Fonctions asynchrones et sockets en .NET

Pour attendre une connexion, il faut utiliser la fonction BeginAccept. Avant de faire appel à BeginAccept, il faut lancer l'écoute sur le port voulu. Cela se fait grâce à la fonction Bind. Cette fonction prend comme argument un objet IPEndPoint. Pour finir le lancement de l'écoute, il faut faire appel à la fonction Listen. Cette fonction est non bloquante.

Socket SocketServer = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
                
SocketServer.Bind(new IPEndPoint(« 192.168.0.1 »,15));
SocketServer.Listen(1);

Je ne reviendrai pas sur le constructeur d'un socket (ceci est développé dans un article sur développez.com ) Le constructeur d' IPEndPoint prend comme argument une adresse IP et un numéro de port. La fonction Listen prend comme argument le nombre de connexions entrantes que le serveur peut mettre en file d'attente pour acceptation. C'est-à-dire que si vous passez 1 à Listen et que trois clients se présentent en même temps, les deux derniers seront automatiquement refusés avant même l'examen de la demande par le socket serveur. Après avoir lancé l'écoute sur le port voulu grâce aux fonctions Bind et Listen il faut lancer l'attente de la connexion grâce à la fonction BeginAccept.

void BeginAccept(AsyncCallback CallBack, object obj)

SocketServer.BeginAccept(new AsyncCallback(this.connexionAcceptCallback),SocketServer);

Le deuxième argument sera passé à la fonction connexionCallback, lorsque celle-ci sera appelée, à travers la propriété AsyncState de IAsyncResult. Le premier argument est un objet de type AsyncCallback. AsyncCallback est un délégué, qui est le terme en .NET pour désigner un pointeur de fonction. Le constructeur prend comme argument une fonction ayant cette signature :

void connexionCallback(IAsyncResult asyncResult)

Retenez bien cette signature, car elle servira pour toutes les fonctions de rappel des autres fonctions asynchrones. La fonction connexionCallback s'exécute dans un Thread séparé de celui de l'application principale (thread lancé par le système). Cette fonction prend comme argument un type IAsyncResult. L'interface IAsyncResult nous permet de retrouver l'objet que nous avons passé à la fonction BeginAccept tel qu'il était à travers sa propriété AsyncState.

object asyncResult.AsyncState

Pour finir l'attente d'une connexion et pour finir d'accepter la connexion d'un client, vous devez appeler la fonction EndAccept.

private void connexionAcceptCallback(IAsyncResult asyncResult)
{
    SocketClient = SocketServer.EndAccept(asyncResult);
}

EndAccept renvoie le socket avec lequel nous allons pouvoir envoyer les données vers le client. À partir de ce moment, la connexion est établie entre le serveur et le client.

Pour le client, le but va être de se connecter au serveur et d'envoyer des messages à celui-ci. Pour se connecter au serveur, nous allons utiliser la fonction BeginConnect

SocketClient.BeginConnect(new IPEndPoint(« 192.168.0.2 »,15), new AsyncCallback(connexionConnectCallback), SocketClient);

Par rapport au serveur il n'y a rien de nouveau dans cette partie. Pour que la connexion soit complète, il faut faire appel à la fonction EndConnect

private void connexionConnectCallback(IAsyncResult asyncResult)
{
    SocketClient.EndConnect(asyncResult);
}

Pour se mettre en attente d'un message, nous allons utiliser la fonction BeginReceive

void BeginReceive(byte[] buffer, int offset, int size, SocketFlags socketFlags, AsyncCallback asyncCallback, object state)

SocketClient.BeginReceive(buf,0,buf.Length,SocketFlags.none,new AsyncCallback(ReceiveCallback),SocketClient);

Voici la fonction de rappel pour l'attente d'un message :

private void ReceiveCallback(IAsyncResult asyncResult)
{
    int read = SocketClient.EndReceive(asyncResult);
}

EndReceive renvoie le nombre d'octets reçus.

Pour envoyer un message, il faut utiliser la fonction BeginSend. Voici sa signature :

void BeginSend(byte[] buffer,int offset,int BufferLenght,SocketFlags socketFlags,AsyncCallback asyncCallBack,object state);

et voici comment l'utiliser :

SocketClient.BeginSend(buf,0,buf.Length,SocketFlags.none,new AsyncCallback(SendCallback),SocketClient);

Pour finir d'envoyer des données de façon asynchrone, vous devez dans la méthode de rappel appeler la fonction EndSend.

private void SendCallback(IAsyncResult asyncResult)
{
    int send = SocketClient.EndSend(asyncResult);
}

EndSend renvoie le nombre d'octets envoyés.

Le socket client qui souhaite fermer la connexion doit faire un Shutdown puis un Close.

SocketClient.Shutdown(SocketShutdow.Both);
SocketClient.Close();

Notez que l'appel de shutdown ou close met fin à toute les E/S en attente en cours, et les fonctions de rappel correspondantes sont appelées. Pour le serveur il suffit de faire à appel à la fonction Close des sockets

SocketServer.Close();