C#异步套接字实现浅析-异步 c#

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#异步套接字生成的

因此在等待来自客户端的连接时不挂起服务器应用程序的执行。该应用程序接收来自客户端的字符串

在控制台显示该字符串，然后将该字符串回显到客户端。来自客户端的字符串必须包含字符串“<EOF>”

以发出表示消息结尾的信号。

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#异步套接字有所帮助。

【编辑推荐】