devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity3D C# Socket通信详解之基础介绍_unity socket是什么

作者：正经夜光杯 | 2024-06-30 08:33:07

赞

踩

unity socket是什么

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);
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93

客户端：
客户端的步骤和服务端基本类似，但不需要人为指定端口号，也不需要绑定和监听，只需连接到服务器就行(连接的时候，系统会自动为客户端分配端口)，步骤如下：
①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("发送心跳成功");
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97

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();
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

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

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("发送心跳成功");
        }
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70

4 待处理部分

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

5 项目源码

ps：项目中的VS版本是2017，低版本的VS有些语法不支持会报错
项目
链接：https://pan.baidu.com/s/1_7D79eLQDdhqGXzwGkfFzw
提取码：k9gu
博主个人博客本文链接。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/771977
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号