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

Unity【Multiplayer 多人在线】- Socket 通用客户端网络模块（一）、Connect 连接服务端_unity socket插件

作者：从前慢现在也慢 | 2024-02-16 06:10:42

赞

踩

unity socket插件

介绍

        在阅读了罗培羽著作的Unity3D网络游戏实战一书后，博主综合自己的开发经验与考虑进行部分修改和调整，将通用的客户端网络模块和通用的服务端框架进行提取，形成专栏，介绍Socket网络编程，希望对其他人有所帮助。目录如下：

一、通用服务端框架

        （一）、定义套接字和多路复用​​​​​​

        （二）、客户端信息类和通用缓冲区结构

        （三）、Protobuf 通信协议

        （四）、数据处理和关闭连接

        （五）、Messenger 事件发布、订阅系统

        （六）、单点发送和广播数据

        （七）、时间戳和心跳机制

 二、通用客户端网络模块

        （一）、Connect 连接服务端

        （二）、Receive 接收并处理数据

        （三）、Send 发送数据

        （四）、Close 关闭连接

本篇内容：

客户端网络模块中同样使用服务端框架中的通用缓冲区结构ByteArray，和消息的发布、订阅系统Messenger，以及通信协议工具类ProtoUtility，代码分别如下：

  1. using System;
  2.  
  3. namespace SK.Framework.Sockets
  4. {
  5.     public class ByteArray
  6.     {
  7.         //默认大小
  8.         private const int DEFAULT_SIZE = 1024;
  9.         //初始大小
  10.         private readonly int initSize = 0;
  11.         //缓冲区
  12.         public byte[] bytes;
  13.         //读取位置
  14.         public int readIdx = 0;
  15.         //写入位置
  16.         public int writeIdx = 0;
  17.         //容量
  18.         private int capacity = 0;
  19.         //剩余空间
  20.         public int remain { get { return capacity - writeIdx; } }
  21.         //数据长度
  22.         public int length { get { return writeIdx - readIdx; } }
  23.  
  24.         //构造函数
  25.         public ByteArray(int size = DEFAULT_SIZE)
  26.         {
  27.             bytes = new byte[size];
  28.             capacity = size;
  29.             initSize = size;
  30.             writeIdx = 0;
  31.             readIdx = 0;
  32.         }
  33.         //构造函数
  34.         public ByteArray(byte[] defaultBytes)
  35.         {
  36.             bytes = defaultBytes;
  37.             capacity = defaultBytes.Length;
  38.             initSize = defaultBytes.Length;
  39.             readIdx = 0;
  40.             writeIdx = defaultBytes.Length;
  41.         }
  42.         //重设尺寸
  43.         public void ReSize(int size)
  44.         {
  45.             if (size < length) return;
  46.             if (size < initSize) return;
  47.             int n = 1;
  48.             while (n < size)
  49.             {
  50.                 n *= 2;
  51.             }
  52.             capacity = n;
  53.             byte[] newBytes = new byte[capacity];
  54.             Array.Copy(bytes, readIdx, newBytes, 0, writeIdx - readIdx);
  55.             bytes = newBytes;
  56.             writeIdx = length;
  57.             readIdx = 0;
  58.         }
  59.         //检查并移动数据
  60.         public void CheckAndMoveBytes()
  61.         {
  62.             if (length < 8)
  63.             {
  64.                 MoveBytes();
  65.             }
  66.         }
  67.         //移动数据
  68.         public void MoveBytes()
  69.         {
  70.             if (length > 0)
  71.             {
  72.                 Array.Copy(bytes, readIdx, bytes, 0, length);
  73.             }
  74.             writeIdx = length;
  75.             readIdx = 0;
  76.         }
  77.         //写入数据
  78.         public int Write(byte[] bs, int offset, int count)
  79.         {
  80.             if (remain < count)
  81.             {
  82.                 ReSize(length + count);
  83.             }
  84.             Array.Copy(bs, offset, bytes, writeIdx, count);
  85.             writeIdx += count;
  86.             return count;
  87.         }
  88.         //读取数据
  89.         public int Read(byte[] bs, int offset, int count)
  90.         {
  91.             count = Math.Min(count, length);
  92.             Array.Copy(bytes, readIdx, bs, offset, count);
  93.             readIdx += count;
  94.             CheckAndMoveBytes();
  95.             return count;
  96.         }
  97.         //读取Int16
  98.         public Int16 ReadInt16()
  99.         {
  100.             if (length < 2) return 0;
  101.             Int16 ret = (Int16)((bytes[readIdx + 1]) << 8 | bytes[readIdx]);
  102.             readIdx += 2;
  103.             CheckAndMoveBytes();
  104.             return ret;
  105.         }
  106.         //读取Int32
  107.         public Int32 ReadInt32()
  108.         {
  109.             if (length < 4) return 0;
  110.             Int32 ret = (Int32)((bytes[readIdx + 3] << 24) |
  111.                                 (bytes[readIdx + 2] << 16) |
  112.                                 (bytes[readIdx + 1] << 8) |
  113.                                 bytes[readIdx + 0]);
  114.             readIdx += 4;
  115.             CheckAndMoveBytes();
  116.             return ret;
  117.         }
  118.     }
  119. }
  1. using System.Collections.Generic;
  2.  
  3. namespace SK.Framework.Sockets
  4. {
  5.     /// <summary>
  6.     /// 消息发布、订阅系统
  7.     /// </summary>
  8.     public class Messenger
  9.     {
  10.         public delegate void MessageEvent(params object[] args);
  11.  
  12.         private static readonly Dictionary<string, MessageEvent> msgDic = new Dictionary<string, MessageEvent>();
  13.  
  14.         /// <summary>
  15.         /// 发布消息
  16.         /// </summary>
  17.         /// <param name="msgKey">消息Key值</param>
  18.         /// <param name="arg">参数</param>
  19.         public static void Publish(string msgKey, params object[] args)
  20.         {
  21.             if (msgDic.ContainsKey(msgKey))
  22.             {
  23.                 msgDic[msgKey].Invoke(args);
  24.             }
  25.         }
  26.         /// <summary>
  27.         /// 订阅消息
  28.         /// </summary>
  29.         /// <param name="msgKey">消息Key值</param>
  30.         /// <param name="messageEvent">订阅事件</param>
  31.         public static void Subscribe(string msgKey, MessageEvent messageEvent)
  32.         {
  33.             if (msgDic.ContainsKey(msgKey))
  34.             {
  35.                 msgDic[msgKey] += messageEvent;
  36.             }
  37.             else
  38.             {
  39.                 msgDic[msgKey] = messageEvent;
  40.             }
  41.         }
  42.         /// <summary>
  43.         /// 取消订阅
  44.         /// </summary>
  45.         /// <param name="msgKey">消息Key值</param>
  46.         /// <param name="messageEvent">订阅事件</param>
  47.         public static void Unsubscribe(string msgKey, MessageEvent messageEvent)
  48.         {
  49.             if (msgDic.ContainsKey(msgKey))
  50.             {
  51.                 msgDic[msgKey] -= messageEvent;
  52.                 if (msgDic[msgKey] == null)
  53.                 {
  54.                     msgDic.Remove(msgKey);
  55.                 }
  56.             }
  57.         }
  58.     }
  59. }
  1. using System;
  2. using ProtoBuf;
  3. using System.IO;
  4. using System.Text;
  5.  
  6. namespace SK.Framework.Sockets
  7. {
  8.     /// <summary>
  9.     /// 协议工具
  10.     /// </summary>
  11.     public static class ProtoUtility
  12.     {
  13.         /// <summary>
  14.         /// 协议编码
  15.         /// </summary>
  16.         /// <param name="proto">协议</param>
  17.         /// <returns>返回编码后的字节数据</returns>
  18.         public static byte[] Encode(IExtensible proto)
  19.         {
  20.             using (MemoryStream ms = new MemoryStream())
  21.             {
  22.                 Serializer.Serialize(ms, proto);
  23.                 return ms.ToArray();
  24.             }
  25.         }
  26.         /// <summary>
  27.         /// 协议解码
  28.         /// </summary>
  29.         /// <param name="protoName">协议名</param>
  30.         /// <param name="bytes">要解码的byte数组</param>
  31.         /// <param name="offset">协议体所在起始位置</param>
  32.         /// <param name="count">协议体长度</param>
  33.         /// <returns>返回解码后的协议</returns>
  34.         public static IExtensible Decode(string protoName, byte[] bytes, int offset, int count)
  35.         {
  36.             using (MemoryStream ms = new MemoryStream(bytes, offset, count))
  37.             {
  38.                 Type type = Type.GetType(protoName);
  39.                 return (IExtensible)Serializer.NonGeneric.Deserialize(type, ms);
  40.             }
  41.         }
  42.         /// <summary>
  43.         /// 协议名编码
  44.         /// </summary>
  45.         /// <param name="proto">协议</param>
  46.         /// <returns>返回编码后的字节数据</returns>
  47.         public static byte[] EncodeName(IExtensible proto)
  48.         {
  49.             //名字bytes和长度
  50.             byte[] nameBytes = Encoding.UTF8.GetBytes(proto.GetType().FullName);
  51.             Int16 length = (Int16)nameBytes.Length;
  52.             //申请bytes数值
  53.             byte[] bytes = new byte[length + 2];
  54.             //组装2字节的长度信息
  55.             bytes[0] = (byte)(length % 256);
  56.             bytes[1] = (byte)(length / 256);
  57.             //组装名字bytes
  58.             Array.Copy(nameBytes, 0, bytes, 2, length);
  59.             return bytes;
  60.         }
  61.         /// <summary>
  62.         /// 协议名解码
  63.         /// </summary>
  64.         /// <param name="bytes">要解码的byte数组</param>
  65.         /// <param name="offset">起始位置</param>
  66.         /// <param name="length">长度</param>
  67.         /// <returns>返回解码后的协议名</returns>
  68.         public static string DecodeName(byte[] bytes, int offset, out int length)
  69.         {
  70.             length = 0;
  71.             //必须大于2字节
  72.             if (offset + 2 > bytes.Length) return string.Empty;
  73.             //获取长度
  74.             Int16 l = (Int16)((bytes[offset + 1] << 8) | bytes[offset]);
  75.             if (l <= 0) return string.Empty;
  76.             //长度必须足够
  77.             if (offset + 2 + l > bytes.Length) return string.Empty;
  78.             //解析
  79.             length = 2 + l;
  80.             string name = Encoding.UTF8.GetString(bytes, offset + 2, l);
  81.             return name;
  82.         }
  83.     }
  84. }

Connect 连接服务端：

创建网络管理类NetworkManager，定义Socket套接字、读缓冲区、以及正在连接和关闭的标志位等字段，封装Connect连接函数，接收两个参数，参数一ip代表服务端的IP地址，参数二port代表端口：

  1. using System;
  2. using UnityEngine;
  3. using System.Net.Sockets;
  4. using System.Collections.Generic;
  5.  
  6. namespace SK.Framework.Sockets
  7. {
  8.     public class NetworkManager : MonoBehaviour
  9.     {
  10.         //定义套接字
  11.         private static Socket socket;
  12.         //接收缓冲区
  13.         private static ByteArray readBuff;
  14.         //是否正在连接
  15.         private static bool isConnecting = false;
  16.         //是否正在关闭
  17.         private static bool isClosing = false;
  18.  
  19.         /// <summary>
  20.         /// 连接服务端
  21.         /// </summary>
  22.         /// <param name="ip">服务器IP地址</param>
  23.         /// <param name="port">端口</param>
  24.         public static void Connect(string ip, int port)
  25.         {
  26.             //状态判断
  27.             if ((socket != null && socket.Connected) || isConnecting) return;
  28.             //初始化
  29.             Init();
  30.             //参数设置
  31.             socket.NoDelay = true;
  32.             //连接
  33.             isConnecting = true;
  34.             socket.BeginConnect(ip, port, ConnectCallback, socket);
  35.         } 
  36.         //初始化状态
  37.         private static void Init()
  38.         {
  39.             //Socket
  40.             socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  41.             //接收缓冲区
  42.             readBuff = new ByteArray();
  43.             //是否正在连接
  44.             isConnecting = false;
  45.             //是否正在关闭
  46.             isClosing = false;
  47.         }
  48.         //Connect回调
  49.         private static void ConnectCallback(IAsyncResult ar)
  50.         {
  51.             try
  52.             {
  53.                 Socket socket = (Socket)ar.AsyncState;
  54.                 socket.EndConnect(ar);
  55.                 isConnecting = false;
  56.                 Debug.Log($"成功连接服务端.");
  57.                 //发布消息
  58.                 Messenger.Publish("连接服务端", true);
  59.                 //TODO：开始接收数据               
  60.             }
  61.             catch (SocketException error)
  62.             {
  63.                 Debug.Log($"连接服务端失败：{error}");
  64.                 isConnecting = false;
  65.                 //发布消息
  66.                 Messenger.Publish("连接服务端", false);
  67.             }
  68.         }
  69.     }
  70. }

NoDelay参数含义：

将其设为true时，表示不使用Nagle算法，什么是Nagle算法？

        Nagle 算法旨在通过使套接字缓冲小数据包，然后在特定情况下将它们合并并发送到一个数据包，从而减少网络流量。 TCP 数据包包含40字节的标头以及要发送的数据。 当使用 TCP 发送小型数据包时，TCP 标头产生的开销可能会成为网络流量的重要部分。 在负载较重的网络上，由于这种开销导致的拥塞会导致丢失数据报和重新传输，以及拥塞导致的传播时间过大。 如果在连接上以前传输的数据保持未确认的情况，则 Nagle 算法将禁止发送新的 TCP 段。

        启用Nagle算法可以提升网络传输效率，但它要收集到一定长度的数据后才会把它们一起发送出去。这样就会降低网络的实时性，本套框架里我们关闭Nagle算法，将socket.NoDelay设为true。

参考资料：《Unity3D网络游戏实战》（第2版）罗培羽 著

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

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

  

闽ICP备14008679号