1. using System; 
2. using System.Net; 
3. using System.Net.Sockets; 
4. using System.Threading; 
5. using System.Text; 
6. // State object for receiving data from remote device. 
7. public class StateObject { 
8. // Client socket. 
9. public Socket workSocket = null; 
10. // Size of receive buffer. 
11. public const int BufferSize = 256; 
12. // Receive buffer. 
13. public byte[] buffer = new byte[BufferSize]; 
14. // Received data string. 
15. public StringBuilder sb = new StringBuilder(); 
16. } 
17. public class AsynchronousClient { 
18. // The port number for the remote device. 
19. private const int port = 11000; 
20. // ManualResetEvent instances signal completion. 
21. private static ManualResetEvent connectDone = 
22. new ManualResetEvent(false); 
23. private static ManualResetEvent sendDone = 
24. new ManualResetEvent(false); 
25. private static ManualResetEvent receiveDone = 
26. new ManualResetEvent(false); 
27. // The response from the remote device. 
28. private static String response = String.Empty; 
29. private static void StartClient() { 
30. // Connect to a remote device. 
31. try { 
32. // Establish the remote endpoint for the socket. 
33. // The name of the  
34. // remote device is "host.contoso.com". 
35. IPHostEntry ipHostInfo = Dns.Resolve("host.contoso.com"); 
36. IPAddress ipAddress = ipHostInfo.AddressList[0]; 
37. IPEndPoint remoteEP = new IPEndPoint(ipAddress, port); 
38. // Create a TCP/IP socket. 
39. Socket client = new Socket(AddressFamily.InterNetwork, 
40. SocketType.Stream, ProtocolType.Tcp); 
41. // Connect to the remote endpoint. 
42. client.BeginConnect( remoteEP, 
43. new AsyncCallback(ConnectCallback), client); 
44. connectDone.WaitOne(); 
45. // Send test data to the remote device. 
46. Send(client,"This is a test"); 
47. sendDone.WaitOne(); 
48. // Receive the response from the remote device. 
49. Receive(client); 
50. receiveDone.WaitOne(); 
51. // Write the response to the console. 
52. Console.WriteLine("Response received : {0}", response); 
53. // Release the socket. 
54. client.Shutdown(SocketShutdown.Both); 
55. client.Close(); 
56. } catch (Exception e) { 
57. Console.WriteLine(e.ToString()); 
58. } 
59. } 
60. private static void ConnectCallback(IAsyncResult ar) { 
61. try { 
62. // Retrieve the socket from the state object. 
63. Socket client = (Socket) ar.AsyncState; 
64. // Complete the connection. 
65. client.EndConnect(ar); 
66. Console.WriteLine("Socket connected to {0}", 
67. client.RemoteEndPoint.ToString()); 
68. // Signal that the connection has been made. 
69. connectDone.Set(); 
70. } catch (Exception e) { 
71. Console.WriteLine(e.ToString()); 
72. } 
73. } 
74. private static void Receive(Socket client) { 
75. try { 
76. // Create the state object. 
77. StateObject state = new StateObject(); 
78. state.workSocket = client; 
79. // Begin receiving the data from the remote device. 
80. client.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, 
81. new AsyncCallback(ReceiveCallback), state); 
82. } catch (Exception e) { 
83. Console.WriteLine(e.ToString()); 
84. } 
85. } 
86. private static void ReceiveCallback( IAsyncResult ar ) { 
87. try { 
88. // Retrieve the state object and the client socket  
89. // from the asynchronous state object. 
90. StateObject state = (StateObject) ar.AsyncState; 
91. Socket client = state.workSocket; 
92. // Read data from the remote device. 
93. int bytesRead = client.EndReceive(ar); 
94. if (bytesRead > 0) { 
95. // There might be more data, so store the data received so far. 
96. state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead)); 
97. // Get the rest of the data. 
98. client.BeginReceive(state.buffer,0,StateObject.BufferSize,0, 
99. new AsyncCallback(ReceiveCallback), state); 
100. } else { 
101. // All the data has arrived; put it in response. 
102. if (state.sb.Length > 1) { 
103. response = state.sb.ToString(); 
104. } 
105. // Signal that all bytes have been received. 
106. receiveDone.Set(); 
107. } 
108. } catch (Exception e) { 
109. Console.WriteLine(e.ToString()); 
110. } 
111. } 
112. private static void Send(Socket client, String data) { 
113. // Convert the string data to byte data using ASCII encoding. 
114. byte[] byteData = Encoding.ASCII.GetBytes(data); 
115. // Begin sending the data to the remote device. 
116. client.BeginSend(byteData, 0, byteData.Length, 0, 
117. new AsyncCallback(SendCallback), client); 
118. } 
119. private static void SendCallback(IAsyncResult ar) { 
120. try { 
121. // Retrieve the socket from the state object. 
122. Socket client = (Socket) ar.AsyncState; 
123. // Complete sending the data to the remote device. 
124. int bytesSent = client.EndSend(ar); 
125. Console.WriteLine("Sent {0} bytes to server.", bytesSent); 
126. // Signal that all bytes have been sent. 
127. sendDone.Set(); 
128. } catch (Exception e) { 
129. Console.WriteLine(e.ToString()); 
130. } 
131. } 
132. public static int Main(String[] args) { 
133. StartClient(); 
134. return 0; 
135. } 
136. }