Unity3D C# Socket通信详解之基础介绍

Unity3D C# Socket通信详解之基础介绍

2020年8月9日 0 作者 老王

1 引言

之前写了两篇和底层设备通信的文章,①Unity3D C# 从零自定义通讯协议Unity3D C# 从零自定义通讯协议之通信框架,demo中用的是socket进行通信,索性这里来总结一下,方便以后查阅。

2 Socket基础

2.1 什么是Socket

socket的英文原义是“孔”或“插座”。作为进程通信机制,取后一种意思。通常也称作“套接字”,用于描述IP地址和端口,是一个通信链的句柄(其实就是两个程序通信用的)。
socket非常类似于电话插座。以一个电话网为例:电话的通话双方相当于相互通信的2个程序,电话号码就是ip地址。任何用户在通话之前,首先要占有一部电话机,相当于申请一个socket;同时要知道对方的号码,相当于对方有一个固定的socket。然后向对方拨号呼叫,相当于发出连接请求。对方假如在场并空闲,拿起电话话筒,双方就可以正式通话,相当于连接成功。双方通话的过程,是一方向电话机发出信号和对方从电话机接收信号的过程,相当于向socket发送数据和从socket接收数据。通话结束后,一方挂起电话机相当于关闭socket,撤销连接。

为了满足不同程序对通信质量和性能的要求,一般的网络系统都提供了以下3种不同类型的套接字,以供用户在设计程序时根据不同需要来选择:

  • 流式套接字(SOCK_STREAM):提供了一种可靠的、面向连接的双向数据传输服务。实现了数据无差错,无重复的发送,内设流量控制,被传输的数据被看做无记录边界的字节流。在TCP/IP协议簇中,使用TCP实现字节流的传输,当用户要发送大批量数据,或对数据传输的可靠性有较高要求时使用流式套接字。
  • 数据报套接字(SOCK_DGRAM):提供了一种无连接、不可靠的双向数据传输服务。数据以独立的包形式被发送,并且保留了记录边界,不提供可靠性保证。数据在传输过程中可能会丢失或重复,并且不能保证在接收端数据按发送顺序接收。在TCP/IP协议簇中,使用UDP实现数据报套接字
  • 原始套接字(SOCK_RAW):该套接字允许对较低层协议(如IP或ICMP)进行直接访问。一般用于对TCP/IP核心协议的网络编程。

2.2 IP地址与端口

2.2.1 IP地址

先看看通用的定义:IP 地址是指互联网协议地址, IP 地址是 IP 协议提供的一种统一的地址格式, 它为互联网上的每一个网络和每一台主机分配一个逻辑地址, 以此来屏蔽物理地址的差异
这里面提到两个概念,一个是逻辑地址,一个是物理地址。IP地址就是逻辑地址,如192.168.1.1;物理地址就是网卡上的MAC地址,全球唯一,由网卡的生产商在生产时设定好。
本机的IP地址如何查看?win + r,调出运行,然后输入cmd回车,输入ipconfig/all即可查看到本机的ip和mac地址。
电脑的 IP 地址类似于手机的手机号, 两部手机之间打电话发短信, 需要知道对方的手机号才行; 两台电脑之间通讯, 也需要知道对方的 IP 地址。

2.2.2 端口

我们从客户端的角度来看:
比如我们的电脑上有很多的软件,qq、微信、百度云等等。这些软件都不能单独运行,都需要连接到各自的服务器才能运行。qq发送数据时,只有qq的服务器能收到,微信和百度云的服务器收不到;同理微信发送数据时,也只有微信的服务器能收到,qq和百度云的服务器收不到。端口就是来实现这个功能的,每个客户端软件和服务器沟通都独占一个端口。
端口号的范围是0 ~ 65535,其中0 ~ 1014是系统保留端口,1025~65534 是预留端口, 是我们在开发过程中能使用的端口, 但是要避免端口冲突。
默认的端口地址如下

  • 21:FTP(文件传输)协议代理服务器
  • 25:SMTP服务器所开放的端口,用于发送邮件
  • 80:HTTP服务,用于网页浏览
  • 3306:MySql
  • 1433:SqlServer

2.3 协议

版权声明,以下部分来源于博客C#网络编程二:Socket编程,由于实在写得很好,所以干脆复制了过来,难得跳转过去跳转过来。

2.3.1 TCP

TCP是一种面向连接的、可靠的,基于字节流的传输层通信协议。为两台主机提供高可靠性的数据通信服务。它可以将源主机的数据无差错地传输到目标主机。当有数据要发送时,对应用进程送来的数据进行分片,以适合于在网络层中传输;当接收到网络层传来的分组时,它要对收到的分组进行确认,还要对丢失的分组设置超时重发等。为此TCP需要增加额外的许多开销,以便在数据传输过程中进行一些必要的控制,确保数据的可靠传输。因此,TCP传输的效率比较低。
TCP发送数据的流程如下:
①连接
TCP是面向连接的协议,TCP协议通过三个报文段完成类似电话呼叫的连接建立过程,这个过程称为三次握手,如图所示:
TCP的三次握手
第一次握手:建立连接时,客户端发送SYN包(SEQ=x)到服务器,并进入SYN_SEND状态,等待服务器确认。
第二次握手:服务器收到SYN包,必须确认客户的SYN(ACK=x+1),同时自己也发送一个SYN包(SEQ=y),即SYN+ACK包,此时服务器进入SYN_RECV状态。
第三次握手:客户端收到服务器的SYN+ACK包,向服务器发送确认包ACK(ACK=y+1),此包发送完毕,客户端和服务器进入Established状态,完成三次握手。
②传输数据
一旦通信双方建立了TCP连接,连接中的任何一方都能向对方发送数据和接收对方发来的数据。TCP协议负责把用户数据(字节流)按一定的格式和长度组成多个数据报进行发送,并在接收到数据报之后按分解顺序重新组装和恢复用户数据。
利用TCP传输数据时,数据是以字节流的形式进行传输的。
③连接终止
建立一个连接需要三次握手,而终止一个连接要经过四次握手,这是由TCP的半关闭(half-close)造成的。具体过程如图所示:
TCP协议连接终止
TCP协议的主要特点如下:
(1) 是面向连接的协议。
(2) 端到端的通信。每个TCP连接只能有两个端点,而且只能一对一通信,不能一点对多点直接通信。
(3) 高可靠性。通过TCP连接传送的数据,能保证数据无差错、不丢失、不重复地准确到达接收方,并且保证各数据到达的顺序与其发出的顺序相同。
(4) 全双工方式传输。
(5) 数据以字节流的方式传输。
(6) 传输的数据无消息边界。

2.3.2 UDP

UDP是一种简单的、面向数据报的无连接的协议,提供的是不一定可靠的传输服务。所谓“无连接”是指在正式通信前不必与对方先建立连接,不管对方状态如何都直接发送过去。这与发手机短信非常相似,只要知道对方的手机号就可以了,不要考虑对方手机处于什么状态。UDP虽然不能保证数据传输的可靠性,但数据传输的效率较高。
UDP的劣势如下:
(1) UDP可靠性不如TCP
TCP包含了专门的传递保证机制,当数据接收方收到发送方传来的信息时,会自动向发送方发出确认消息;发送方只有在接收到该确认消息之后才继续传送其他信息,否则将一直等待直到收到确认信息为止。与TCP不同,UDP并不提供数据传送的保证机制。如果在从发送方到接收方的传递过程中出现数据报的丢失,协议本身并不能做出任何检测或提示。因此,通常人们把UDP称为不可靠的传输协议。
(2) UDP不能保证有序传输
UDP不能确保数据的发送和接收顺序。对于突发性的数据报,有可能会乱序。
UDP的优势如下:
(1) UDP速度比TCP快
由于UDP不需要先与对方建立连接,也不需要传输确认,因此其数据传输速度比TCP快得多。对于强调传输性能而不是传输完整性的应用(比如网络音频播放、视频点播和网络会议等),使用UDP比较合适,因为它的传输速度快,使通过网络播放的视频音质好、画面清晰。
(2) UDP有消息边界
发送方UDP对应用程序交下来的报文,在添加首部后就向下直接交付给IP层。既不拆分,也不合并,而是保留这些报文的边界。使用UDP不需要考虑消息边界问题,这样使得UDP编程相比TCP,在对接收到的数据的处理方面要方便的多。在程序员看来,UDP套接字使用比TCP简单。UDP的这一特征也说明了它是一种面向报文的传输协议。
(3) UDP可以一对多传输
由于传输数据不建立连接,也就不需要维护连接状态(包括收发状态等),因此一台服务器可以同时向多个客户端传输相同的消息。利用UDP可以使用广播或组播的方式同时向子网上的所有客户进程发送消息,这一点也比TCP方便。
其中,速度快是UDP的首要优势
由于TCP协议中植入了各种安全保障功能,在实际执行的过程中会占用大量的系统开销,无疑使速度受到严重影响。反观UDP,由于抛弃了信息可靠传输机制,将安全和排序等功能移交给上层应用完成,极大地降低了执行时间,使速度得到了保证。简而言之,UDP的“理念”就是“不顾一切,只为更快地发送数据”。
UDP追求速度

3 示例

3.1 Tcp

使用Socket进行Tcp通信很简单,按照基本的流程来就行了。
由于实际开发中都是使用异步的方式,所以这里只以异步的方法为示例,同步方法不做阐述。
服务端:
①new一个Socket,SocketType选择为流模式(见2.1节),ProtocolType选择为Tcp
②指定一个端口,然后根据端口和本地IP(127.0.0.1就是本地的IP,或者win+r进入允许,输入cmd+回车,然后在控制台输入ipconfig查看实际的本地ip)new一个IPEndPoint
③Socket进行绑定Bind
④Socket开启监听Listen,同时设置最大连接数
⑤调用BeginAccpet和EndAccpet异步等待客户端的连接
⑥调用BeginReceive和EndReceive异步接收客户端发来的数据
⑦调用BeginSend和EndSend异步发送数据
⑧调用Close关闭连接

    class Server
    {
        private struct ReceiveState
        {
            public Socket clientSocket;
            public byte[] buffer;
        }

        private const int MaxCnt = 5;
        private const int Port = 10086;
        private Socket m_ServerSocket;
        private Dictionary<string, Socket> m_ClientDict = new Dictionary<string, Socket>();
        private Dictionary<Socket, byte[]> m_ClientBuffer = new Dictionary<Socket, byte[]>();

        public void Open()
        {
            m_ServerSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), Port);
            m_ServerSocket.Bind(ipEndPoint);
            m_ServerSocket.Listen(MaxCnt);
            m_ServerSocket.BeginAccept(OnAccept, m_ServerSocket);
        }

        public void Close()
        {
            m_ServerSocket.Close();
        }

        private void OnAccept(IAsyncResult result)
        {
            Socket serverSocket = (Socket) result.AsyncState;
            Socket clientSocket = serverSocket.EndAccept(result);
            string clientIp = clientSocket.RemoteEndPoint.ToString();
            m_ClientDict.Add(clientIp, clientSocket);
            //Console.WriteLine($"{clientIp}连接上服务器,当前连接数:{m_ClientDict.Count}");
            ReceiveData(clientSocket);
            // 继续等待其他客户端连接
            serverSocket.BeginAccept(OnAccept, serverSocket);
        }

        private void ReceiveData(Socket client)
        {
            if(!m_ClientBuffer.TryGetValue(client, out byte[] buffer))
            {
                buffer = new byte[1024];
                m_ClientBuffer.Add(client, buffer);
            }

            client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, EndReceive, new ReceiveState
            {
                clientSocket = client,
                buffer = buffer
            });
        }

        private void EndReceive(IAsyncResult result)
        {
            ReceiveState state = (ReceiveState)result.AsyncState;
            Socket client = state.clientSocket;
            byte[] buffer = state.buffer;
            try
            {
                int length = client.EndReceive(result);
                string msgString = Encoding.Default.GetString(buffer, 0, length);
                Console.WriteLine($"客户端{((IPEndPoint)client.RemoteEndPoint).Address.MapToIPv4()}发来信息 {msgString}");
                ReceiveData(client);

                Send("服务器回复的心跳包", client);
            }
            catch (SocketException e)
            {
                m_ClientBuffer.Remove(client);
                m_ClientDict.Remove(client.RemoteEndPoint.ToString());
                Console.WriteLine($"{client.RemoteEndPoint} 下线,剩余连接数{m_ClientDict.Count}");
            }
            catch (FormatException e)
            {
                //Console.WriteLine($"{client.RemoteEndPoint} 发来的数据无法解析......");
            }
        }

        public void Send(string msg, Socket client)
        {
            byte[] msgBytes = Encoding.Default.GetBytes(msg);
            client.BeginSend(msgBytes, 0, msgBytes.Length, SocketFlags.None, OnEndSend, client);
        }

        private void OnEndSend(IAsyncResult result)
        {
            Socket client = (Socket)result.AsyncState;
            int cnt = client.EndSend(result);
        }
    }

客户端:
客户端的步骤和服务端基本类似,但不需要人为指定端口号,也不需要绑定和监听,只需连接到服务器就行(连接的时候,系统会自动为客户端分配端口),步骤如下:
①new一个Socket,SocketType选择为流模式(见2.1节),ProtocolType选择为Tcp
②根据服务器的端口和本地IP(127.0.0.1就是本地的IP,或者win+r进入允许,输入cmd+回车,然后在控制台输入ipconfig查看实际的本地ip)new一个IPEndPoint
③调用BeginConnect和EndConnect异步连接服务器
④调用BeginAccpet和EndAccpet异步等待客户端的连接
⑤调用BeginReceive和EndReceive异步接收客户端发来的数据
⑥调用BeginSend和EndSend异步发送数据
⑦调用Close关闭连接

    class Client
    {
        private struct ReceiveState
        {
            public Socket clientSocket;
            public byte[] buffer;
        }

        private const int MaxCnt = 5;
        private const int Port = 10086;
        private IPEndPoint m_ServerIpEndPoint;
        private Socket m_ClientSocket;
        private byte[] m_Buffer = new byte[1024];
        private byte[] m_HeartBytes = Encoding.Default.GetBytes("Tcp心跳包");

        public void Open()
        {
            m_ClientSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
            m_ServerIpEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 10086);
            Console.WriteLine($"客户端{m_ClientSocket.LocalEndPoint}开始连接服务器......");
            m_ClientSocket.BeginConnect(m_ServerIpEndPoint, OnConnect, m_ClientSocket);
        }

        public void Close()
        {
            m_ClientSocket.Close();
        }

        private void OnConnect(IAsyncResult result)
        {
            try
            {
                Socket client = (Socket)result.AsyncState;
                client.EndConnect(result);
                Console.WriteLine("连接服务器成功");
                // 开始接收数据
                ReceiveData(client);
                // 定时发送心跳
                SendHeartBeat();
            }
            catch (SocketException e)
            {
                Console.WriteLine("连接服务器失败,尝试重新连接中......");
                m_ClientSocket.BeginConnect(m_ServerIpEndPoint, OnConnect, m_ClientSocket);
            }
        }

        private void ReceiveData(Socket client)
        {
            client.BeginReceive(m_Buffer, 0, m_Buffer.Length, SocketFlags.None, EndReceive, new ReceiveState
            {
                clientSocket = client,
                buffer = m_Buffer
            });
        }

        private void EndReceive(IAsyncResult result)
        {
            ReceiveState state = (ReceiveState)result.AsyncState;
            Socket client = state.clientSocket;
            byte[] buffer = state.buffer;
            try
            {
                int length = client.EndReceive(result);
                string msgString = Encoding.Default.GetString(buffer, 0, length);
                Console.WriteLine($"服务器发来信息: {msgString}");

                // 继续接收消息
                ReceiveData(client);
            }
            catch (SocketException e)
            {
                Console.WriteLine($"与服务器丢失连接 Error:{e.Message}");
            }
            catch (FormatException e)
            {
                //Console.WriteLine($"服务器发来的数据无法解析......");
            }
        }

        private void SendHeartBeat()
        {
            // 发送心跳包
            while (true)
            {
                m_ClientSocket?.BeginSend(m_HeartBytes, 0, m_HeartBytes.Length, SocketFlags.None, OnEndSend, m_ClientSocket);
                Thread.Sleep(2000);
            }
        }

        private void OnEndSend(IAsyncResult result)
        {
            Socket client = (Socket)result.AsyncState;
            int cnt = client.EndSend(result);
            Console.WriteLine("发送心跳成功");
        }
    }

3.2 Udp

服务端
①new一个Socket,SocketType设置为Dgram,ProtocolType设置为Udp
②指定一个端口,然后根据端口和本地IP(127.0.0.1就是本地的IP,或者win+r进入允许,输入cmd+回车,然后在控制台输入ipconfig查看实际的本地ip)new一个IPEndPoint
③Socket进行绑定Bind
④使用BeginReceiveFrom和EndReceiveFrom异步接收数据
⑤使用BeginSendTo和EndSendTo异步发送数据
⑥Close关闭

class Server
    {
        private struct ReceiveState
        {
            public EndPoint clientIpEndPoint;
            public byte[] buffer;
        }

        private Socket m_ServerSocket;
        private const int Port = 20000;
        private byte[] m_Buffer = new byte[1024];
        private List<IPEndPoint> m_ClientList = new List<IPEndPoint>();
        public void Open()
        {
            m_ServerSocket = new Socket(SocketType.Dgram, ProtocolType.Udp);
            IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), Port);
            m_ServerSocket.Bind(ipEndPoint);
            Recive();
        }

        public void Close()
        {
            m_ServerSocket?.Close();
        }

        private void Recive()
        {
            EndPoint clientIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
            m_ServerSocket.BeginReceiveFrom(m_Buffer, 0, m_Buffer.Length, SocketFlags.None, ref clientIpEndPoint, EndReceive,
                new ReceiveState
                {
                    clientIpEndPoint = clientIpEndPoint,
                    buffer = m_Buffer
                });
        }

        private void EndReceive(IAsyncResult result)
        {
            ReceiveState state = (ReceiveState) result.AsyncState;
            EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
            int length = m_ServerSocket.EndReceiveFrom(result, ref endPoint);

            IPEndPoint clientIpEndPoint = (IPEndPoint) endPoint;
            Console.WriteLine($"收到{clientIpEndPoint.Address.MapToIPv4()}:{clientIpEndPoint.Port}发送来的数据 {Encoding.Default.GetString(state.buffer, 0, length)}");
            if (!m_ClientList.Contains(clientIpEndPoint))
            {
                m_ClientList.Add(clientIpEndPoint);
            }

            // 继续接收
            Recive();
        }
    }

客户端与服务端一样,只是端口号和服务端对调。

class Client
    {
        private struct ReceiveState
        {
            public EndPoint clientIpEndPoint;
            public byte[] buffer;
        }

        private Socket m_ClientSocket;
        private const int ServerPort = 20000;
        private const int Port = 20001;
        private IPEndPoint m_ServerIPEndPoint;
        private byte[] m_Buffer = new byte[1024];
        private byte[] m_HeartBytes = Encoding.Default.GetBytes("Udp心跳包");

        public void Open()
        {
            m_ServerIPEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), ServerPort);

            m_ClientSocket = new Socket(SocketType.Dgram, ProtocolType.Udp);
            //IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), Port);
            //m_ClientSocket.Bind(ipEndPoint);
            //Receive();

            SendHeartBeat();
        }

        public void Close()
        {
            m_ClientSocket?.Close();
        }

        private void Receive()
        {
            EndPoint clientIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
            m_ClientSocket.BeginReceiveFrom(m_Buffer, 0, m_Buffer.Length, SocketFlags.None, ref clientIpEndPoint, EndReceive,
                new ReceiveState
                {
                    clientIpEndPoint = clientIpEndPoint,
                    buffer = m_Buffer
                });
        }

        private void EndReceive(IAsyncResult result)
        {
            ReceiveState state = (ReceiveState)result.AsyncState;
            EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
            int length = m_ClientSocket.EndReceiveFrom(result, ref endPoint);
            Console.WriteLine($"收到{((IPEndPoint)endPoint).Address}:{((IPEndPoint)endPoint).Port}发送来的数据 {Encoding.Default.GetString(state.buffer, 0, length)}");

            Receive();
        }

        private void SendHeartBeat()
        {
            // 发送心跳包
            while (true)
            {
                m_ClientSocket?.BeginSendTo(m_HeartBytes, 0, m_HeartBytes.Length, SocketFlags.None, m_ServerIPEndPoint, OnEndSend, m_ClientSocket);
                Thread.Sleep(2000);
            }
        }

        private void OnEndSend(IAsyncResult result)
        {
            Socket client = (Socket)result.AsyncState;
            int cnt = client.EndSend(result);
            Console.WriteLine("发送心跳成功");
        }
    }

4 待处理部分

以上只是实现了简单的连接和通信,很多细节没有处理,还需要做优化和处理:
①Tcp服务器应该使用连接池的方式来处理客户端的连接
②服务端与客户端通信时没有处理粘包和分包问题,应该在通信协议中添加上内容长度
③服务端或客户端可使用Protrobuf进行消息的序列化
④由于客户端收到服务的消息时经常会更新游戏物体,而Unity中只能在主线程处理游戏物体,客户端需要用列表将收到到的消息缓存起来,然后在Update中每帧处理几条消息
⑤目前没有处理消息的分发,消息分发可通过发送协议名,然后客户端或服务器通过协议名再通过反射获取到对应的类,再处理协议
以上这几部分,我们以后单独分几篇文章来一一解决。

5 项目源码

ps:项目中的VS版本是2017,低版本的VS有些语法不支持会报错
项目
链接:https://pan.baidu.com/s/1_7D79eLQDdhqGXzwGkfFzw
提取码:k9gu