Unity网络开发记录（五）：二进制传输消息类

消息类

前篇所写的CS模型只能传输字符串，在本篇文章中，尝试在服务端一次传输多种类型的数据，并在客户端接收到信息之后进行解析显示

为了实现对不同类型的数据传输，需要将不同类型的数据都转换成二进制的形式在网络中进行传输。所以要实现一个消息基类，提供各种类型数据的序列化与反序列化方法，再让需要发送的数据类继承该基类，实现其中信息的序列化等操作

using System;
using System.Text;

public abstract class BaseData 
{
    /// <summary>
    /// 获取字节数
    /// </summary>
    /// <returns></returns>
    public abstract int GetByteNum();

    /// <summary>
    /// 写入
    /// </summary>
    /// <returns></returns>
    public abstract byte[] Writing();

    /// <summary>
    /// 读取
    /// </summary>
    /// <param name="bytes"></param>
    /// <param name="index"></param>
    /// <returns></returns>
    public abstract int Reading(byte[] bytes, int index = 0);

    protected void WriteInt(byte[] bytes, int value, ref int index)
    {
        BitConverter.GetBytes(value).CopyTo(bytes, index);
        index += sizeof(int);
    }

    protected void WriteFloat(byte[] bytes, float value, ref int index)
    {
        BitConverter.GetBytes(value).CopyTo(bytes, index);
        index += sizeof(float);
    }

    protected void WriteString(byte[] bytes, string value, ref int index)
    {
        byte[] b1 = Encoding.UTF8.GetBytes(value);
        BitConverter.GetBytes(b1.Length).CopyTo(bytes, index);
        index += sizeof(int);
        b1.CopyTo(bytes, index);
        index += b1.Length;
    }

    protected void WriteBool(byte[] bytes, bool value, ref int index)
    {
        BitConverter.GetBytes(value).CopyTo(bytes, index);
        index += sizeof(bool);
    }

    protected void WriteData(byte[] bytes, BaseData data, ref int index)
    {
        data.Writing().CopyTo(bytes, index);
        index += data.GetByteNum();
    }

    protected int ReadInt(byte[] bytes, ref int index)
    {
        int v = BitConverter.ToInt32(bytes, index);
        index += sizeof(int);
        return v;
    }
    protected string ReadString(byte[] bytes, ref int index)
    {
        int num = BitConverter.ToInt32(bytes, index);
        index += sizeof(int);
        string v = Encoding.UTF8.GetString(bytes, index, num);
        index += num;
        return v;
    }

    protected float ReadFloat(byte[] bytes, ref int index)
    {
        float v = BitConverter.ToSingle(bytes, index);
        index += sizeof(float);
        return v;
    }

    protected bool ReadBool(byte[] bytes, ref int index)
    {
        bool v = BitConverter.ToBoolean(bytes, index);
        index += sizeof(bool);
        return v;
    }

    protected T ReadData<T>(byte[] bytes, ref int index) where T : BaseData, new()
    {
        T data = new T();
        index += data.Reading(bytes, index);
        return data;
    }
}

创建一个数据类，继承自消息基类，实现一下写入和读取的方法

using System;
using System.Text;

public class PlayerData : BaseData
{
    public int atk;
    public bool sex;
    public string name;

    public override int GetByteNum()
    {
        //int bool int（string转换成字节数组后的字节数） 字符串转字符数组后的长度 总共所占的字节数
        return sizeof(int) + sizeof(bool) + sizeof(int) + Encoding.UTF8.GetBytes(name).Length;
    }

    public override int Reading(byte[] bytes, int beginIndex = 0)
    {
        int index = beginIndex;
        atk = ReadInt(bytes, ref index);
        sex = ReadBool(bytes, ref index);
        name = ReadString(bytes, ref index);
        return index - beginIndex;
    }

    public override byte[] Writing()
    {
        int index = 0;
        byte[] bytes = new byte[GetByteNum()];
        WriteInt(bytes, atk, ref index);
        WriteBool(bytes, sex, ref index);
        WriteString(bytes, name, ref index);
        return bytes;
    }
}

为了区别不同的消息类型，需要添加一个消息头，其中有标识类型的ID

public class BaseMsg : BaseData
{
    public override int GetByteNum()
    {
        throw new System.NotImplementedException();
    }

    public override int Reading(byte[] bytes, int index = 0)
    {
        throw new System.NotImplementedException();
    }

    public override byte[] Writing()
    {
        throw new System.NotImplementedException();
    }

    public virtual int GetID()
    {
        return 0;//默认id为0
    }
}

 

创建一个最终的玩家信息类，实现读取写入方法，并设置一个标识id

public class PlayerMsg : BaseMsg
{
    public int playerID;
    public PlayerData data;

    public override int GetByteNum()
    {
        //消息头长度，int，PlayerData
        return sizeof(int) + sizeof(int) + data.GetByteNum();
    }

    public override int Reading(byte[] bytes, int index = 0)
    {
        int _index = index;
        playerID = ReadInt(bytes, ref _index);
        data = ReadData<PlayerData>(bytes, ref _index);
        return _index - index;
    }

    public override byte[] Writing()
    {
        int index = 0;
        byte[] bytes = new byte[GetByteNum()];
        WriteInt(bytes, GetID(), ref index);
        WriteInt(bytes, playerID, ref index);
        WriteData(bytes, data, ref index);
        return bytes;
    }

    public override int GetID()
    {
        return 10086;
    }

}

使用例

在服务端调用Writing方法进行序列化，然后Send。在客户端Receive后调用Reading进行反序列化

        public void Send(string info)
        {
            if (socket != null)
            {
                try
                {
                    //socket.Send(Encoding.UTF8.GetBytes(info));

                    PlayerMsg msg = new PlayerMsg();
                    msg.playerID = 114;
                    msg.data = new PlayerData();
                    msg.data.name = "123";
                    msg.data.atk = 122;
                    msg.data.sex = true;

                    socket.Send(msg.Writing());

                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);   
                }
            }
        }

先解析消息头，获得消息类型，然后根据类型进行对应解析 

    private void ReceiveMsg(object obj)
    {
        if (socket is null) return;

        while(isConnteced)
        {
            if (socket.Available > 0)
            {
                num = socket.Receive(reveiveBuffer);
                int id = BitConverter.ToInt32(reveiveBuffer, 0);
                switch (id)
                {
                    case 10086:
                        PlayerMsg msg = new PlayerMsg();
                        msg.Reading(reveiveBuffer, 4);
                        print(msg.playerID);
                        print(msg.data.atk);
                        print(msg.data.name);
                        print(msg.data.sex);
                        break;
                    default:
                        break;
                }


                //receiveQue.Enqueue(Encoding.UTF8.GetString(reveiveBuffer, 0, num));
            }
        }
    }

先启动服务端，然后在unity中运行客户端，可以看到信息解析成功了

实现了最基本的序列化反序列化通信信息的操作