Unity使用protobuf-net实现的网络框架

最新推荐文章于 2024-08-14 10:56:48 发布
最新推荐文章于 2024-08-14 10:56:48 发布
阅读量8.8k 收藏 14
点赞数
分类专栏： unity protobuf-net 文章标签： unity protobuf-net
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l_jinxiong/article/details/50709745
版权

设计思想是把协议号和协议类型分别存储起来，当我们向服务端发送协议的时候，会自动根据协议类型加上协议号，并用protobuf序列化后发给服务端，客户端收到服务端发回来的协议后，会根据协议号，用protobuf根按协议类型自动反序列化成相应的对象，并调用相应的回调方法。

首先到https://github.com/mgravell/protobuf-net下载protobuf-net源码，把protobuf-net这个目录拷到Unity工程里，

我的工程目录如下


在Unity的Assest目录下新建一个smcs.rsp文件，里面填入-unsafe，重启Uniyt就可以了，如果使用VS的话，最好设置工程允许不安全代码，不然用VS调试的时候会报错


下面是主要的代码：

ProtoDic.cs 这个是存储协议号和协议类型的文件，这个主要是用代码自动生成，最好不要手动去更改

using ServerMessage;
using System;
using System.Collections.Generic;

namespace Proto
{
    public class ProtoDic
    {
        private static List<int> _protoId = new List<int>
        {
            1001,
            1002,
            1003
        };

        private static List<Type>_protoType = new List<Type>
        {
            typeof(SignUpResponse),
            typeof(TocChat),
            typeof(TosChat),
        };

        public static Type GetProtoTypeByProtoId(int protoId)
        {
            int index = _protoId.IndexOf(protoId);
            return _protoType[index];
        }

        public static int GetProtoIdByProtoType(Type type)
        {
            int index = _protoType.IndexOf(type);
            return _protoId[index];
        }

        public static bool ContainProtoId(int protoId)
        {
            if(_protoId.Contains(protoId))
            {
                return true;
            }
            return false;
        }

        public static bool ContainProtoType(Type type)
        {
            if(_protoType.Contains(type))
            {
                return true;
            }
            return false;
        }
    }
}

SocketClient.cs 这个是客户端的socket文件 

using UnityEngine;
using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Collections;
using System.Collections.Generic;
using Net;

public enum DisType
{
    Exception,
    Disconnect,
}

public class SocketClient
{
    private TcpClient client = null;
    private NetworkStream outStream = null;
    private MemoryStream memStream;
    private BinaryReader reader;

    private const int MAX_READ = 8192;
    private byte[] byteBuffer = new byte[MAX_READ];

    // Use this for initialization
    public SocketClient()
    {
    }

    /// <summary>
    /// 注册代理
    /// </summary>
    public void OnRegister()
    {
        memStream = new MemoryStream();
        reader = new BinaryReader(memStream);
    }

    /// <summary>
    /// 移除代理
    /// </summary>
    public void OnRemove()
    {
        this.Close();
        reader.Close();
        memStream.Close();
    }

    /// <summary>
    /// 连接服务器
    /// </summary>
    void ConnectServer(string host, int port)
    {
        client = null;
        client = new TcpClient();
        client.SendTimeout = 1000;
        client.ReceiveTimeout = 1000;
        client.NoDelay = true;
        try
        {
            client.BeginConnect(host, port, new AsyncCallback(OnConnect), null);
        }
        catch (Exception e)
        {
            Close();
            Debug.LogError(e.Message);
        }
    }

    /// <summary>
    /// 连接上服务器
    /// </summary>
    void OnConnect(IAsyncResult asr)
    {
        outStream = client.GetStream();
        client.GetStream().BeginRead(byteBuffer, 0, MAX_READ, new AsyncCallback(OnRead), null);
        NetManager.Instance.OnConnect();
    }

    /// <summary>
    /// 写数据
    /// </summary>
    void WriteMessage(byte[] message)
    {
        MemoryStream ms = null;
        using (ms = new MemoryStream())
        {
            ms.Position = 0;
            BinaryWriter writer = new BinaryWriter(ms);
            ushort msglen = (ushort)message.Length;
            writer.Write(msglen);
            writer.Write(message);
            writer.Flush();
            if (client != null && client.Connected)
            {
                byte[] payload = ms.ToArray();
                outStream.BeginWrite(payload, 0, payload.Length, new AsyncCallback(OnWrite), null);
            }
            else
            {
                Debug.LogError("client.connected----->>false");
            }
        }
    }

    /// <summary>
    /// 读取消息
    /// </summary>
    void OnRead(IAsyncResult asr)
    {
        int bytesRead = 0;
        try
        {
            lock (client.GetStream())
            {         //读取字节流到缓冲区
                bytesRead = client.GetStream().EndRead(asr);
            }
            if (bytesRead < 1)
            {                //包尺寸有问题，断线处理
                OnDisconnected(DisType.Disconnect, "bytesRead < 1");
                return;
            }
            OnReceive(byteBuffer, bytesRead);   //分析数据包内容，抛给逻辑层
            lock (client.GetStream())
            {         //分析完，再次监听服务器发过来的新消息
                Array.Clear(byteBuffer, 0, byteBuffer.Length);   //清空数组
                client.GetStream().BeginRead(byteBuffer, 0, MAX_READ, new AsyncCallback(OnRead), null);
            }
        }
        catch (Exception ex)
        {
            //PrintBytes();
            OnDisconnected(DisType.Exception, ex.Message);
        }
    }

    /// <summary>
    /// 丢失链接
    /// </summary>
    void OnDisconnected(DisType dis, string msg)
    {
        Close();   //关掉客户端链接
        NetManager.Instance.OnDisConnect();
    }

    /// <summary>
    /// 打印字节
    /// </summary>
    /// <param name="bytes"></param>
    void PrintBytes()
    {
        string returnStr = string.Empty;
        for (int i = 0; i < byteBuffer.Length; i++)
        {
            returnStr += byteBuffer[i].ToString("X2");
        }
        Debug.LogError(returnStr);
    }

    /// <summary>
    /// 向链接写入数据流
    /// </summary>
    void OnWrite(IAsyncResult r)
    {
        try
        {
            outStream.EndWrite(r);
        }
        catch (Exception ex)
        {
            Debug.LogError("OnWrite--->>>" + ex.Message);
        }
    }

    /// <summary>
    /// 接收到消息
    /// </summary>
    void OnReceive(byte[] bytes, int length)
    {
        memStream.Seek(0, SeekOrigin.End);
        memStream.Write(bytes, 0, length);
        //Reset to beginning
        memStream.Seek(0, SeekOrigin.Begin);
        while (RemainingBytes() > 2)
        {
            ushort messageLen = reader.ReadUInt16();
            if (RemainingBytes() >= messageLen)
            {
                MemoryStream ms = new MemoryStream();
                BinaryWriter writer = new BinaryWriter(ms);
                writer.Write(reader.ReadBytes(messageLen));
                ms.Seek(0, SeekOrigin.Begin);
                OnReceivedMessage(ms);
            }
            else
            {
                memStream.Position = memStream.Position - 2;
                break;
            }
        }
        byte[] leftover = reader.ReadBytes((int)RemainingBytes());
        memStream.SetLength(0);    
        memStream.Write(leftover, 0, leftover.Length);
    }

    /// <summary>
    /// 剩余的字节
    /// </summary>
    private long RemainingBytes()
    {
        return memStream.Length - memStream.Position;
    }

    /// <summary>
    /// 接收到消息
    /// </summary>
    /// <param name="ms"></param>
    void OnReceivedMessage(MemoryStream ms)
    {
        BinaryReader r = new BinaryReader(ms);
        byte[] message = r.ReadBytes((int)(ms.Length - ms.Position));        
        ByteBuffer buffer = new ByteBuffer(message);
        int mainId = buffer.ReadShort();
        NetManager.Instance.DispatchProto(mainId, buffer);
    }


    /// <summary>
    /// 会话发送
    /// </summary>
    void SessionSend(byte[] bytes)
    {
        WriteMessage(bytes);
    }

    /// <summary>
    /// 关闭链接
    /// </summary>
    public void Close()
    {
        if (client != null)
        {
            if (client.Connected) client.Close();
            client = null;
        }
    }

    /// <summary>
    /// 发送连接请求
    /// </summary>
    public void SendConnect()
    {
        ConnectServer(AppConst.SocketAddress, AppConst.SocketPort);
    }

    /// <summary>
    /// 发送消息
    /// </summary>
    public void SendMessage(ByteBuffer buffer)
    {
        SessionSend(buffer.ToBytes());
        buffer.Close();
    }
}

NetManager.cs 这个是网络功能的管理文件 

using UnityEngine;
using System.Collections;
using Util;
using System.Collections.Generic;
using System;
using Proto;
using System.IO;

namespace Net
{
    public class NetManager : SingletonMonoBehaviour<NetManager>
    {
        private Dictionary<Type, TocHandler> _handlerDic;
        private SocketClient _socketClient;
        SocketClient socketClient
        {
            get
            {
                if (_socketClient == null)
                {
                    _socketClient = new SocketClient();
                }
                return _socketClient;
            }
        }

        void Start()
        {
            Init();
        }

        public void Init()
        {
            _handlerDic = new Dictionary<Type, TocHandler>();
            socketClient.OnRegister();
        }

        /// <summary>
        /// 发送链接请求
        /// </summary>
        public void SendConnect()
        {
            socketClient.SendConnect();
        }

        /// <summary>
        /// 关闭网络
        /// </summary>
        public void OnRemove()
        {
            socketClient.OnRemove();
        }

        /// <summary>
        /// 发送SOCKET消息
        /// </summary>
        public void SendMessage(ByteBuffer buffer)
        {
            socketClient.SendMessage(buffer);
        }

        /// <summary>
        /// 发送SOCKET消息
        /// </summary>
        public void SendMessage(object obj)
        {
            if (!ProtoDic.ContainProtoType(obj.GetType()))
            {
                Debug.LogError("不存协议类型");
                return;
            }
            ByteBuffer buff = new ByteBuffer();
            int protoId = ProtoDic.GetProtoIdByProtoType(obj.GetType());
            buff.WriteShort((ushort)protoId);
            MemoryStream ms = new MemoryStream();
            ProtoBuf.Serializer.Serialize(ms, obj);
            byte[] result = ms.ToArray();
            buff.WriteBytes(result);
            SendMessage(buff);
        }

        /// <summary>
        /// 连接 
        /// </summary>
        public void OnConnect()
        {
            Debug.Log("======连接========");
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void OnDisConnect()
        {
            Debug.Log("======断开连接========");
        }

        /// <summary>
        /// 派发协议
        /// </summary>
        /// <param name="protoId"></param>
        /// <param name="buff"></param>
        public void DispatchProto(int protoId, ByteBuffer buff)
        {
            if(!ProtoDic.ContainProtoId(protoId))
            {
                Debug.LogError("未知协议号");
                return;
            }
            Type protoType = ProtoDic.GetProtoTypeByProtoId(protoId);
            object toc = ProtoBuf.Serializer.Deserialize(protoType, new MemoryStream(buff.ReadBytes()));
            sEvents.Enqueue(new KeyValuePair<Type, object>(protoType, toc));
        }

        static Queue<KeyValuePair<Type, object>> sEvents = new Queue<KeyValuePair<Type, object>>();
        /// <summary>
        /// 交给Command，这里不想关心发给谁。
        /// </summary>
        void Update()
        {
            if (sEvents.Count > 0)
            {
                while (sEvents.Count > 0)
                {
                    KeyValuePair<Type, object> _event = sEvents.Dequeue();
                    if (_handlerDic.ContainsKey(_event.Key))
                    {
                        _handlerDic[_event.Key](_event.Value);
                    }
                }
            }
        }

        public void AddHandler(Type type, TocHandler handler)
        {
            if (_handlerDic.ContainsKey(type))
            {
                _handlerDic[type] += handler;
            }
            else
            {
                _handlerDic.Add(type, handler);
            }
        }
    }

}


最后附上一个简单的测试工程:https://github.com/caolaoyao/Chat

把工程下载下来，用Unity 5.x把开main入口就可以看到效果了

l_jinxiong
关注
专栏目录
Unity之Protobuf-net的使用
TxNet
03-05 3474
protobuf的使用方式 1.手动编写 2..proto文件自动生成 1.手动方式手动编写protobuf序列化的实体类[ProtoContract]//序列化类 public class Student { [ProtoMember(1)]//序列化属性 public string name; [ProtoMember(2)]
Unity之C#端使用protobuf
TxNet
02-22 2894
protobuf全称Protocol Buffers，由Google推出的一种平台、语言无关的数据交互格式，目前使用最广泛的一种数据格式，尤其在网络传输过程中，有很强的安全性，而且数据量比json和xml要小很多。最主要的是protobuf支持的语言非常多，不管你是.net，java，lua，iOS，android，python，go，等等等等。都可以支持互相通信。我们之前的游戏框架都是lua的，所以protobuf用的也都是lua版本的。
Unity使用的protobuf-net
02-20
Unity使用的protobuf-net，使用方法可参考本人的文章，地址：https://blog.csdn.net/menghuangxiao/article/details/87824619
《Unity3D网络游戏实战》通用服务器框架
最新发布
zaizai1007的博客
08-14 336
实现一套通用的服务端框架
unity中简单实用protobuf（Protobuf-net）
mrzhengttl的博客
04-28 9861
（一） Protobuf 是Google的一个开源序列化库，因为使用的数据压缩算法等优化，序列化的数据较Xml更小，速度更快，因为序列化后数据是以紧凑的二进制流形式展现的，所以几乎不可直接查看。 由于Protobuf不支持.Net3.5及以下版本，所以如果要在Unity3D当中使用，则需要用到第三方的Protobuf-net库。 Protobuf-net也是开源的，项目地址如下：
Unity 3D游戏客户端基础框架 protobuf网络框架
Peter的博客
07-29 1009
前言： protobuf是google的一个开源项目，主要的用途是： 1.数据存储（序列化和反序列化），这个功能类似xml和json等； 2.制作网络通信协议； 一、资源下载： 1.github源码地址：https://github.com/mgravell/protobuf-net 2.google项目源码下载地址（访问需翻墙）：https://code.google.com/p/protobuf-net/ 二、数据存储： C#语言方式的导表和解...
unity protobuf-netunity protobuf-net使用实践
qq_35107322的博客
11-30 396
1 下载代码 git clone https://github.com/protobuf-net/protobuf-net.git 2 本人使用vs2019编译发布 进入protobuf-net\src 打开protobuf-net.sln 全部重新生成 OK 如果有问题，一般可以补安装一些sdk。。。 实际使用到的是protobuf-net和protogen 在vs里选中这两个目录，右键生成，done 3 测试一下protogen， .\protogen.exe --csharp_out=cs --pac
（013）Unity 使用 protobuf-net.dll
WGYHAPPY的博客
01-22 1174
文章目录项目地址编译 项目地址 Protobuf-net 编译 下载源码，打开 src\protobuf-net.sln , 在命令行窗口运行 dotnet build , 运行完成后把 src\protobuf-net\bin\Debug\net461 目录下的 dll 文件拷贝到 unity 的 Assets 目录下。 ...
protobuf-net网络协议的定制
08-25
protobuf-net是Google开源的一种高效、跨平台的数据序列化框架，它是Protocol Buffers的.NET实现。在.NET环境中，protobuf-net提供了一种快速、小巧且可扩展的方式来序列化和反序列化对象，广泛应用于网络通信和数据...
Unity中使用Protobuf-net
无道的博客
02-04 3639
使用Protobuf的好处我就不说了，这里强调使用。（目前我认为是为了实现C++服务器与unity的C#之间的跨平台通信） 首先从gitHub上下载源码   https://github.com/mgravell/protobuf-net 然后进入如下目录下 点击.csproj,进入工程  编译一下，得到如下图： 把protobuf-net.dll加入到 打开该目录下的.
Unity3D中使用Protobuf-net
小孔明的专栏
05-25 181
https://gameinstitute.qq.com/community/detail/124250
protobuf-net
12-01
在网上下载的protobuf，适用于unity项目，在里面的imges下有需要摆放的位置，smcs一定要放在Assets下
protobuf for unity 在unity中使用protobuf工程示例
05-10
protobuf for unity 在unity中使用protobuf工程示例，数据的序列化和反序列化工程示例
unity-protobuf3
02-27
unity通讯之protobuf文件传输，protobuf3序列化与反序列化。
《Unity 3D游戏客户端基础框架》 protobuf网络框架
热门推荐
linshuhe1的专栏
08-25 3万+
前言：         protobuf是google的一个开源项目，主要的用途是： 1.数据存储（序列化和反序列化），例如xml和json等； 2.制作网络通信协议； 一、资源下载： 1.github源码地址：https://github.com/mgravell/protobuf-net 2.google项目源码下载地址（访问需翻墙）：https://code.google
Unity使用Protobuf
qq_25670983的博客
01-15 640
unity 使用protobuf
[C#基础]网络编程(三):protobuf-net
宏哥的博客
04-06 1871
相关链接： http://www.cnblogs.com/xuf22/articles/3504399.html http://blog.csdn.net/ddxkjddx/article/details/7239798 http://www.cnblogs.com/sifenkesi/p/4045392.html protobuf-net官方下载地址：https://code.g
Unity 如果要用protobuf-net，只导入protobuf-net.dll可以吗
07-20
在Unity中使用protobuf-net库，导入protobuf-net.dll是必须的，因为它包含了protobuf-net的核心功能。protobuf-net.dll是用于在Unity中进行序列化和反序列化操作的主要DLL文件。 但是，请注意，protobuf-net库依赖于System.Runtime.Serialization.dll，这是.NET Framework的一部分，提供了用于序列化和反序列化的基本类型和功能。在大多数情况下，Unity项目已经包含了System.Runtime.Serialization.dll，无需手动导入。但是如果在使用protobuf-net时遇到缺少System.Runtime.Serialization.dll的问题，你可能需要手动将它导入到Unity项目中。 因此，为了正确地使用protobuf-net库，你需要导入protobuf-net.dll和确保System.Runtime.Serialization.dll已经包含在Unity项目中。这样你就可以使用protobuf-net库进行数据的序列化和反序列化操作了。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值