c# (Socket) asynchronous socket code example

Asynchronous Client Socket Example


The following example program creates a client that connects to the server. The client is built with an asynchronous socket, so the execution of the client application is not suspended while waiting for a response from the server. The application sends a string to the server and then displays the string returned by the server on the console.

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 in stances 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);
Con sole .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;
}
}

That’s it c# (Socket) asynchronous socket code example content, please pay attention to the PHP Chinese website (m.sbmmt.com) for more related content!