C#客户端程序实现同步传输字符串浅析

C#客户端程序实现同步传输字符串的问题：我们编写客户端向服务器发送字符串的代码，与服务端类似，它先获取连接服务器端的流，将字符串保存到buffer缓存中，再将缓存写入流，写入流这一过程，相当于将消息发往服务端。

创新互联成立于2013年，先为仁寿等服务建站，仁寿等地企业，进行企业商务咨询服务。为仁寿企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

 
 
 
    
  
  
  
  1. class Client {  
    2. 
  
  
  
  2.     static void Main(string[] args) {  
    3. 
  
  
  
  3.         Console.WriteLine("Client Running ...");  
    4. 
  
  
  
  4.         TcpClient client;  
    5. 
  
  
  
  5. //C#客户端程序  
    6. 
  
  
  
  6.         try {  
    7. 
  
  
  
  7.             client = new TcpClient();  
    8. 
  
  
  
  8.             client.Connect("localhost", 8500);      // 与服务器连接  
    9. 
  
  
  
  9.         } catch (Exception ex) {  
    10. 
  
  
  
  10.             Console.WriteLine(ex.Message);  
    11. 
  
  
  
  11.             return;  
    12. 
  
  
  
  12.         }  
    13. 
  
  
  
  13.         // 打印连接到的服务端信息  
    14. 
  
  
  
  14.         Console.WriteLine("Server Connected！{0} --> {1}",  
    15. 
  
  
  
  15.             client.Client.LocalEndPoint, client.Client.RemoteEndPoint);  
    16. 
  
  
  
  16. //C#客户端程序  
    17. 
  
  
  
  17.         string msg = "\"Welcome To TraceFact.Net\"";  
    18. 
  
  
  
  18.         NetworkStream streamToServer = client.GetStream();  
    19. 
  
  
  
  19.  
    20. 
  
  
  
  20.         byte[] buffer = Encoding.Unicode.GetBytes(msg);     // 获得缓存  
    21. 
  
  
  
  21.         streamToServer.Write(buffer, 0, buffer.Length);     // 发往服务器  
    22. 
  
  
  
  22.         Console.WriteLine("Sent: {0}", msg);  
    23. 
  
  
  
  23.  
    24. 
  
  
  
  24.         // 按Q退出  
    25. 
  
  
  
  25.     }  
    26. 
  
  
  
  26. }  
    27.

现在再次运行程序，得到的输出为：

 
 
 
    
  
  
  
  1. // 服务端  
    2. 
  
  
  
  2. Server is running ...  
    3. 
  
  
  
  3. Start Listening ...  
    4. 
  
  
  
  4. Client Connected！127.0.0.1:8500 <-- 127.0.0.1:7847  
    5. 
  
  
  
  5. Reading data, 52 bytes ...  
    6. 
  
  
  
  6. Received: "Welcome To TraceFact.Net" 
    7. 
  
  
  
  7. 输入"Q"键退出。  
    8. 
  
  
  
  8. // 客户端  
    9. 
  
  
  
  9. Client Running ...  
    10. 
  
  
  
  10. Server Connected！127.0.0.1:7847 --> 127.0.0.1:8500  
    11. 
  
  
  
  11. Sent: "Welcome To TraceFact.Net" 
    12. 
  
  
  
  12. 输入"Q"键退出。 
    13.

再继续进行之前，我们假设客户端可以发送多条消息，而服务端要不断的接收来自客户端发送的消息，但是上面的代码只能接收客户端发来的一条消息，因为它已经输出了“输入Q键退出”，说明程序已经执行完毕，无法再进行任何动作。此时如果我们再开启一个客户端，那么出现的情况是：客户端可以与服务器建立连接，也就是netstat-a显示为ESTABLISHED，这是操作系统所知道的；但是由于服务端的程序已经执行到了最后一步，只能输入Q键退出，无法再采取任何的动作。

回想一个上面我们需要一个服务器对应多个客户端时，对AcceptTcpClient()方法的处理办法，将它放在了do/while循环中；类似地，当我们需要一个服务端对同一个客户端的多次请求服务时，可以将Read()方法放入到do/while循环中。

现在，我们大致可以得出这样几个结论：

◆如果不使用do/while循环，服务端只有一个listener.AcceptTcpClient()方法和一个TcpClient.GetStream().Read()方法，则服务端只能处理到同一客户端的一条请求。

◆如果使用一个do/while循环，并将listener.AcceptTcpClient()方法和TcpClient.GetStream().Read()方法都放在这个循环以内，那么服务端将可以处理多个客户端的一条请求。

◆如果使用一个do/while循环，并将listener.AcceptTcpClient()方法放在循环之外，将TcpClient.GetStream().Read()方法放在循环以内，那么服务端可以处理一个客户端的多条请求。

◆如果使用两个do/while循环，对它们进行分别嵌套，那么结果是什么呢？结果并不是可以处理多个客户端的多条请求。因为里层的do/while循环总是在为一个客户端服务，因为它会中断在TcpClient.GetStream().Read()方法的位置，而无法执行完毕。即使可以通过某种方式让里层循环退出，比如客户端往服务端发去“exit”字符串时，服务端也只能挨个对客户端提供服务。如果服务端想执行多个客户端的多个请求，那么服务端就需要采用多线程。主线程，也就是执行外层do/while循环的线程，在收到一个TcpClient之后，必须将里层的do/while循环交给新线程去执行，然后主线程快速地重新回到listener.AcceptTcpClient()的位置，以响应其它的客户端。

对于第四种情况，实际上是构建一个服务端更为通常的情况，所以需要专门开辟一个章节讨论，这里暂且放过。而我们上面所做的，即是列出的第一种情况，接下来我们再分别看一下第二种和第三种情况。

对于第二种情况，我们按照上面的叙述先对服务端进行一下改动：

 
 
 
    
  
  
  
  1. do {  
    2. 
  
  
  
  2. // 获取一个连接，中断方法  
    3. 
  
  
  
  3. TcpClient remoteClient = listener.AcceptTcpClient();  
    4. 
  
  
  
  4. // 打印连接到的客户端信息  
    5. 
  
  
  
  5. Console.WriteLine("Client Connected！{0} <-- {1}",  
    6. 
  
  
  
  6. remoteClient.Client.LocalEndPoint,   
    7. 
  
  
  
  7. remoteClient.Client.RemoteEndPoint);  
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9. // 获得流，并写入buffer中  
    10. 
  
  
  
  10. NetworkStream streamToClient = remoteClient.GetStream();  
    11. 
  
  
  
  11. byte[] buffer = new byte[BufferSize];  
    12. 
  
  
  
  12. int bytesRead = streamToClient.Read(buffer, 0, BufferSize);  
    13. 
  
  
  
  13. Console.WriteLine("Reading data, {0} bytes ...", bytesRead);  
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15. // 获得请求的字符串  
    16. 
  
  
  
  16. string msg = Encoding.Unicode.GetString(buffer, 0, bytesRead);  
    17. 
  
  
  
  17. Console.WriteLine("Received: {0}", msg);  
    18. 
  
  
  
  18. } while (true);  
    19.

然后启动多个客户端，在服务端应该可以看到下面的输出（客户端没有变化）：

 
 
 
    
  
  
  
  1. Server is running ...  
    2. 
  
  
  
  2. Start Listening ...  
    3. 
  
  
  
  3. Client Connected！127.0.0.1:8500 <-- 127.0.0.1:8196  
    4. 
  
  
  
  4. Reading data, 52 bytes ...  
    5. 
  
  
  
  5. Received: "Welcome To TraceFact.Net" 
    6. 
  
  
  
  6. Client Connected！127.0.0.1:8500 <-- 127.0.0.1:8199  
    7. 
  
  
  
  7. Reading data, 52 bytes ...  
    8. 
  
  
  
  8. Received: "Welcome To TraceFact.Net" 
    9.

由第2种情况改为第3种情况，只需要将do向下挪动几行就可以了：

 
 
 
    
  
  
  
  1. // 获取一个连接，中断方法  
    2. 
  
  
  
  2. TcpClient remoteClient = listener.AcceptTcpClient();  
    3. 
  
  
  
  3. // 打印连接到的客户端信息  
    4. 
  
  
  
  4. Console.WriteLine("Client Connected！{0} <-- {1}",  
    5. 
  
  
  
  5.     remoteClient.Client.LocalEndPoint,  
    6. 
  
  
  
  6.  remoteClient.Client.RemoteEndPoint);  
    7. 
  
  
  
  7. // 获得流，并写入buffer中  
    8. 
  
  
  
  8. NetworkStream streamToClient = remoteClient.GetStream();  
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10. do {  
    11. 
  
  
  
  11.     byte[] buffer = new byte[BufferSize];  
    12. 
  
  
  
  12.     int bytesRead = streamToClient.Read(  
    13. 
  
  
  
  13. buffer, 0, BufferSize);  
    14. 
  
  
  
  14.     Console.WriteLine("Reading data,   
    15. 
  
  
  
  15. {0} bytes ...", bytesRead);  
    16. 
  
  
  
  16.  
    17. 
  
  
  
  17.     // 获得请求的字符串  
    18. 
  
  
  
  18.     string msg = Encoding.Unicode.GetString(  
    19. 
  
  
  
  19. buffer, 0, bytesRead);  
    20. 
  
  
  
  20.     Console.WriteLine("Received: {0}", msg);  
    21. 
  
  
  
  21. } while (true);  
    22.

然后我们再改动一下客户端，让它发送多个请求。当我们按下S的时候，可以输入一行字符串，然后将这行字符串发送到服务端；当我们输入X的时候则退出循环：

 
 
 
    
  
  
  
  1. NetworkStream streamToServer = client.GetStream();  
    2. 
  
  
  
  2. ConsoleKey key;  
    3. 
  
  
  
  3. Console.WriteLine("Menu: S - Send, X - Exit");  
    4. 
  
  
  
  4. do {  
    5. 
  
  
  
  5. key = Console.ReadKey(true).Key;  
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. if (key == ConsoleKey.S) {  
    8. 
  
  
  
  8. // 获取输入的字符串  
    9. 
  
  
  
  9. Console.Write("Input the message: ");  
    10. 
  
  
  
  10. string msg = Console.ReadLine();  
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12. byte[] buffer = Encoding.Unicode.GetBytes(msg);// 获得缓存  
    13. 
  
  
  
  13. streamToServer.Write(buffer, 0, buffer.Length);// 发往服务器  
    14. 
  
  
  
  14. Console.WriteLine("Sent: {0}", msg);  
    15. 
  
  
  
  15. }  
    16. 
  
  
  
  16. } while (key != ConsoleKey.X);  
    17.

接下来我们先运行服务端，然后再运行客户端，输入一些字符串，来进行测试，应该能够看到下面的输出结果：

 
 
 
    
  
  
  
  1. // 服务端  
    2. 
  
  
  
  2. Server is running ...  
    3. 
  
  
  
  3. Start Listening ...  
    4. 
  
  
  
  4. Client Connected！127.0.0.1:8500 <-- 127.0.0.1:11004  
    5. 
  
  
  
  5. Reading data, 44 bytes ...  
    6. 
  
  
  
  6. Received: 欢迎访问我的博客：TraceFact.Net  
    7. 
  
  
  
  7. Reading data, 14 bytes ...  
    8. 
  
  
  
  8. Received: 我们一起进步！  
    9. 
  
  
  
  9. //客户端  
    10. 
  
  
  
  10. Client Running ...  
    11. 
  
  
  
  11. Server Connected！127.0.0.1:11004 --> 127.0.0.1:8500  
    12. 
  
  
  
  12. Menu: S - Send, X - Exit  
    13. 
  
  
  
  13. Input the message: 欢迎访问我的博客：TraceFact.Net  
    14. 
  
  
  
  14. Sent: 欢迎访问我的博客：TraceFact.Net  
    15. 
  
  
  
  15. Input the message: 我们一起进步！  
    16. 
  
  
  
  16. Sent: 我们一起进步！ 
    17.

这里还需要注意一点，当客户端在TcpClient实例上调用Close()方法，或者在流上调用Dispose()方法，服务端的streamToClient.Read()方法会持续地返回0，但是不抛出异常，所以会产生一个无限循环；而如果直接关闭掉客户端，或者客户端执行完毕但没有调用stream.Dispose()或者TcpClient.Close()，如果服务器端此时仍阻塞在Read()方法处，则会在服务器端抛出异常：“远程主机强制关闭了一个现有连接”。因此，我们将服务端的streamToClient.Read()方法需要写在一个try/catch中。同理，如果在服务端已经连接到客户端之后，服务端调用remoteClient.Close()，则客户端会得到异常“无法将数据写入传输连接: 您的主机中的软件放弃了一个已建立的连接。”；而如果服务端直接关闭程序的话，则客户端会得到异常“无法将数据写入传输连接: 远程主机强迫关闭了一个现有的连接。”。因此，它们的读写操作必须都放入到try/catch块中。

C#客户端程序的基本内容就向你介绍到这里，希望对你了解和学习C#客户端程序有所帮助。

网页名称：C#客户端程序实现同步传输字符串浅析
网页链接：http://www.shufengxianlan.com/qtweb/news3/308503.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

用户体验知识

同城分类信息

成都移动托管　　 　铁科精智测控　　 　营销型网站　　 　成都企业网站建设公司　　 　德阳服务器托管　　 　石膏隔墙　　 　广安网站建设　　 　迷你发光字　　 　网站制作公司　　 　B2C电商系统　　 　成都定制网站建设　　 　成都网站设计　　 　成都托管服务器　　 　域名申请　　 　网站建设　　 　微信开发　　 　四川成都seo网站优化　　 　网络推广公司　　 　成都商城app开发　　 　达州主机托管