c# (Socket) asynchroner Socket-Codebeispiel

Beispiel für einen asynchronen Client-Socket


Das folgende Beispielprogramm erstellt einen Client, der eine Verbindung zum Server herstellt. Der Client ist mit einem asynchronen Socket ausgestattet, sodass die Ausführung der Clientanwendung nicht angehalten wird, während auf die Rückgabe einer Antwort vom Server gewartet wird. Die Anwendung sendet eine Zeichenfolge an den Server und zeigt dann die vom Server zurückgegebene Zeichenfolge auf der Konsole an.

C#

using System.Net;
using System.Net.Sockets;
using System.Text;
// Statusobjekt zum Empfangen von Daten vom Remote-Gerät
// Client-Socket = null; >public const int BufferSize = 256;
// Empfangspuffer
public byte[] buffer = new byte[BufferSize];
public StringBuilder( );
}
public class AsynchronousClient {
// Die Portnummer für das Remote-Gerät
private const int port = 11000;
// ManualResetEvent-Instanzen signalisieren den Abschluss static ManualResetEvent connectDone =
new ManualResetEvent(false);
private static ManualResetEvent(false);
private static ManualResetEvent(false); // Die Antwort vom Remote-Gerät.
private static String Response = String.Empty;
private static void StartClient() {
// Mit einem Remote-Gerät verbinden
// Richten Sie den Remote-Endpunkt für den Socket ein.
// Der Name des
// Remote-Geräts ist „host.contoso.com“.
IPHostEntry ipHostInfo = Dns.Resolve("host.contoso. com");
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
// Erstellen Sie einen TCP/IP-Socket.
Socket-Client = neu Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
// Mit dem Remote-Endpunkt verbinden
client.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
// Testdaten an das Remote-Gerät senden
Send(client,"This is a test"); 🎜>// Empfangen Sie die Antwort vom Remote-Gerät.
receiveDone.WaitOne();
// Schreiben Sie die Antwort auf die Konsole erhalten: {0}", Antwort);
// Den Socket freigeben.
client.Shutdown(SocketShutdown.Both);
client.Close();
} Catch (Exception e) {
Console.WriteLine(e.ToString());
}
}
private static void ConnectCallback(IAsyncResult ar) {
try {
// Abrufen des Sockets aus dem Status object.
Socket client = (Socket) ar.AsyncState;// Vervollständigen Sie die Verbindung
client.EndConnect(ar);
Console.WriteLine("Socket verbunden mit {0}",
client.RemoteEndPoint.ToString());
// Signalisieren, dass die Verbindung hergestellt wurde
connectDone.Set();
} Catch (Ausnahme e) {
Console.WriteLine (e.ToString());
}
}
private static void Receive(Socket client) {
try {
// Erstelle das Statusobjekt = new StateObject();
state.workSocket = client;
// Beginnen Sie mit dem Empfang der Daten vom Remote-Gerät
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 ) { 
try{ 
// Rufe das Statusobjekt und den Client-Socket  
// vom asynchronen Statusobjekt ab. 
StateObject state = (StateObject) ar.AsyncState; 
Socket client = state.workSocket; 
// Daten vom Remotegerät lesen. 
int bytesRead = client.EndReceive(ar); 
if (bytesRead > 0) { 
// Es könnten mehr Daten vorhanden sein, also speichern Sie die bisher empfangenen Daten. 
state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead)); 
// Rufen Sie den Rest der Daten ab. 
client.BeginReceive(state.buffer,0,StateObject.BufferSize,0, 
new AsyncCallback(ReceiveCallback), state); 
} else { 
// Alle Daten sind  angekommen; setze es als Antwort. 
if (state.sb.Length > 1) { 
response = state.sb.ToString(); 
} 
// Signalisieren, dass alle Bytes empfangen wurden. 
receiveDone.Set(); 
} 
} catch (Exception e) { 
Console.WriteLine(e.ToString()); 
} 
} 
private static void Send(Socket-client, String-data) { 
// Konvertiert die String-Daten in Byte-Daten mithilfe der ASCII-Codierung. 
byte[] byteData = Encoding.ASCII.GetBytes(data); 
// Beginnen Sie mit dem Senden der Daten an das Remote-Gerät. 
client.BeginSend(byteData, 0, byteData.Length, 0, 
new AsyncCallback(SendCallback), client); 
} 
private static void SendCallback(IAsyncResult ar) { 
try { 
// Den Socket vom Statusobjekt abrufen. 
Socket client = (Socket) ar.AsyncState; 
// Schließen Sie das Senden der Daten an das Remote-Gerät ab. 
int bytesSent = client.EndSend(ar); 
Console.WriteLine("Sende {0} Bytes an Server.", bytesSent); 
// Signal, dass alle Bytes gesendet wurden. 
sendDone.Set(); 
} catch (Exception e) { 
Console.WriteLine(e.ToString()); 
} 
} 
public static int Main(String[] args) { 
StartClient(); 
return 0; 
} 
} 
异步服务器套接字示例 下面的示例程序创建一个接收来自客户端的连接请求的服务器.该服务器是用异步套接字生成的, 
因此在等待来自客户端的连接时不挂起服务器应用程序的执行.该应用程序接收来自客户端的字符串， 
在控制台显示该字符串,然后将该字符串回显到客户端.来自客户端的字符串„“ >
C#
 复制代码 

using System; 
mit System.Net; 
mit System.Net.Sockets; 
mit System.Text; 
mit System.Threading; 
// Statusobjekt zum asynchronen Lesen von Clientdaten 
öffentliche Klasse StateObject { 
// Client-Socket. 
public Socket workSocket = null; 
// Größe des Empfangspuffers. 
public const int BufferSize = 1024; 
// Empfangspuffer. 
public byte[] buffer = new byte[BufferSize]; 
// Empfangene Datenzeichenfolge. 
public StringBuilder sb = new StringBuilder(); 
} 
öffentliche Klasse AsynchronousSocketListener { 
// Thread-Signal. 
public static ManualResetEvent allDone = new ManualResetEvent(false); 
public AsynchronousSocketListener() { 
} 
public static void StartListening() { 
// Datenpuffer für eingehende Daten. 
byte[] bytes = neues Byte[1024]; 
// Den lokalen Endpunkt für den Socket einrichten. 
// Der DNS-Name des Computers 
// auf dem der Listener ausgeführt wird, lautet „host.contoso.com“. 
IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()); 
IPAddress ipAddress = ipHostInfo.AddressList[0]; 
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000); 
// Erstellen einen TCP/IP-Socket. 
Socket-Listener = neuer Socket(AddressFamily.InterNetwork, 
SocketType.Stream, ProtocolType.Tcp ); 
// Binden Sie den Socket an den lokalen Endpunkt und warten Sie auf eingehende Verbindungen. 
versuchen Sie es mit { 
listener.Bind(localEndPoint); 
listener.Listen(100); 
while (true) { 
// Das Ereignis auf den nicht signalisierten Status setzen. 
allDone.Reset(); 
// Starten Sie einen asynchronen Socket, um auf Verbindungen zu warten. 
Console.WriteLine("Warten auf eine Verbindung..."); 
listener.BeginAccept( 
new AsyncCallback(AcceptCallback), 
listener ); 
// Warten Sie, bis eine Verbindung hergestellt wurde, bevor Sie fortfahren. 
allDone.WaitOne(); 
} 
} catch (Exception e) { 
Console.WriteLine(e.ToString()); 
} 
Console.WriteLine("nPress ENTER to continue..."); 
Console.Read(); 
} 
public static void AcceptCallback(IAsyncResult ar) { 
// Signalisiert dem Hauptthread, fortzufahren. 
allDone.Set(); 
// Holen Sie sich den Socket, der die Client-Anfrage verarbeitet. 
Socket listener = (Socket) ar.AsyncState; 
Socket handler = listener.EndAccept(ar); 
// Erstellen das Statusobjekt. 
StateObject state = new StateObject(); 
state.workSocket = handler; 
handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, 
new AsyncCallback(ReadCallback), state); 
} 
public static void ReadCallback(IAsyncResult ar) { 
String content = String.Empty; 
// Rufen das Statusobjekt und den Handler-Socket 
// vom asynchronen Statusobjekt ab. 
StateObject state = (StateObject) ar.AsyncState; 
Socket handler = state.workSocket; 
// Daten aus dem Client-Socket lesen.  
int bytesRead = handler.EndReceive(ar); 
if (bytesRead > 0) { 
// Es könnten mehr Daten vorhanden sein. Speichern Sie daher die bisher empfangenen Daten. 
state.sb.Append(Encoding.ASCII.GetString( 
state.buffer,0,bytesRead)); 
// Auf Dateiende-Tag prüfen. Wenn es nicht vorhanden ist, lesen  
// weitere Daten. 
content = state.sb.ToString(); 
if (content.IndexOf("") > -1) { 
// Alle Daten wurden vom  
// Client gelesen. Zeigen Sie es auf der Konsole an. 
Console.WriteLine("Lesen {0} Bytes aus Socket. n Daten : {1}", 
content.Length, content ); 
// Senden Sie die Daten an den Client zurück. 
Send(handler, content); 
} else { 
// Nicht alle Daten empfangen. Holen Sie sich mehr. 
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
new AsyncCallback(ReadCallback), state); 
} 
} 
} 
private static void Send(Socket handler, String data) { 
// Konvertieren die String-Daten in Byte-Daten mithilfe der ASCII-Codierung. 
byte[] byteData = Encoding.ASCII.GetBytes(data);
// Beginnen Sie mit dem Senden der Daten an das Remote-Gerät
handler.BeginSend(byteData, 0, byteData.Length, 0,
new AsyncCallback (SendCallback), handler);
}
private static void SendCallback(IAsyncResult ar) {
try {
// Abrufen des Sockets vom Statusobjekt
Socket handler = (Socket) ar.AsyncState;
// Schließen Sie das Senden der Daten an das Remote-Gerät ab.
int bytesSent = handler.EndSend(ar);
Console.WriteLine("Sende {0} Bytes an den Client );
handler.Shutdown(SocketShutdown.Both);
handler.Close() }
}
public static int Main(String[] args) {
StartListening();
return 0;
}

Das Obige ist c# (Socket) Beispiele für asynchronen Socket-Code. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!