.net下单线程同步模式（2）

 在.net中采用TcpListener、TcpClient代替 socket实现单线程同步模式

 

 

服务器端：

1. static void Connect(String server, String message) 
2. {
3.   try 
4.   {
5.     // Create a TcpClient.
6.     // Note, for this client to work you need to have a TcpServer 
7.     // connected to the same address as specified by the server, port
8.     // combination.
9.     Int32 port = 13000;
10.     TcpClient client = new TcpClient(server, port);
12.     // Translate the passed message into ASCII and store it as a Byte array.
13.     Byte[] data = System.Text.Encoding.ASCII.GetBytes(message);         
15.     // Get a client stream for reading and writing.
16.    //  Stream stream = client.GetStream();
18.     NetworkStream stream = client.GetStream();
20.     // Send the message to the connected TcpServer. 
21.     stream.Write(data, 0, data.Length);
23.     Console.WriteLine("Sent: {0}", message);         
25.     // Receive the TcpServer.response.
27.     // Buffer to store the response bytes.
28.     data = new Byte[256];
30.     // String to store the response ASCII representation.
31.     String responseData = String.Empty;
33.     // Read the first batch of the TcpServer response bytes.
34.     Int32 bytes = stream.Read(data, 0, data.Length);
35.     responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
36.     Console.WriteLine("Received: {0}", responseData);         
38.     // Close everything.
39.     stream.Close();         
40.     client.Close();         
41.   } 
42.   catch (ArgumentNullException e) 
43.   {
44.     Console.WriteLine("ArgumentNullException: {0}", e);
45.   } 
46.   catch (SocketException e) 
47.   {
48.     Console.WriteLine("SocketException: {0}", e);
49.   }
51.   Console.WriteLine("/n Press Enter to continue...");
52.   Console.Read();
53. }

 

1. using System;
2. using System.IO;
3. using System.Net;
4. using System.Net.Sockets;
5. using System.Text;
7. class MyTcpListener
8. {
9.   public static void Main()
10.   { 
11.     TcpListener server=null;   
12.     try
13.     {
14.       // Set the TcpListener on port 13000.
15.       Int32 port = 13000;
16.       IPAddress localAddr = IPAddress.Parse("127.0.0.1");
18.       // TcpListener server = new TcpListener(port);
19.       server = new TcpListener(localAddr, port);
21.       // Start listening for client requests.
22.       server.Start();
24.       // Buffer for reading data
25.       Byte[] bytes = new Byte[256];
26.       String data = null;
28.       // Enter the listening loop.
29.       while(true) 
30.       {
31.         Console.Write("Waiting for a connection... ");
33.         // Perform a blocking call to accept requests.
34.         // You could also user server.AcceptSocket() here.
35.         TcpClient client = server.AcceptTcpClient();            
36.         Console.WriteLine("Connected!");
38.         data = null;
40.         // Get a stream object for reading and writing
41.         NetworkStream stream = client.GetStream();
43.         int i;
45.         // Loop to receive all the data sent by the client.
46.         while((i = stream.Read(bytes, 0, bytes.Length))!=0) 
47.         {   
48.           // Translate data bytes to a ASCII string.
49.           data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
50.           Console.WriteLine("Received: {0}", data);
52.           // Process the data sent by the client.
53.           data = data.ToUpper();
55.           byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);
57.           // Send back a response.
58.           stream.Write(msg, 0, msg.Length);
59.           Console.WriteLine("Sent: {0}", data);            
60.         }
62.         // Shutdown and end connection
63.         client.Close();
64.       }
65.     }
66.     catch(SocketException e)
67.     {
68.       Console.WriteLine("SocketException: {0}", e);
69.     }
70.     finally
71.     {
72.        // Stop listening for new clients.
73.        server.Stop();
74.     }
77.     Console.WriteLine("/nHit enter to continue...");
78.     Console.Read();
79.   }   

}