C#異步套接字實現(xiàn)是如何的呢？讓我們開始從實例開始：

下面的C#異步套接字實現(xiàn)實例程序創(chuàng)建一個連接到服務(wù)器的客戶端。該客戶端是用C#異步套接字生成的，因此在等待服務(wù)器返回響應(yīng)時不掛起客戶端應(yīng)用程序的執(zhí)行。該應(yīng)用程序?qū)⒆址l(fā)送到服務(wù)器，然后在控制臺顯示該服務(wù)器返回的字符串。

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#異步套接字在服務(wù)器的示例 下面的示例程序創(chuàng)建一個接收來自客戶端的連接請求的服務(wù)器。該服務(wù)器是用C#異步套接字生成的

因此在等待來自客戶端的連接時不掛起服務(wù)器應(yīng)用程序的執(zhí)行。該應(yīng)用程序接收來自客戶端的字符串

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

以發(fā)出表示消息結(jié)尾的信號。

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#異步套接字的相關(guān)內(nèi)容就向你介紹到這里，希望對你了解和學(xué)習(xí)C#異步套接字有所幫助。

【編輯推薦】

1. 基于事件的C#異步編程模式淺析
2. 對委托在C#異步委托和多線程中的理解
3. C#異步委托之委托使用的時機(jī)淺析
4. C#異步通信概念及應(yīng)用淺析
5. C#異步調(diào)用概念及理解淺談