返回

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

本文通过分析和总结 C#中 Socket 通信编程的关键技术,按照同步实现的方式实现了一个简单的 Socket 聊天程序,目的是通过这个程序来掌握 Socket 编程,为进一步开发 Unity3D 网络游戏打下一个坚实的基础。

Socket 编程基础

关于 Socket 编程基础部分的内容,主要是了解和掌握.NET 框架下为 Socket 编程提供的相关类和接口方法。.NET 中常见的网络相关的 API 都集中在 System.Net 和 System.Net.Socket 这两个命名空间下,大家可以通过 MSDN 去了解这两个命名空间下相关的类和方法。这里援引一位朋友总结的一篇文章http://www.cnblogs.com/sunev/archive/2012/08/05/2604189.html,大家可以从这里获得更为直观的认识。

什么是 Socket 编程的同步实现

本文的目的是按照同步实现的方式来实现一个简单的 Socket 聊天程序,因此在解决这个问题前,我们首先来看看什么是 Socket 编程的同步实现。所谓 Socket 编程的同步实现就是指按照同步过程的方法来实现 Socket 通信。从编程来说,我们常用的方法或者函数都是同步过程。因为当我们调用一个方法或者函数的时候我们能够立即得到它的返回值。可是我们知道在 Socket 通信中,我们不能保证时时刻刻连接都通畅、更不能够保证时时刻刻都有数据收发,因为我们就需要不断去读取相应的值来确定整个过程的状态。这就是 Socket 编程的同步实现了,下面我们来看具体的实现过程。

如何实现 Socket 同步通信

服务端

服务端的主要职责是处理各个客户端发送来的数据,因此在客户端的 Socket 编程中需要使用两个线程来循环处理客户端的请求,一个线程用于监听客户端的连接情况,一个线程用于监听客户端的消息发送,当服务端接收到客户端的消息后需要将消息处理后再分发给各个客户端。

基本流程

  • 创建套接字
  • 绑定套接字的 IP 和端口号——Bind()
  • 将套接字处于监听状态等待客户端的连接请求——Listen()
  • 当请求到来后,接受请求并返回本次会话的套接字——Accept()
  • 使用返回的套接字和客户端通信——Send()/Receive()
  • 返回,再次等待新的连接请求
  • 关闭套接字

代码示例

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4using System.Net;
  5using System.Net.Sockets;
  6using System.Threading;
  7
  8namespace TCPLib
  9{
 10    public class TCPServer
 11    {
 12        private byte[] result = new byte[1024];
 13        /// <summary>
 14        /// 最大的监听数量
 15        /// </summary>
 16        private int maxClientCount;
 17        public int MaxClientCount
 18        {
 19            get { return maxClientCount; }
 20            set { maxClientCount = value; }
 21        }
 22
 23        /// <summary>
 24        /// IP地址
 25        /// </summary>
 26        private string ip;
 27        public string IP
 28        {
 29            get { return ip; }
 30            set { ip = value; }
 31        }
 32
 33        /// <summary>
 34        /// 端口号
 35        /// </summary>
 36        private int port;
 37        public int Port
 38        {
 39            get { return port; }
 40            set { port = value; }
 41        }
 42
 43        /// <summary>
 44        /// 客户端列表
 45        /// </summary>
 46        private List<Socket> mClientSockets;
 47        public List<Socket> ClientSockets
 48        {
 49            get { return mClientSockets; }
 50        }
 51
 52        /// <summary>
 53        /// IP终端
 54        /// </summary>
 55        private IPEndPoint ipEndPoint;
 56
 57        /// <summary>
 58        /// 服务端Socket
 59        /// </summary>
 60        private Socket mServerSocket;
 61
 62        /// <summary>
 63        /// 当前客户端Socket
 64        /// </summary>
 65        private Socket mClientSocket;
 66        public Socket ClientSocket 
 67        {
 68            get { return mClientSocket;  }
 69            set { mClientSocket = value; }
 70        }
 71
 72        /// <summary>
 73        /// 构造函数
 74        /// </summary>
 75        /// <param name="port">端口号</param>
 76        /// <param name="count">监听的最大树目</param>
 77        public TCPServer(int port, int count)
 78        {
 79            this.ip = IPAddress.Any.ToString();
 80            this.port = port;
 81            this.maxClientCount=count;
 82
 83            this.mClientSockets = new List<Socket>();
 84
 85            //初始化IP终端
 86            this.ipEndPoint = new IPEndPoint(IPAddress.Any, port);
 87            //初始化服务端Socket
 88            this.mServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 89            //端口绑定
 90            this.mServerSocket.Bind(this.ipEndPoint);
 91            //设置监听数目
 92            this.mServerSocket.Listen(maxClientCount);
 93        }
 94
 95        /// <summary>
 96        /// 构造函数
 97        /// </summary>
 98        /// <param name="ip">ip地址</param>
 99        /// <param name="port">端口号</param>
100        /// <param name="count">监听的最大数目</param>
101        public TCPServer(string ip,int port,int count)
102        {
103            this.ip = ip;
104            this.port = port;
105            this.maxClientCount = count;
106
107            this.mClientSockets = new List<Socket>();
108
109            //初始化IP终端
110            this.ipEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);
111            //初始化服务端Socket
112            this.mServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
113            //端口绑定
114            this.mServerSocket.Bind(this.ipEndPoint);
115            //设置监听数目
116            this.mServerSocket.Listen(maxClientCount);
117
118        }
119
120        /// <summary>
121        /// 定义一个Start方法将构造函数中的方法分离出来
122        /// </summary>
123        public void Start()
124        {
125            //创建服务端线程,实现客户端连接请求的循环监听
126            var mServerThread = new Thread(this.ListenClientConnect);
127            //服务端线程开启
128            mServerThread.Start();
129        }
130
131        /// <summary>
132        /// 监听客户端链接
133        /// </summary>
134        private void ListenClientConnect()
135        {
136            //设置循环标志位
137            bool flag = true;
138            while (flag)
139            {
140                //获取连接到服务端的客户端
141                this.ClientSocket = this.mServerSocket.Accept();
142                //将获取到的客户端添加到客户端列表
143                this.mClientSockets.Add(this.ClientSocket);
144                //向客户端发送一条消息
145                this.SendMessage(string.Format("客户端{0}已成功连接到服务器", this.ClientSocket.RemoteEndPoint));
146                //创建客户端消息线程,实现客户端消息的循环监听
147                var mReveiveThread = new Thread(this.ReceiveClient);
148                //注意到ReceiveClient方法传入了一个参数
149                //实际上这个参数就是此时连接到服务器的客户端
150                //即ClientSocket
151                mReveiveThread.Start(this.ClientSocket);
152            }
153        }
154
155        /// <summary>
156        /// 接收客户端消息的方法
157        /// </summary>
158        private void ReceiveClient(object obj)
159        {
160            //获取当前客户端
161            //因为每次发送消息的可能并不是同一个客户端,所以需要使用var来实例化一个新的对象
162            //可是我感觉这里用局部变量更好一点
163            var mClientSocket = (Socket)obj;
164            // 循环标志位
165            bool flag = true;
166            while (flag)
167            {
168                try
169                {
170                    //获取数据长度
171                    int receiveLength = mClientSocket.Receive(result);
172                    //获取客户端消息
173                    string clientMessage = Encoding.UTF8.GetString(result, 0, receiveLength);
174                    //服务端负责将客户端的消息分发给各个客户端
175                    this.SendMessage(string.Format("客户端{0}发来消息:{1}",mClientSocket.RemoteEndPoint,clientMessage));
176
177                }
178                catch (Exception e)
179                {
180                    //从客户端列表中移除该客户端
181                    this.mClientSockets.Remove(mClientSocket);
182                    //向其它客户端告知该客户端下线
183                    this.SendMessage(string.Format("服务器发来消息:客户端{0}从服务器断开,断开原因:{1}",mClientSocket.RemoteEndPoint,e.Message));
184                    //断开连接
185                    mClientSocket.Shutdown(SocketShutdown.Both);
186                    mClientSocket.Close();
187                    break;
188                }
189            }
190            
191        }
192
193        /// <summary>
194        /// 向所有的客户端群发消息
195        /// </summary>
196        /// <param name="msg">message</param>
197        public void SendMessage(string msg)
198        {
199            //确保消息非空以及客户端列表非空
200            if (msg == string.Empty || this.mClientSockets.Count <= 0) return;
201            //向每一个客户端发送消息
202            foreach (Socket s in this.mClientSockets)
203            {
204                (s as Socket).Send(Encoding.UTF8.GetBytes(msg));
205            }
206        }
207
208        /// <summary>
209        /// 向指定的客户端发送消息
210        /// </summary>
211        /// <param name="ip">ip</param>
212        /// <param name="port">port</param>
213        /// <param name="msg">message</param>
214        public void SendMessage(string ip,int port,string msg)
215        {
216            //构造出一个终端地址
217            IPEndPoint _IPEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);
218            //遍历所有客户端
219            foreach (Socket s in mClientSockets)
220            {
221                if (_IPEndPoint == (IPEndPoint)s.RemoteEndPoint)
222                {
223                    s.Send(Encoding.UTF8.GetBytes(msg));
224                }
225            }
226        }
227    }
228}

好了,现在我们已经编写好了一个具备接收和发送数据能力的服务端程序。现在我们来尝试让服务端运行起来:

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4using TCPLib;
 5using System.Net;
 6using System.Net.Sockets;
 7
 8namespace TCPLib.Test
 9{
10    class Program
11    {
12        static void Main(string[] args)
13        {
14            //指定IP和端口号及最大监听数目的方式
15            TCPLib.TCPServer s1 = new TCPServer("127.0.0.1", 6001, 10);
16            //指定端口号及最大监听数目的方式
17            TCPLib.TCPServer s2 = new TCPServer(6001, 10);
18           
19            //执行Start方法
20            s1.Start();
21        
22        }
23    }
24
25}

现在我们来看看编写客户端 Socket 程序的基本流程

客户端

客户端相对于服务端来说任务要轻许多,因为客户端仅仅需要和服务端通信即可,可是因为在和服务器通信的过程中,需要时刻保持连接通畅,因此同样需要两个线程来分别处理连接情况的监听和消息发送的监听。

基本流程

  • 创建套接字保证与服务器的端口一致
  • 向服务器发出连接请求——Connect()
  • 和服务器端进行通信——Send()/Receive()
  • 关闭套接字

代码示例

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4using System.Net;
  5using System.Net.Sockets;
  6using System.Threading;
  7
  8namespace TCPLib
  9{
 10    public class TCPClient
 11    {
 12        /// <summary>
 13        /// 定义数据
 14        /// </summary>
 15        private byte[] result = new byte[1024];
 16
 17        /// <summary>
 18        /// 客户端IP
 19        /// </summary>
 20        private string ip;
 21        public string IP
 22        {
 23            get { return ip; }
 24            set { ip = value; }
 25        }
 26
 27        /// <summary>
 28        /// 客户端端口号
 29        /// </summary>
 30        private int port;
 31        public int Port
 32        {
 33            get { return port; }
 34            set { port = value; }
 35        }
 36
 37        /// <summary>
 38        /// IP终端
 39        /// </summary>
 40        private IPEndPoint ipEndPoint;
 41
 42        /// <summary>
 43        /// 客户端Socket
 44        /// </summary>
 45        private Socket mClientSocket;
 46
 47        /// <summary>
 48        /// 是否连接到了服务器
 49        /// 默认为flase
 50        /// </summary>
 51        private bool isConnected = false;
 52
 53        /// <summary>
 54        /// 构造函数
 55        /// </summary>
 56        /// <param name="ip">IP地址</param>
 57        /// <param name="port">端口号</param>
 58        public TCPClient(string ip, int port)
 59        {
 60            this.ip=ip;
 61            this.port=port;
 62            //初始化IP终端
 63            this.ipEndPoint = new IPEndPoint(IPAddress.Parse(this.ip), this.port);
 64            //初始化客户端Socket
 65            mClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 66
 67        }
 68
 69        public void Start()
 70        {
 71            //创建一个线程以不断连接服务器
 72            var mConnectThread = new Thread(this.ConnectToServer);
 73            //开启线程
 74            mConnectThread.Start();
 75        }
 76
 77        /// <summary>
 78        /// 连接到服务器
 79        /// </summary>
 80        private void ConnectToServer()
 81        {
 82            //当没有连接到服务器时开始连接
 83            while (!isConnected)
 84            {
 85                try
 86                {
 87                    //开始连接
 88                    mClientSocket.Connect(this.ipEndPoint);
 89                    this.isConnected = true;
 90                }
 91                catch (Exception e)
 92                {
 93                    //输出Debug信息
 94                    Console.WriteLine(string.Format("因为一个错误的发生,暂时无法连接到服务器,错误信息为:{0}",e.Message));
 95                    this.isConnected = false;
 96                }
 97
 98                //等待5秒钟后尝试再次连接
 99                Thread.Sleep(5000);
100                Console.WriteLine("正在尝试重新连接...");
101            }
102
103            //连接成功后
104            Console.WriteLine("连接服务器成功,现在可以和服务器进行会话了");
105            //创建一个线程以监听数据接收
106            var mReceiveThread = new Thread(this.ReceiveMessage);
107            //开启线程
108            mReceiveThread.Start();
109        }
110
111        /// <summary>
112        /// 因为客户端只接受来自服务器的数据
113        /// 因此这个方法中不需要参数
114        /// </summary>
115        private void ReceiveMessage()
116        {
117            //设置循环标志位
118            bool flag = true;
119            while (flag)
120            {
121                try
122                {
123                    //获取数据长度
124                    int receiveLength = this.mClientSocket.Receive(result);
125                    //获取服务器消息
126                    string serverMessage = Encoding.UTF8.GetString(result, 0, receiveLength);
127                    //输出服务器消息
128                    Console.WriteLine(serverMessage);
129                }
130                catch (Exception e)
131                {
132                    //停止消息接收
133                    flag = false;
134                    //断开服务器
135                    this.mClientSocket.Shutdown(SocketShutdown.Both);
136                    //关闭套接字
137                    this.mClientSocket.Close();
138
139                    //重新尝试连接服务器
140                    this.isConnected = false;
141                    ConnectToServer();
142                }
143            }
144            
145        }
146
147        /// <summary>
148        /// 发送消息
149        /// </summary>
150        /// <param name="msg">消息文本</param>
151        public void SendMessage(string msg)
152        {
153            if(msg==string.Empty || this.mClientSocket==null) return;
154
155            mClientSocket.Send(Encoding.UTF8.GetBytes(msg));
156        }
157    }
158}

同样地,我们现在来运行客户端程序,这样客户端就可以和服务端进行通信了:

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4using TCPLib;
 5using System.Net;
 6using System.Net.Sockets;
 7
 8namespace TCPLib.Test
 9{
10    class Program
11    {
12        static void Main(string[] args)
13        {
14            //保证端口号和服务端一致
15            TCPLib.TCPClient c = new TCPClient("127.0.0.1",6001);
16            //执行Start方法
17            c.Start();
18            while(true)
19            {
20                //读取客户端输入的消息
21                string msg = Console.ReadLine();
22                //发送消息到服务端
23                c.SendMessage(msg);
24            }
25        
26        }
27    }
28
29}

注意要先运行服务端的程序、再运行客户端的程序,不然程序会报错,嘿嘿!好了,下面是今天的效果演示图:

聊天窗口效果演示
聊天窗口效果演示

客户端下线效果演示
客户端下线效果演示

总结

今天我们基本上写出了一个可以使用的用例,不过这个例子目前还存在以下问题:

  • 这里仅仅实现了发送字符串的功能,如何让这个程序支持更多的类型,从基础的 int、float、double、string、single 等类型到 structure、class 甚至是二进制文件的类型?

  • 如何让这个用例更具有扩展性,我们发现所有的 Socket 编程流程都是一样的,唯一不同就是在接收到数据以后该如何去处理,因为能不能将核心功能和自定义功能分离开来?

  • 在今天的这个用例中,数据传输的缓冲区大小我们人为设定为 1024,那么如果碰到比这个设定更大的数据类型,这个用例该怎么来写?

好了,这就是今天的内容了,希望大家喜欢,同时希望大家关注我的博客!

2016 年 1 月 24 日更新: 要解决“支持更多类型的问题”,可以从两种思路来考虑,即实现所有类型到 byte[]类型的转换或者是实现所有类型到 string 类型的转换,对于第二种思路我们通常称之为序列化,序列化可以解决所有类型到 string 类型的转换问题,唯一可能需要考量的一个部分就是缓冲区的大小问题。

要解决“将核心功能和自定义功能分离”这个问题,可以考虑使用委托机制来实现,委托机制可以理解为一个函数的指针,在需要将函数的控制权交给用户来处理的场景中,委托都是一种有效而明智的选择。

Built with Hugo
Theme Stack designed by Jimmy