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

迷南。 2022-06-09 07:41 371阅读 0赞

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

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

# 如何实现Socket异步通信 #

## 服务端 ##

### 基本流程 ###

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

### 代码示例 ###

**\[csharp\]**  [view plain][]   [copy][view plain]

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()两组方法与服务端进行收发通信
 *  关闭套接字

### 代码示例 ###

### **\[csharp\]**  [view plain][]   [copy][view plain]  using System;    using System.Collections.Generic;    using System.Text;    using System.Net;    using System.Net.Sockets;        namespace AsyncClient    \{        public class AsyncTCPClient        \{            /// <summary>            /// 连接到服务器            /// </summary>            public void AsynConnect()            \{                //端口及IP                IPEndPoint ipe = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6065);                //创建套接字                Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);                //开始连接到服务器                client.BeginConnect(ipe, asyncResult =>                \{                    client.EndConnect(asyncResult);                    //向服务器发送消息                    AsynSend(client,"你好我是客户端");                    AsynSend(client, "第一条消息");                    AsynSend(client, "第二条消息");                    //接受消息                    AsynRecive(client);                \}, null);            \}                /// <summary>            /// 发送消息            /// </summary>            /// <param name="socket"></param>            /// <param name="message"></param>            public void AsynSend(Socket socket, string message)            \{                if (socket == null || message == string.Empty) return;                //编码                byte\[\] data = Encoding.UTF8.GetBytes(message);                try                \{                    socket.BeginSend(data, 0, data.Length, SocketFlags.None, asyncResult =>                    \{                        //完成发送消息                        int length = socket.EndSend(asyncResult);                        Console.WriteLine(string.Format("客户端发送消息:\{0\}", message));                    \}, null);                \}                catch (Exception ex)                \{                    Console.WriteLine("异常信息：\{0\}", ex.Message);                \}            \}                /// <summary>            /// 接收消息            /// </summary>            /// <param name="socket"></param>            public void AsynRecive(Socket socket)            \{                byte\[\] data = new byte\[1024\];                try                \{                    //开始接收数据                    socket.BeginReceive(data, 0, data.Length, SocketFlags.None,                    asyncResult =>                    \{                        int length = socket.EndReceive(asyncResult);                        Console.WriteLine(string.Format("收到服务器消息:\{0\}", Encoding.UTF8.GetString(data)));                        AsynRecive(socket);                    \}, null);                \}                catch (Exception ex)                \{                    Console.WriteLine("异常信息：", ex.Message);                \}            \}        \}    \}         从总体上来讲Socket异步编程的逻辑性更加明确了，因为我们只需要为每一个过程写好回调函数就好了。那么这个示例的效果如何呢？我们来看看它的演示效果：  ![Socket异步编程效果演示][Socket] ###

# 总结 #

### 和Socket同步编程的案例相比，今天的这个案例可能只是对Socket异步编程内容的一个简单应用，因为博主到现在为止都还没有写出一个可以进行交互聊天的程序来。在Socket的异步编程中，服务端不需要为一个客户端单独创建一个线程来维护其连接，可是这样带来的一个问题就是博主不知道该如何实现一个多客户端的异步编程的实例。如果有朋友知道如何实现的话，还希望能够告诉我，毕竟学习就是一个相互促进的过程啊。好了，最后想说的是博主这段时间研究Socket异步编程中关于异步方法调用的写法问题。我们知道Socket异步编程中的方法是成对出现的，每一个方法都有一个回调函数，对于回调函数，这里有两种写法，以BeginConnect方法为例：       **\[csharp\]**  [view plain][]   [copy][view plain]  m\_Socket.BeginConnect(this.m\_ipEndPoint,             new AsyncCallback(this.ConnectCallBack),             this.m\_Socket);//其中ConnectCallBack是一个回调函数    **\[csharp\]**  [view plain][]   [copy][view plain]  或者    **\[csharp\]**  [view plain][]   [copy][view plain]  m\_Socket.BeginConnect(this.m\_ipEndPoint,asyncResult=>    \{        //在这里添加更多代码    \},null)            博主为什么要在这里说这两种写法呢，有两个原因：    \* 第二种写法更为简洁，无需去构造容器传递Socket和消息，因为它们都是局部变量。如果我们使用第一种方法，因为主函数和回调函数是两个不同的函数，因此如果想要共享变量就需要通过IAsyncResult接口来访问容器中的值，这样显然增加了我们的工作量。   \* 第二种写法更为优雅，这似乎是C\#语言中某种高级语法，具体叫什么我忘了，反正在Linq中经常看到这种写法的影子。       综合以上两个观点，博主还是建议大家使用第二种写法，博主打算有空的话将之前写的程序再重新写一遍，看看能不能找出代码中的问题。好了，今天的内容就是这样了，谢谢大家，希望大家喜欢！ ###

[view plain]: http://blog.csdn.net/mss359681091/article/details/51790931#
[Socket]: http://7wy477.com1.z0.glb.clouddn.com/imgs_Socket%E5%BC%82%E6%AD%A5%E9%80%9A%E4%BF%A1%E6%95%88%E6%9E%9C%E6%BC%94%E7%A4%BA.png