C#異步套接字實現是如何的呢?讓我們開始從實例開始：

下面的C#異步套接字實現實例程序創建一個連接到服務器的客戶端。該客戶端是用C#異步套接字生成的，因此在等待服務器返回響應時不掛起客戶端應用程序的執行。該應用程序將字符串發送到服務器，然后在控制臺顯示該服務器返回的字符串。

using System;       
using System.Net;       
using System.Net.Sockets;       
using System.Threading;       
using System.Text;       
// State object for receiving data from remote device.       
public class StateObject {       
// Client socket.       
public Socket workSocket = null;       
// Size of receive buffer.       
public const int BufferSize = 256;       
// Receive buffer.       
public byte[] buffer = new byte[BufferSize];       
// Received data string.       
public StringBuilder sb = new StringBuilder();       
}       
public class AsynchronousClient {       
// The port number for the remote device.       
private const int port = 11000;       
// ManualResetEvent instances signal completion.       
private static ManualResetEvent connectDone =       
new ManualResetEvent(false);       
private static ManualResetEvent sendDone =       
new ManualResetEvent(false);       
private static ManualResetEvent receiveDone =       
new ManualResetEvent(false);       
// The response from the remote device.       
private static String response = String.Empty;       
private static void StartClient() {       
// Connect to a remote device.       
try {       
// Establish the remote endpoint for the socket.       
// The name of the       
// remote device is "host.contoso.com".       
IPHostEntry ipHostInfo = Dns.Resolve("host.contoso.com");       
IPAddress ipAddress = ipHostInfo.AddressList[0];       
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);       
// Create a TCP/IP socket.       
Socket client = new Socket(AddressFamily.InterNetwork,       
SocketType.Stream, ProtocolType.Tcp);       
// Connect to the remote endpoint.       
client.BeginConnect( remoteEP,       
new AsyncCallback(ConnectCallback), client);       
connectDone.WaitOne();       
// Send test data to the remote device.       
Send(client,"This is a test< EOF>");       
sendDone.WaitOne();       
// Receive the response from the remote device.       
Receive(client);       
receiveDone.WaitOne();       
// Write the response to the console.       
Console.WriteLine("Response received : {0}", response);       
// Release the socket.       
client.Shutdown(SocketShutdown.Both);       
client.Close();       
} catch (Exception e) {       
Console.WriteLine(e.ToString());       
}       
}       
private static void ConnectCallback(IAsyncResult ar) {       
try {       
// Retrieve the socket from the state object.       
Socket client = (Socket) ar.AsyncState;       
// Complete the connection.       
client.EndConnect(ar);       
Console.WriteLine("Socket connected to {0}",       
client.RemoteEndPoint.ToString());       
// Signal that the connection has been made.       
connectDone.Set();       
} catch (Exception e) {       
Console.WriteLine(e.ToString());       
}       
}       
private static void Receive(Socket client) {       
try {       
// Create the state object.       
StateObject state = new StateObject();       
state.workSocket = client;       
// Begin receiving the data from the remote device.       
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 {       
// Retrieve the state object and the client socket       
// from the asynchronous state object.       
StateObject state = (StateObject) ar.AsyncState;       
Socket client = state.workSocket;       
// Read data from the remote device.       
int bytesRead = client.EndReceive(ar);       
if (bytesRead > 0) {       
// There might be more data, so store the data received so far.       
    
state.sb.Append(Encoding.ASCII.GetString(      
state.buffer,0,bytesRead));       
// Get the rest of the data.       
client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,       
new AsyncCallback(ReceiveCallback), state);       
} else {       
// All the data has arrived; put it in response.       
if (state.sb.Length > 1) {       
response = state.sb.ToString();       
}       
// Signal that all bytes have been received.       
receiveDone.Set();       
}       
} catch (Exception e) {       
Console.WriteLine(e.ToString());       
}       
}       
private static void Send(Socket client, String data) {       
// Convert the string data to byte data using ASCII encoding.       
byte[] byteData = Encoding.ASCII.GetBytes(data);       
// Begin sending the data to the remote device.       
client.BeginSend(byteData, 0, byteData.Length, 0,       
new AsyncCallback(SendCallback), client);       
}       
private static void SendCallback(IAsyncResult ar) {       
try {       
// Retrieve the socket from the state object.       
Socket client = (Socket) ar.AsyncState;       
// Complete sending the data to the remote device.       
int bytesSent = client.EndSend(ar);       
Console.WriteLine("Sent {0} bytes to server.", bytesSent);       
// Signal that all bytes have been sent.       
sendDone.Set();       
} catch (Exception e) {       
Console.WriteLine(e.ToString());       
}       
}       
public static int Main(String[] args) {       
StartClient();       
return 0;       
}       
}    

C#異步套接字在服務器的示例 下面的示例程序創建一個接收來自客戶端的連接請求的服務器。該服務器是用C#異步套接字生成的

因此在等待來自客戶端的連接時不掛起服務器應用程序的執行。該應用程序接收來自客戶端的字符串

在控制臺顯示該字符串，然后將該字符串回顯到客戶端。來自客戶端的字符串必須包含字符串“”

以發出表示消息結尾的信號。

using System;       
using System.Net;       
using System.Net.Sockets;       
using System.Text;       
using System.Threading;       
// State object for reading client data asynchronously       
public class StateObject {       
// Client socket.       
public Socket workSocket = null;       
// Size of receive buffer.       
public const int BufferSize = 1024;       
// Receive buffer.       
public byte[] buffer = new byte[BufferSize];       
// Received data string.       
public StringBuilder sb = new StringBuilder();       
}       
public class AsynchronousSocketListener {       
// Thread signal.       
public static ManualResetEvent allDone =       
new ManualResetEvent(false);       
public AsynchronousSocketListener() {       
}       
public static void StartListening() {       
// Data buffer for incoming data.       
byte[] bytes = new Byte[1024];       
// Establish the local endpoint for the socket.       
// The DNS name of the computer       
// running the listener is "host.contoso.com".       
IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());       
IPAddress ipAddress = ipHostInfo.AddressList[0];       
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);       
// Create a TCP/IP socket.       
Socket listener = new Socket(AddressFamily.InterNetwork,       
SocketType.Stream, ProtocolType.Tcp );       
// Bind the socket to the local       
//endpoint and listen for incoming connections.       
try {       
listener.Bind(localEndPoint);       
listener.Listen(100);       
while (true) {       
// Set the event to nonsignaled state.       
allDone.Reset();       
// Start an asynchronous socket to listen for connections.       
Console.WriteLine("Waiting for a connection...");       
listener.BeginAccept(       
new AsyncCallback(AcceptCallback),       
listener );       
// Wait until a connection is made before continuing.       
allDone.WaitOne();       
}       
} catch (Exception e) {       
Console.WriteLine(e.ToString());       
}       
Console.WriteLine("\nPress ENTER to continue...");       
Console.Read();       
}       
public static void AcceptCallback(IAsyncResult ar) {       
// Signal the main thread to continue.       
allDone.Set();       
// Get the socket that handles the client request.       
Socket listener = (Socket) ar.AsyncState;       
Socket handler = listener.EndAccept(ar);       
// Create the state object.       
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;       
// Retrieve the state object and the handler socket       
// from the asynchronous state object.       
StateObject state = (StateObject) ar.AsyncState;       
Socket handler = state.workSocket;       
// Read data from the client socket.       
int bytesRead = handler.EndReceive(ar);       
if (bytesRead > 0) {       
// There might be more data, so store the data received so far.       
state.sb.Append(Encoding.ASCII.GetString(       
state.buffer,0,bytesRead));       
// Check for end-of-file tag. If it is not there, read       
// more data.       
content = state.sb.ToString();       
if (content.IndexOf("< EOF>") > -1) {       
// All the data has been read from the       
// client. Display it on the console.       
Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",       
content.Length, content );       
// Echo the data back to the client.       
Send(handler, content);       
} else {       
// Not all data received. Get more.       
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,       
new AsyncCallback(ReadCallback), state);       
}       
}       
}       
private static void Send(Socket handler, String data) {       
// Convert the string data to byte data using ASCII encoding.       
byte[] byteData = Encoding.ASCII.GetBytes(data);       
// Begin sending the data to the remote device.       
handler.BeginSend(byteData, 0, byteData.Length, 0,       
new AsyncCallback(SendCallback), handler);       
}       
private static void SendCallback(IAsyncResult ar) {       
try {       
// Retrieve the socket from the state object.       
Socket handler = (Socket) ar.AsyncState;       
// Complete sending the data to the remote device.       
int bytesSent = handler.EndSend(ar);       
Console.WriteLine("Sent {0} bytes to client.", bytesSent);       
handler.Shutdown(SocketShutdown.Both);       
handler.Close();       
} catch (Exception e) {       
Console.WriteLine(e.ToString());       
}       
}       
public static int Main(String[] args) {       
StartListening();       
return 0;       
}       
}    

C#異步套接字的相關內容就向你介紹到這里，希望對你了解和學習C#異步套接字有所幫助。

【編輯推薦】

1. 總結C#語言命名規范
2. C#反射相關知識學習
3. 大話F#和C#：是否會重蹈C#失敗的覆轍？
4. 總結和學習C#接口
5. 學習C#程序有感