socket数据传输

1. //同步socket客户端
2. using System; 
3. using System.Net; 
4. using System.Net.Sockets; 
5. using System.Text; 
6. public class SynchronousSocketClient 
7. { 
8.     public static void StartClient() 
9.     { 
11.         byte[] bytes = new byte[1024]; 
13.         try 
14.         { 
15.             IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()) 
16.             IPAddress ipAddress = ipHostInfo.AddressList[0]; 
17.             IPEndPoint remoteEP = new IPEndPoint(ipAddress,11000); 
19.             Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp ); 
21.             try 
22.             { 
23.                 sender.Connect(remoteEP); 
24.                 Console.WriteLine("Socket connected to {0}", 
25.                 sender.RemoteEndPoint.ToString()); 
27.                 byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>"); 
29.                 int bytesSent = sender.Send(msg); 
31.                 int bytesRec = sender.Receive(bytes); 
32.                 Console.WriteLine("Echoed test = {0}", Encoding.ASCII.GetString(bytes,0,bytesRec)); 
34.                 sender.Shutdown(SocketShutdown.Both); 
35.                 sender.Close(); 
36.             } 
37.             catch (ArgumentNullException ane) 
38.             { 
39.                 Console.WriteLine("ArgumentNullException : {0}",ane.ToString()); 
40.             } 
41.             catch (SocketException se) 
42.             { 
43.                 Console.WriteLine("SocketException : {0}",se.ToString()); 
44.             }
45.             catch (Exception e)
46.             { 
47.                 Console.WriteLine("Unexpected exception : {0}", e.ToString()); 
48.             } 
49.         } 
50.         catch (Exception e) 
51.         { 
52.             Console.WriteLine( e.ToString()); 
53.         } 
54.     } 
56.     public static int Main(String[] args) 
57.     { 
58.         StartClient(); 
59.         return 0; 
60.     } 
61. } 
63. //同步socket监听
64. using System; 
65. using System.Net; 
66. using System.Net.Sockets; 
67. using System.Text; 
68. public class SynchronousSocketListener
69. { 
70.     public static string data = null; 
71.     public static void StartListening() 
72.     { 
73.         byte[] bytes = new Byte[1024]; 
74.          
75.         IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()); 
76.         IPAddress ipAddress = ipHostInfo.AddressList[0]; 
77.         IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000); 
79.         Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp ); 
81.         try 
82.         { 
83.             listener.Bind(localEndPoint); 
84.             listener.Listen(10); 
85.              
86.             while (true) 
87.             { 
88.                 Console.WriteLine("Waiting for a connection..."); 
90.                 Socket handler = listener.Accept(); 
91.                 data = null; 
93.                 while (true) 
94.                 { 
95.                     bytes = new byte[1024]; 
96.                     int bytesRec = handler.Receive(bytes); 
97.                     data += Encoding.ASCII.GetString(bytes,0,bytesRec); 
98.                     if (data.IndexOf("<EOF>") > -1) 
99.                     { 
100.                         break; 
101.                     } 
102.                 } 
104.                 Console.WriteLine( "Text received : {0}", data); 
106.                 byte[] msg = Encoding.ASCII.GetBytes(data); 
107.                 handler.Send(msg); 
108.                 handler.Shutdown(SocketShutdown.Both); 
109.                 handler.Close(); 
110.             } 
111.         } 
112.         catch (Exception e) 
113.         { 
114.             Console.WriteLine(e.ToString()); 
115.         } 
116.         Console.WriteLine("/nPress ENTER to continue..."); 
117.         Console.Read(); 
118.     } 
120.     public static int Main(String[] args) 
121.     { 
122.         StartListening(); 
123.         return 0; 
124.     } 
125. } 
127. //异步socket客户端
128. using System; 
129. using System.Net; 
130. using System.Net.Sockets; 
131. using System.Threading; 
132. using System.Text; 
134.     public class StateObject 
135.     { 
136.         public Socket workSocket = null; 
137.         public const int BufferSize = 256; 
138.         public byte[] buffer = new byte[BufferSize]; 
139.         public StringBuilder sb = new StringBuilder(); 
140.     } 
142.     public class AsynchronousClient 
143.     { 
145.         private const int port = 11000; 
147.         private static ManualResetEvent connectDone = new ManualResetEvent(false); 
148.         private static ManualResetEvent sendDone = new ManualResetEvent(false); 
149.         private static ManualResetEvent receiveDone = new ManualResetEvent(false); 
150.          
151.         private static String response = String.Empty; 
153.         private static void StartClient() 
154.         { 
155.             try 
156.             { 
157.                 IPHostEntry ipHostInfo = Dns.Resolve("host.contoso.com"); 
158.                 IPAddress ipAddress = ipHostInfo.AddressList[0]; 
159.                 IPEndPoint remoteEP = new IPEndPoint(ipAddress, port); 
161.                 Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
162.                 client.BeginConnect( remoteEP, new AsyncCallback(ConnectCallback), client); 
163.                 connectDone.WaitOne(); 
165.                 Send(client,"This is a test<EOF>"); 
166.                 sendDone.WaitOne(); 
167.                  
168.                 Receive(client); 
169.                 receiveDone.WaitOne(); 
171.                 Console.WriteLine("Response received : {0}", response); 
173.                 client.Shutdown(SocketShutdown.Both); 
174.                 client.Close(); 
175.             } 
176.             catch (Exception e) 
177.             { 
178.                 Console.WriteLine(e.ToString()); 
179.             } 
180.         } 
182.         private static void ConnectCallback(IAsyncResult ar) 
183.         { 
184.             try 
185.             { 
186.                 Socket client = (Socket) ar.AsyncState; 
187.                 client.EndConnect(ar); 
188.                 Console.WriteLine("Socket connected to {0}", 
189.                 client.RemoteEndPoint.ToString()); 
190.                 connectDone.Set(); 
191.             } 
192.             catch (Exception e) 
193.             { 
194.                 Console.WriteLine(e.ToString()); 
195.             } 
196.         } 
198.         private static void Receive(Socket client) 
199.         { 
200.             try 
201.             { 
202.                 StateObject state = new StateObject(); 
203.                 state.workSocket = client; 
204.                 client.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state); 
205.             } 
206.             catch (Exception e) 
207.             { 
208.                 Console.WriteLine(e.ToString()); 
209.             } 
210.         } 
212.         private static void ReceiveCallback( IAsyncResult ar ) 
213.         { 
214.             try 
215.             { 
216.                 StateObject state = (StateObject) ar.AsyncState; 
217.                 Socket client = state.workSocket; 
218.                 int bytesRead = client.EndReceive(ar); 
219.                 if (bytesRead > 0) 
220.                 { 
221.                     state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead)); 
222.                     client.BeginReceive(state.buffer,0,StateObject.BufferSize,0, new AsyncCallback(ReceiveCallback), state); 
223.                 } 
224.                 else 
225.                 { 
226.                     if (state.sb.Length > 1) 
227.                     { 
228.                         response = state.sb.ToString(); 
229.                     } 
230.                     receiveDone.Set(); 
231.                 } 
232.             } 
233.             catch (Exception e)
234.             { 
235.                 Console.WriteLine(e.ToString()); 
236.             } 
237.         } 
239.         private static void Send(Socket client, String data) 
240.         { 
241.             byte[] byteData = Encoding.ASCII.GetBytes(data); 
242.             client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client); 
243.         } 
245.         private static void SendCallback(IAsyncResult ar) 
246.         { 
247.             try 
248.             { 
249.                 Socket client = (Socket) ar.AsyncState;          
250.                 int bytesSent = client.EndSend(ar); 
251.                 Console.WriteLine("Sent {0} bytes to server.", bytesSent); 
252.                 sendDone.Set(); 
253.             } 
254.             catch (Exception e) 
255.             { 
256.                 Console.WriteLine(e.ToString()); 
257.             } 
258.         } 
261.         public static int Main(String[] args) 
262.         { 
263.             StartClient(); 
264.             return 0; 
265.         } 
266.     } 
269. //异步socket监听
270. using System; 
271. using System.Net; 
272. using System.Net.Sockets; 
273. using System.Text; 
274. using System.Threading; 
276. public class StateObject 
277. { 
278.     public Socket workSocket = null; 
279.     public const int BufferSize = 1024; 
280.     public byte[] buffer = new byte[BufferSize]; 
281.     public StringBuilder sb = new StringBuilder(); 
282. } 
284. public class AsynchronousSocketListener 
285. { 
286.     public static ManualResetEvent allDone = new ManualResetEvent(false); 
288.     public AsynchronousSocketListener() 
289.     { 
291.     } 
293.     public static void StartListening() 
294.     {  
295.         byte[] bytes = new Byte[1024]; 
296.         IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()); 
297.         IPAddress ipAddress = ipHostInfo.AddressList[0]; 
298.         IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000); 
300.         Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp ); 
302.         try 
303.         { 
304.             listener.Bind(localEndPoint); 
305.             listener.Listen(100); 
306.             while (true) 
307.             { 
308.                 allDone.Reset(); 
309.                 Console.WriteLine("Waiting for a connection..."); 
310.                 listener.BeginAccept( new AsyncCallback(AcceptCallback), listener ); 
311.                 allDone.WaitOne(); 
312.             } 
313.         } 
314.         catch (Exception e) 
315.         { 
316.             Console.WriteLine(e.ToString()); 
317.         } 
318.         Console.WriteLine("/nPress ENTER to continue..."); 
319.         Console.Read(); 
320.     } 
322.     public static void AcceptCallback(IAsyncResult ar) 
323.     { 
324.         allDone.Set(); 
325.         Socket listener = (Socket) ar.AsyncState; 
326.         Socket handler = listener.EndAccept(ar); 
327.         StateObject state = new StateObject(); 
328.         state.workSocket = handler; 
329.         handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state); 
330.     } 
332.     public static void ReadCallback(IAsyncResult ar) 
333.     { 
334.         String content = String.Empty; 
335.         StateObject state = (StateObject) ar.AsyncState; 
336.         Socket handler = state.workSocket; 
337.         int bytesRead = handler.EndReceive(ar); 
338.         if (bytesRead > 0) 
339.         { 
340.             state.sb.Append(Encoding.ASCII.GetString( state.buffer,0,bytesRead));  
341.             content = state.sb.ToString(); 
342.             if (content.IndexOf("<EOF>") > -1) 
343.             { 
344.                 Console.WriteLine("Read {0} bytes from socket. /n Data : {1}", content.Length, content ); 
345.                 Send(handler, content); 
346.             } 
347.             else 
348.             { 
349.                 handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state); 
350.             } 
351.         } 
352.     } 
354.     private static void Send(Socket handler, String data) 
355.     { 
356.         byte[] byteData = Encoding.ASCII.GetBytes(data); 
357.         handler.BeginSend(byteData, 0, byteData.Length, 0, 
358.         new AsyncCallback(SendCallback), handler); 
359.     } 
361.     private static void SendCallback(IAsyncResult ar)
362.     { 
363.         try 
364.         { 
365.             Socket handler = (Socket) ar.AsyncState; 
366.             int bytesSent = handler.EndSend(ar); 
367.             Console.WriteLine("Sent {0} bytes to client.", bytesSent); 
368.             handler.Shutdown(SocketShutdown.Both); 
369.             handler.Close(); 
370.         } 
371.         catch (Exception e) 
372.         { 
373.             Console.WriteLine(e.ToString()); 
374.         } 
375.     } 
377.     public static int Main(String[] args) 
378.     { 
379.         StartListening(); 
380.         return 0; 
381.     } 
382. }