Esistono diversi modi per raggiungere questo scopo ed uno dei più rapidi ci viene offerto dalla versione 2.0 del .NET Framework con la classe IPGlobalProperties (namespace System.Net.NetworkInformation), in particolare sfruttando il metodo statico GetIPGlobalProperties().

Con l’esempio riportato di seguito è possibile ricavare lo stato di tutte le connessioni Tcp e Udp attraverso un’istanza della classe IPGlobalProperties, la quale ci metterà a disposizione vari metodi, tra cui quelli che più ci interessano:

• TCP attive: GetActiveTcpConnections(); restituisce una matrice di tipo TcpConnectionInformation
• TCP in ascolto: GetActiveTcpListeners(); restituisce una matrice di tipo IPEndPoint
• UDP: GetActiveUdpListeners(); restituisce una matrice di tipo IPEndPoint

L’oggetto IPGlobalProperties lo otteniamo attraverso una chiamata al metodo statico GetIPGlobalProperties().
Ottenuta l’istanza, chiameremo i metodi sopra citati e attraverso gli oggetti restituiti (matrici di tipo TcpConnectionInformation e IPEndPoint) avremo accesso ai vari stati delle nostre connessioni.

using System.Net.NetworkInformation;  

namespace Sergio79
{
    public class SocketsInfo
    {
        private TcpConnectionInformation[] activeTcp;  //connessioni tcp attive
        private System.Net.IPEndPoint[] listenTcp;       //connessioni tcp in ascolto
        private System.Net.IPEndPoint[] udp;              //connessioni udp (tutte)  

        //Proprietà: elenco proprietà di sola lettura
        public int LengthActiveTcp
        {
            get { try { return activeTcp.Length; } catch { return 0; } }
        }  

        public int LengthListenTcp
        {
            get { try { return listenTcp.Length; } catch { return 0; } }
        }  

        public int LengthUdp
        {
            get { try { return udp.Length; } catch { return 0; } }
        }  

        //Costruttore: inizializzo i campi
        public SocketsInfo()
        {
            GetAll();
        }  

        //Metodo: inizializza e aggiorna tutti i campi
        private void GetAll()
        {
            try
            {
                activeTcp = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections();
                listenTcp = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpListeners();
                udp = IPGlobalProperties.GetIPGlobalProperties().GetActiveUdpListeners();
            }
            catch { }
        }  

        //Aggiornamento informazioni sockets
        public void Update()
        {
            GetAll();
        }  

        //Metodo: restituzione matrice string per info connessioni tcp attive
        public string[,] GetActiveTcp()
        {
            try
            {
                string[,] infoActiveTcp = new string[activeTcp.Length, 4];  

                for (int i = 0; i < activeTcp.Length; i++)
                {
                    infoActiveTcp[i, 0] = "Tcp";
                    infoActiveTcp[i, 1] = activeTcp[i].LocalEndPoint.ToString();
                    infoActiveTcp[i, 2] = activeTcp[i].RemoteEndPoint.ToString();
                    infoActiveTcp[i, 3] = activeTcp[i].State.ToString();
                }  

                return infoActiveTcp;
            }
            catch { return null; }
        }  

        //Metodo: restituzione matrice string per info connessioni tcp in ascolto
        public string[,] GetListenTcp()
        {
            try
            {
                string[,] infoListenTcp = new string[listenTcp.Length, 4];  

                for (int i = 0; i < listenTcp.Length; i++)
                {
                    infoListenTcp[i, 0] = "Tcp";
                    infoListenTcp[i, 1] = listenTcp[i].ToString();
                    infoListenTcp[i, 2] = "0.0.0.0:0";
                    infoListenTcp[i, 3] = "Listening";
                }  

                return infoListenTcp;
            }
            catch { return null; }
        }  

        //Metodo: restituzione matrice string per info connessioni udp
        public string[,] GetUdp()
        {
            try
            {
                string[,] infoUdp = new string[udp.Length, 3];  

                for (int i = 0; i < udp.Length; i++)
                {
                    infoUdp[i, 0] = "Udp";
                    infoUdp[i, 1] = udp[i].ToString();
                    infoUdp[i, 2] = "*:*";
                }  

                return infoUdp;
            }
            catch { return null; }
        }  

        //Metodo: visualizzo lo stato di connessione su porta specifica
        public string ConnectedUserOnTcp(int port)
        {
            try
            {
                GetAll();  

                for (int i = 0; i < activeTcp.Length; i++)
                {
                    //trovo la porta
                    if (activeTcp[i].LocalEndPoint.Port == port)
                    {
                        //verifico se lo stato è attivo
                        if (activeTcp[i].State == TcpState.Established)
                        {
                            return "User: " + activeTcp[i].RemoteEndPoint.Address.ToString();
                        }
                    }
                }  

                return "User: No-one";
            }
            catch { return "User: Error - Unknow"; }
        }
    }
}

Uno dei possibili utilizzi di questa classe può trovare riscontro in applicazioni di tipo client-server che sfruttino oggetti Socket su protocollo Tcp. Quasi sempre infatti, capita di voler essere costantemente aggiornati sullo stato di connessione diretta della nostra applicazione, ad esempio durante uno stato di attesa di invio o ricezione dati.

Benché in questi casi Microsoft consigli la verifica dei NativeErrocCode in seguito a chiamate non bloccanti al metodo Send(..) a zero byte, l’esito potrebbe non essere veritiero: client o server potrebbero terminare la loro esezuione in modo anomalo (e non solo), impostando lo stato di connessione ad esempio su Time_Wait o Fin_Wait, dove di fatto non vi sarebbe più una comunicazione diretta tra le due applicazioni, ma ciò non risulterebbe dal NativeErrorCode.

Ecco allora che può venirci in aiuto il metodo ConnectedUserOnTcp(int port), verificando proprio lo stato di connessione e dando esito positivo (attraverso una stringa, ma modificando opportunamente il codice anche tramite un valore di tipo bool) soltanto nel caso in cui essa risulti come “Established”.

Condivi questo articolo: