浅析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;       
}       
}    
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.

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;       
}       
}    
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.