c#(Socket)异步套接字代码示例

异步客户端套接字示例   


下面的示例程序创建一个连接到服务器的客户端。该客户端是用异步套接字生成的，因此在等待服务器返回响应时不挂起客户端应用程序的执行。该应用程序将字符串发送到服务器，然后在控制台显示该服务器返回的字符串。 

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"); 
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# 
 复制代码 

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("") > -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#(Socket)异步套接字代码示例的内容，更多相关内容请关注PHP中文网（www.php.cn）！