Exemple de code de socket asynchrone c# (Socket)

Exemple de socket client asynchrone


L'exemple de programme suivant crée un client qui se connecte au serveur. Le client est construit avec un socket asynchrone, donc l'exécution de l'application client n'est pas suspendue en attendant une réponse du serveur. L'application envoie une chaîne au serveur puis affiche la chaîne renvoyée par le serveur sur la console.

C#

en utilisant System ;
en utilisant System.Net
en utilisant System.Net.Sockets ;
en utilisant System.Threading ;
// Objet d'état pour recevoir des données d'un appareil distant.
public class StateObject {
// Socket client
public Socket workSocket = null; >public const int BufferSize = 256;
// Tampon de réception
public byte[] buffer = new byte[BufferSize];// Chaîne de données reçue
public StringBuilder sb = new StringBuilder( );
}
public class AsynchronousClient {
// Le numéro de port du périphérique distant
private const int port = 11000;// Les instances ManualResetEvent
private. static ManualResetEvent connectDone =
new ManualResetEvent(false);
private static ManualResetEvent sendDone =
new ManualResetEvent(false);
private static ManualResetEvent recevoirDone =
new ManualResetEvent(false ); // La réponse de l'appareil distant.
private static String réponse = String.Empty;
private static void StartClient() {
// Connectez-vous à un appareil distant. // Établit le point de terminaison distant pour le socket.
// Le nom du
// périphérique distant est "host.contoso.com".
IPHostEntry ipHostInfo = Dns.Resolve("host.contoso. com");
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
// Créer un socket TCP/IP.
Socket client = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
// Connectez-vous au point de terminaison distant
client.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
// Envoyer les données de test à l'appareil distant
Send(client,"Ceci est un test"); 🎜>// Recevez la réponse de l'appareil distant
Receive(client);
receiveDone.WaitOne();
// Écrivez la réponse sur la console
Console.WriteLine("Response). reçu : {0}", réponse);
// Libérez le socket.
client.Shutdown(SocketShutdown.Both);
client.Close();
} catch (Exception e) {
Console.WriteLine(e.ToString());
}
}
private static void ConnectCallback(IAsyncResult ar) {
try {
// Récupérer le socket de l'état object.
Socket client = (Socket) ar.AsyncState;
// Terminez la connexion
client.EndConnect(ar);
Console.WriteLine("Socket connecté à {0}",
client.RemoteEndPoint.ToString());
// Signale que la connexion a été établie
connectDone.Set();
} catch (Exception e) {
Console.WriteLine. (e.ToString());
}
}
private static void Receiver (Socket client) {
try {
// Créer l'objet d'état
StateObject state = new. StateObject();
state.workSocket = client
// Commencez à recevoir les données de l'appareil distant
.client.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, 
new AsyncCallback(ReceiveCallback), state); 
} catch (Exception e) { 
Console.WriteLine(e.ToString()); 
} 
} 
private static void ReceiveCallback( IAsyncResult ar ) { 
essayez { 
// Récupérez l'objet d'état et le socket client   
// de l'objet d'état asynchrone. 
StateObject state = (StateObject) ar.AsyncState ; 
Socket client = state.workSocket ; 
// Lire les données de l'appareil à distance. 
int bytesRead = client.EndReceive(ar); 
if (bytesRead > 0) { 
// Il pourrait y avoir plus de données, alors stockez les données reçues jusqu'à présent. 
state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead)); 
// Obtenez le reste des données. 
client.BeginReceive(state.buffer,0,StateObject.BufferSize,0, 
new AsyncCallback(ReceiveCallback), state); 
} else { 
// Toutes les données sont arrivées ; mettez le en réponse. 
if (state.sb.Length > 1) { 
response = state.sb.ToString(); 
} 
// Signal que tous les octets ont été reçus. 
receiveDone.Set(); 
} 
} catch (Exception e) { 
Console.WriteLine(e.ToString()); 
} 
} 
private static void Send (client Socket, String data) { 
// Convertissez les données de chaîne en données d'octets à l'aide de l'encodage ASCII. 
byte[] byteData = Encoding.ASCII.GetBytes(data); 
// Commencez à envoyer les données à l'appareil distant. 
client.BeginSend(byteData, 0, byteData.Length, 0, 
new AsyncCallback(SendCallback), client); 
} 
private static void SendCallback(IAsyncResult ar) { 
essayez { 
// Récupérez le socket de l'objet d'état. 
Socket client = (Socket) ar.AsyncState ; 
// Terminez l'envoi des données à l'appareil distant. 
int bytesSent = client.EndSend(ar); 
Console.WriteLine("Envoyé {0} octets au serveur.", bytesSent); 
// Signal que tous les octets ont été envoyés. 
sendDone.Set(); 
} catch (Exception e) { 
Console.WriteLine(e.ToString()); 
} 
} 
public static int Main(String[] args) { 
StartClient(); 
retour 0 ; 
} 
} 
异步服务器套接字示例 下面的示例程序创建一个接收来自客户端的连接请求的服务器。该服务器是用异步套接字生成的， 
因此在等待来自客户端的连接时不挂起服务器应用程序的执行。该应用程序接收来自客户端的字符串， 
在控制台显示该字符串，然后将该字符串回显到客户端。来自客户端的字符串必须包含字符串“”, 
以发出表示消息结尾的信号。 



  




C#
 复制代码 

en utilisant Système ; 
en utilisant System.Net ; 
en utilisant System.Net.Sockets ; 
en utilisant System.Text ; 
en utilisant System.Threading ; 
// Objet d'état pour lire les données clients de de manière asynchrone 
classe publique StateObject { 
// Socket client. 
public Socket workSocket = null ; 
// Taille du tampon de réception. 
public const int BufferSize = 1024 ; 
// Recevoir le tampon. 
public byte[] buffer = nouvel octet[BufferSize] ; 
// Chaîne de données reçues. 
public StringBuilder sb = new StringBuilder(); 
} 
classe publique AsynchronousSocketListener { 
// Signal thread. 
public static ManualResetEvent allDone = new ManualResetEvent(false); 
public AsynchronousSocketListener() { 
} 
public static void StartListening() { 
// Tampon de données pour les données entrantes. 
octet[] octets = nouvel octet[1024] ; 
// Établir le point de terminaison local pour le socket. 
// Le nom DNS de l'ordinateur 
// qui exécute l'écouteur est "host.contoso.com". 
IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()); 
IPAddress ipAddress = ipHostInfo.AddressList[0] ; 
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000); 
// Créez un socket TCP/IP . 
Socket listener = new Socket(AddressFamily.InterNetwork, 
SocketType.Stream, ProtocolType.Tcp ); 
// Liez le socket au point de terminaison local et écoutez les connexions entrantes. 
essayez { 
listener.Bind(localEndPoint); 
listener.Listen(100); 
while (true) { 
// Définissez l'événement à l'état non signalé. 
allDone.Reset(); 
// Démarrez un socket asynchrone pour écouter les connexions. 
Console.WriteLine("En attente d'une connexion..."); 
listener.BeginAccept( 
new AsyncCallback(AcceptCallback), 
listener ); 
// Attendez qu'une connexion soit établie avant de continuer. 
allDone.WaitOne(); 
} 
} catch (Exception e) { 
Console.WriteLine(e.ToString()); 
} 
Console.WriteLine("nAppuyez sur ENTER pour continuer..."); 
Console.Read(); 
} 
public static void AcceptCallback(IAsyncResult ar) { 
// Signalez au thread principal pour continuer. 
allDone.Set(); 
// Récupérez le socket qui gère la demande du client. 
Socket écouteur = (Socket) ar.AsyncState ; 
Socket handler = listener.EndAccept(ar); 
// Créez l'objet d'état. 
StateObject state = new StateObject(); 
state.workSocket = gestionnaire ; 
handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, 
new AsyncCallback(ReadCallback), state); 
} 
public static void ReadCallback(IAsyncResult ar) { 
String content = String.Empty ; 
// Récupérez l'objet d'état et le socket de gestionnaire 
// de l'objet d'état asynchrone. 
StateObject state = (StateObject) ar.AsyncState ; 
Gestionnaire de socket = state.workSocket ; 
// Lire les données de le socket client.  
int bytesRead = handler.EndReceive(ar); 
if (bytesRead > 0) { 
// Il  pourrait y avoir plus de données, alors stockez les données reçues jusqu'à présent. 
state.sb.Append(Encoding.ASCII.GetString( 
state.buffer,0,bytesRead)); 
// Vérifiez la balise de fin de fichier. Si ce n'est pas là, lisez   
// plus de données. 
content = state.sb.ToString(); 
if (content.IndexOf("") > -1) { 
// Toutes les données ont été lues à partir du   
// client. Affichez-le sur la console. 
Console.WriteLine("Lire {0} octets de socket. n Data : {1}", 
content.Length, content ); 
// Répercuter les données au client. 
Envoyer(gestionnaire, contenu) ; 
} else { 
// Toutes les données n'ont pas été reçues. Obtenez plus. 
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
new AsyncCallback(ReadCallback), state); 
} 
} 
} 
private static void Send (gestionnaire de socket, données de chaîne) { 
// Convertissez les données de chaîne en données d'octets à l'aide de l'encodage ASCII. 
byte[] byteData = Encoding.ASCII.GetBytes(data);
// Commencez à envoyer les données au périphérique distant
handler.BeginSend(byteData, 0, byteData.Length, 0,
new AsyncCallback. (SendCallback), handler);
}
private static void SendCallback(IAsyncResult ar) {
try {
// Récupère le socket de l'objet d'état
Socket handler = (Socket) ar.AsyncState;
// Terminez l'envoi des données au périphérique distant
int bytesSent = handler.EndSend(ar);
Console.WriteLine("Envoyé {0} octets au client.", bytesSent );
handler.Shutdown(SocketShutdown.Both);
handler.Close();
} catch (Exception e) {
Console.WriteLine(e.ToString()); }
}
public static int Main(String[] args) {
StartListening();
return 0
}
}