EN中文
开发者社区 > 其他

C#中Socket通信编程的异步实现

发表于2017-11-02
评论0 5.6k浏览

本文将在C#中Socket同步通信的基础上，分析和研究Socket异步编程的实现方法，目的是深入了解Socket编程的基本原理，增强对网络游戏开发相关内容的认识。


什么是Socket编程的异步是实现

所谓Socket编程的异步实现是指按照异步过程来实现Socket编程，那么什么是异步过程呢，我们把在完成了一次调用后通过状态、通知和回调来告知调用者的方式成为异步过程，换句话说，在异步过程中当调用一个方法时，调用者并不能够立刻得到结果，只有当这个方法调用完毕后调用者才能获得调用结果。这样做的好处是什么呢？答案是高效。相信大家还记得我们在《C#中Socket通信编程的同步实现》这篇文章中使用多线程来实现简单聊天的案例吧，在这个案例中我们需要开启两个线程来不断监听客户端的连接和客户端的消息，这样的效率肯定是很低的。那么现在好了，我们可以通过异步过程来解决这个问题，下面我们就来看看如何实现Socket的异步通信。


如何实现Socket异步通信

服务端

基本流程

  • 创建套接字
  • 绑定套接字的IP和端口号——Bind()
  • 使套接字处于监听状态等待客户端的连接请求——Listen()
  • 当请求到来后，使用BeginAccept()和EndAccept()方法接受请求，返回新的套接字
  • 使用BeginSend()/EndSend和BeginReceive()/EndReceive()两组方法与客户端进行收发通信
  • 返回，再次等待新的连接请求
  • 关闭套接字

代码示例

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Net;  
  5. using System.Net.Sockets;  
  6.   
  7. namespace AsyncServer  
  8. {  
  9.     public class AsyncTCPServer  
  10.     {  
  11.         public void Start()  
  12.         {  
  13.             //创建套接字  
  14.             IPEndPoint ipe = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6065);  
  15.             Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
  16.             //绑定端口和IP  
  17.             socket.Bind(ipe);  
  18.             //设置监听  
  19.             socket.Listen(10);  
  20.             //连接客户端  
  21.             AsyncAccept(socket);  
  22.         }  
  23.   
  24.         /// <summary>  
  25.         /// 连接到客户端  
  26.         /// </summary>  
  27.         /// <param name="socket"></param>  
  28.         private void AsyncAccept(Socket socket)  
  29.         {  
  30.             socket.BeginAccept(asyncResult =>  
  31.             {  
  32.                 //获取客户端套接字  
  33.                 Socket client = socket.EndAccept(asyncResult);  
  34.                 Console.WriteLine(string.Format("客户端{0}请求连接...", client.RemoteEndPoint));  
  35.                 AsyncSend(client, "服务器收到连接请求");  
  36.                 AsyncSend(client, string.Format("欢迎你{0}",client.RemoteEndPoint));  
  37.                 AsyncReveive(client);  
  38.             }, null);  
  39.         }  
  40.   
  41.         /// <summary>  
  42.         /// 接收消息  
  43.         /// </summary>  
  44.         /// <param name="client"></param>  
  45.         private void AsyncReveive(Socket socket)  
  46.         {  
  47.             byte[] data = new byte[1024];  
  48.             try  
  49.             {  
  50.                 //开始接收消息  
  51.                 socket.BeginReceive(data, 0, data.Length, SocketFlags.None,  
  52.                 asyncResult =>  
  53.                 {  
  54.                     int length = socket.EndReceive(asyncResult);  
  55.                     Console.WriteLine(string.Format("客户端发送消息:{0}", Encoding.UTF8.GetString(data)));  
  56.                 }, null);  
  57.             }  
  58.             catch (Exception ex)  
  59.             {  
  60.                 Console.WriteLine(ex.Message);  
  61.             }  
  62.         }  
  63.   
  64.         /// <summary>  
  65.         /// 发送消息  
  66.         /// </summary>  
  67.         /// <param name="client"></param>  
  68.         /// <param name="p"></param>  
  69.         private void AsyncSend(Socket client, string p)  
  70.         {  
  71.             if (client == null || p == string.Empty) return;  
  72.             //数据转码  
  73.             byte[] data = new byte[1024];  
  74.             data = Encoding.UTF8.GetBytes(p);  
  75.             try  
  76.             {  
  77.                 //开始发送消息  
  78.                 client.BeginSend(data, 0, data.Length, SocketFlags.None, asyncResult =>  
  79.                 {  
  80.                     //完成消息发送  
  81.                     int length = client.EndSend(asyncResult);  
  82.                     //输出消息  
  83.                     Console.WriteLine(string.Format("服务器发出消息:{0}", p));  
  84.                 }, null);  
  85.             }  
  86.             catch (Exception e)  
  87.             {  
  88.                 Console.WriteLine(e.Message);  
  89.             }  
  90.         }  
  91.     }  
  92. }  

客户端

基本流程

  • 创建套接字并保证与服务器的端口一致
  • 使用BeginConnect()和EndConnect()这组方法向服务端发送连接请求
  • 使用BeginSend()/EndSend和BeginReceive()/EndReceive()两组方法与服务端进行收发通信
  • 关闭套接字

代码示例

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Net;  
  5. using System.Net.Sockets;  
  6.   
  7. namespace AsyncClient  
  8. {  
  9.     public class AsyncTCPClient  
  10.     {  
  11.         /// <summary>  
  12.         /// 连接到服务器  
  13.         /// </summary>  
  14.         public void AsynConnect()  
  15.         {  
  16.             //端口及IP  
  17.             IPEndPoint ipe = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6065);  
  18.             //创建套接字  
  19.             Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
  20.             //开始连接到服务器  
  21.             client.BeginConnect(ipe, asyncResult =>  
  22.             {  
  23.                 client.EndConnect(asyncResult);  
  24.                 //向服务器发送消息  
  25.                 AsynSend(client,"你好我是客户端");  
  26.                 AsynSend(client, "第一条消息");  
  27.                 AsynSend(client, "第二条消息");  
  28.                 //接受消息  
  29.                 AsynRecive(client);  
  30.             }, null);  
  31.         }  
  32.   
  33.         /// <summary>  
  34.         /// 发送消息  
  35.         /// </summary>  
  36.         /// <param name="socket"></param>  
  37.         /// <param name="message"></param>  
  38.         public void AsynSend(Socket socket, string message)  
  39.         {  
  40.             if (socket == null || message == string.Empty) return;  
  41.             //编码  
  42.             byte[] data = Encoding.UTF8.GetBytes(message);  
  43.             try  
  44.             {  
  45.                 socket.BeginSend(data, 0, data.Length, SocketFlags.None, asyncResult =>  
  46.                 {  
  47.                     //完成发送消息  
  48.                     int length = socket.EndSend(asyncResult);  
  49.                     Console.WriteLine(string.Format("客户端发送消息:{0}", message));  
  50.                 }, null);  
  51.             }  
  52.             catch (Exception ex)  
  53.             {  
  54.                 Console.WriteLine("异常信息：{0}", ex.Message);  
  55.             }  
  56.         }  
  57.   
  58.         /// <summary>  
  59.         /// 接收消息  
  60.         /// </summary>  
  61.         /// <param name="socket"></param>  
  62.         public void AsynRecive(Socket socket)  
  63.         {  
  64.             byte[] data = new byte[1024];  
  65.             try  
  66.             {  
  67.                 //开始接收数据  
  68.                 socket.BeginReceive(data, 0, data.Length, SocketFlags.None,  
  69.                 asyncResult =>  
  70.                 {  
  71.                     int length = socket.EndReceive(asyncResult);  
  72.                     Console.WriteLine(string.Format("收到服务器消息:{0}", Encoding.UTF8.GetString(data)));  
  73.                     AsynRecive(socket);  
  74.                 }, null);  
  75.             }  
  76.             catch (Exception ex)  
  77.             {  
  78.                 Console.WriteLine("异常信息：", ex.Message);  
  79.             }  
  80.         }  
  81.     }  
  82. }  

从总体上来讲Socket异步编程的逻辑性更加明确了，因为我们只需要为每一个过程写好回调函数就好了。那么这个示例的效果如何呢？我们来看看它的演示效果：
Socket异步编程效果演示：
Server服务器端：


Client客户端：

总结

和Socket同步编程的案例相比，今天的这个案例可能只是对Socket异步编程内容的一个简单应用，因为博主到现在为止都还没有写出一个可以进行交互聊天的程序来。在Socket的异步编程中，服务端不需要为一个客户端单独创建一个线程来维护其连接。我们知道Socket异步编程中的方法是成对出现的，每一个方法都有一个回调函数，对于回调函数，这里有两种写法，以BeginConnect方法为例：

  1. m_Socket.BeginConnect(this.m_ipEndPoint,   
  2.         new AsyncCallback(this.ConnectCallBack),   
  3.         this.m_Socket);//其中ConnectCallBack是一个回调函数  

或者
  1. m_Socket.BeginConnect(this.m_ipEndPoint,asyncResult=>  
  2. {  
  3.     //在这里添加更多代码  
  4. },null)  

博主为什么要在这里说这两种写法呢，有两个原因： 
* 第二种写法更为简洁，无需去构造容器传递Socket和消息，因为它们都是局部变量。如果我们使用第一种方法，因为主函数和回调函数是两个不同的函数，因此如果想要共享变量就需要通过IAsyncResult接口来访问容器中的值，这样显然增加了我们的工作量。
* 第二种写法更为优雅，这是C#语言中某种高级语法，asyncResult=> 是使用了委托的lambda表达式。

综合以上两个观点，还是建议大家使用第二种写法。

看完了C#中Socket通信编程的异步实现，如果对《C#中Socket通信编程的同步实现》感兴趣的，也可以看看。


如社区发表内容存在侵权行为，您可以点击这里查看侵权投诉指引

标签：

ListTCP/IPIP游戏开发接口网络游戏
0

0个评论