Unity网络开发基础 —— 实践小项目

news2024/12/23 4:57:29

概述

接Unity网络开发基础

导入基础知识中的代码

需求分析

手动写Handler类

手动书写消息池

using GamePlayer;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 消息池中 主要是用于 注册 ID和消息类型以及消息处理器类型的映射关系
/// 方便我们获取对象 进行反序列化和消息逻辑处理
/// </summary>
public class MsgPool 
{
    //记录消息类型和ID的映射关系
    private Dictionary<int, Type> messages = new Dictionary<int, Type>();
    //记录消息处理器类型和ID的映射关系
    private Dictionary<int, Type> handlers = new Dictionary<int, Type>();

    public MsgPool()
    {
        //在构造函数中进行 注册 注册映射关系
        Register(1001, typeof(PlayerMsg), typeof(PlayerMsgHandler));
        //后面继续添加消息类
    }

    private void Register(int id, Type messageType, Type handlerType)
    {
        messages.Add(id, messageType);
        handlers.Add(id, handlerType);
    }

    /// <summary>
    /// 根据ID 得到一个指定的消息类对象
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public BaseMsg GetMessage(int id)
    {
        if (!messages.ContainsKey(id))
            return null;
        return Activator.CreateInstance(messages[id]) as BaseMsg;
    }

    /// <summary>
    /// 根据ID 得到一个指定的消息处理类对象
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public BaseHandler GetHandler(int id)
    {
        if (!handlers.ContainsKey(id))
            return null;
        return Activator.CreateInstance(handlers[id]) as BaseHandler;
    }

}

工具生成Handler

工具生成消息池

源码

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml;
using UnityEngine;

namespace GamePlayer
{
    public enum E_Player_Type
    {
        Main,
        Other,
    }
    public class PlayerTest : BaseData
    {
        public List<int> list;
        public Dictionary<int, string> dic;
        public int[] arrays;
        public E_Player_Type type;
        public PlayerData player;

        public override int GetByteNum()
        {
            int num = 0;
            num += 4; //list.Count
            for (int i = 0; i < list.Count; i++)
            {
                num += 4;
            }

            num += 4; //dic.Count
            foreach (int key in dic.Keys)
            {
                num += 4;//key所占的字节数
                num += 4;//value 字符串长度 占的字节数
                num += Encoding.UTF8.GetByteCount(dic[key]);
            }

            num += 4; //arrays.Length 数组长度
            for (int i = 0; i < arrays.Length; i++)
            {
                num += 4;
            }

            num += 4; //枚举 用int来存

            num += player.GetByteNum(); //PlayerData

            return num;
        }

        public override int Reading(byte[] bytes, int beginIndex = 0)
        {
            int index = beginIndex;

            //反序列化 list
            list = new List<int>();
            short listCount = ReadShort(bytes, ref index);            
            for (int i = 0; i < listCount; i++)
            {
                list.Add(ReadInt(bytes, ref index));
            }

            //dic
            dic = new Dictionary<int, string>();
            short dicCount = ReadShort(bytes, ref index);            
            for (int i = 0; i < dicCount; i++)
            {
                dic.Add(ReadInt(bytes, ref index), ReadString(bytes, ref index));
            }

            //arrays
            int arrayLength = ReadShort(bytes, ref index);
            arrays = new int[arrayLength];
            for (int i = 0; i < arrayLength; i++)
            {
                arrays[i] = ReadInt(bytes, ref index);
            }

            //枚举
            type = (E_Player_Type)ReadInt(bytes, ref index);

            //自定义类型
            player = ReadData<PlayerData>(bytes, ref index);

            return index - beginIndex;
        }

        public override byte[] Writing()
        {
            //固定内容
            int index = 0;
            byte[] bytes = new byte[GetByteNum()];

            //可变的 是根据成员变量来决定如何拼接的
            //存储 list的长度
            WriteShort(bytes, (short)list.Count, ref index);
            for (int i = 0; i < list.Count; i++)
            {
                WriteInt(bytes, list[i], ref index);
            }

            //存储 dic
            //先长度
            WriteShort(bytes, (short)dic.Count, ref index);
            foreach (int key in dic.Keys)
            {
                WriteInt(bytes, key, ref index);
                WriteString(bytes, dic[key], ref index);
            }

            //存储 数组
            WriteShort(bytes, (short)arrays.Length, ref index);
            for (int i = 0; i < arrays.Length; i++)
            {
                WriteInt(bytes, arrays[i], ref index);
            }

            //存储 枚举 (我们用一个 int 来存储枚举)type 是一个枚举类型
            WriteInt(bytes, Convert.ToInt32(type), ref index);

            //存储 自定义数据结构类
            WriteData(bytes, player, ref index);

            //固定内容
            return bytes;
        }
    }
}

public class GenerateCSharp 
{
    //协议保存路径
    private string SAVE_PATH = Application.dataPath + "/Scripts/Protocol/";

    //生成枚举
    public void GenerateEnum(XmlNodeList nodes)
    {
        //生成枚举脚本的逻辑
        string namespaceStr = "";
        string enumNameStr = "";
        string fieldStr = "";

        foreach (XmlNode enumNode in nodes)
        {
            //获取命名空间配置信息
            namespaceStr = enumNode.Attributes["namespace"].Value;
            //获取枚举名配置信息
            enumNameStr = enumNode.Attributes["name"].Value;

            //获取所有的字段节点 然后进行字符串拼接
            XmlNodeList enumFields = enumNode.SelectNodes("field");
            //清空上一次的数据
            fieldStr = "";
            foreach (XmlNode enumField in enumFields)
            {
                fieldStr += "\t\t" + enumField.Attributes["name"].Value;
                if (enumField.InnerText != "")
                    fieldStr += " = " + enumField.InnerText;
                fieldStr += ",\r\n";
            }
            //对所有可变的内容进行拼接
            string enumStr = $"namespace {namespaceStr}\r\n" + 
                            "{\r\n" + 
                                $"\tpublic enum {enumNameStr}\r\n" +
                                "\t{\r\n" +
                                    $"{fieldStr}" + 
                                "\t}\r\n" + 
                             "}";

            //保存文件的路径
            string path = SAVE_PATH + namespaceStr + "/Enum/";
            //如果不存在该文件夹 则创建
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }

            //字符串保存 存储为枚举脚本文件
            //参数一:文件名
            //参数二:转换成string 的 数据
            File.WriteAllText(path + enumNameStr + ".cs", enumStr);

        }

        Debug.Log("枚举生成结束");
    }

    //生成数据结构类
    public void GenerateData(XmlNodeList nodes)
    {
        string namespaceStr = "";
        string classNameStr = "";
        string fieldStr = "";
        //将 GetBytesNum方法 写成字符串
        string getByteNumStr = "";
        // 将 Writing方法 写成字符串
        string writingStr = "";
        //将 Reading方法 写成字符串
        string readingStr = "";

        foreach (XmlNode dataNode in nodes)
        {
            //命名空间
            namespaceStr = dataNode.Attributes["namespace"].Value;
            //类名
            classNameStr = dataNode.Attributes["name"].Value;
            //读取所有字段节点
            XmlNodeList fields = dataNode.SelectNodes("field");

            //通过这个方法进行成员变量声明的拼接 返回拼接结果
            fieldStr = GetFieldStr(fields);

            //通过某个方法 对GetBytesNum函数中的字符串内容进行拼接 返回结果
            getByteNumStr = GetGetBytesNumStr(fields);

            //通过某个方法 对Writing函数中的字符串内容进行拼接 返回结果
            writingStr = GetWritingStr(fields);

            //通过某个方法 对Reading函数中的字符串内容进行拼接 返回结果
            readingStr = GetReadingStr(fields);

            string dataStr = "using System.Collections.Generic;\r\n" +
                             "using System.Text;\r\n" +
                             "using System;\r\n\r\n" + 
                              $"namespace {namespaceStr}\r\n" +
                              "{\r\n" +
                                $"\tpublic class {classNameStr} : BaseData\r\n" +
                                "\t{\r\n" +
                                    $"{fieldStr}\r\n" + 
                                    "\t\tpublic override int GetByteNum()\r\n" + 
                                    "\t\t{\r\n" + 
                                        "\t\t\tint num = 0;\r\n" + 
                                        $"{getByteNumStr}" + 
                                        "\t\t\treturn num;\r\n" + 
                                    "\t\t}\r\n\r\n" + 
                                    "\t\tpublic override byte[] Writing()\r\n" + 
                                    "\t\t{\r\n" + 
                                        "\t\t\tint index = 0;\r\n" + 
                                        "\t\t\tbyte[] bytes = new byte[GetByteNum()];\r\n" + 
                                        $"{writingStr}" + 
                                        "\t\t\treturn bytes;\r\n" + 
                                    "\t\t}\r\n\r\n" +
                                    "\t\tpublic override int Reading(byte[] bytes, int beginIndex = 0)\r\n" +
                                    "\t\t{\r\n" +
                                        "\t\t\tint index = beginIndex;\r\n" +                                        
                                        $"{readingStr}" +
                                        "\t\t\treturn index - beginIndex;\r\n" +
                                    "\t\t}\r\n\r\n" +
                                "\t}\r\n" +
                              "}";

            //保存为 脚本对象
            //保存文件的路径
            string path = SAVE_PATH + namespaceStr + "/Data/";
            //如果没有该路径 就创建
            if (!Directory.Exists(path))
                Directory.CreateDirectory(path);

            //字符串保存 存储为数据结构类脚本
            File.WriteAllText(path + classNameStr + ".cs", dataStr);

        }

        Debug.Log("数据结构类生成结束");
    }


    //生成消息类
    public void CenerateMsg(XmlNodeList nodes)
    {
        string namespaceStr = "";
        string classNameStr = "";
        string idStr = "";
        string fieldStr = "";
        //将 GetBytesNum方法 写成字符串
        string getByteNumStr = "";
        // 将 Writing方法 写成字符串
        string writingStr = "";
        //将 Reading方法 写成字符串
        string readingStr = "";

        foreach (XmlNode dataNode in nodes)
        {
            //命名空间
            namespaceStr = dataNode.Attributes["namespace"].Value;
            //类名
            classNameStr = dataNode.Attributes["name"].Value;
            //消息id
            idStr = dataNode.Attributes["id"].Value;
            //读取所有字段节点
            XmlNodeList fields = dataNode.SelectNodes("field");

            //通过这个方法进行成员变量声明的拼接 返回拼接结果
            fieldStr = GetFieldStr(fields);

            //通过某个方法 对GetBytesNum函数中的字符串内容进行拼接 返回结果
            getByteNumStr = GetGetBytesNumStr(fields);

            //通过某个方法 对Writing函数中的字符串内容进行拼接 返回结果
            writingStr = GetWritingStr(fields);

            //通过某个方法 对Reading函数中的字符串内容进行拼接 返回结果
            readingStr = GetReadingStr(fields);

            string dataStr = "using System.Collections.Generic;\r\n" +
                             "using System.Text;\r\n" +
                             "using System;\r\n\r\n" +
                              $"namespace {namespaceStr}\r\n" +
                              "{\r\n" +
                                $"\tpublic class {classNameStr} : BaseMsg\r\n" +
                                "\t{\r\n" +
                                    $"{fieldStr}\r\n" +
                                    "\t\tpublic override int GetByteNum()\r\n" +
                                    "\t\t{\r\n" +
                                        "\t\t\tint num = 8;\r\n" + //这个8代表的是 消息ID的4个字节 + 消息体长度的4个字节
                                        $"{getByteNumStr}" +
                                        "\t\t\treturn num;\r\n" +
                                    "\t\t}\r\n\r\n" +
                                    "\t\tpublic override byte[] Writing()\r\n" +
                                    "\t\t{\r\n" +
                                        "\t\t\tint index = 0;\r\n" +
                                        "\t\t\tbyte[] bytes = new byte[GetByteNum()];\r\n" +
                                        "\t\t\tWriteInt(bytes, GetID(), ref index);\r\n" + 
                                        "\t\t\tWriteInt(bytes, bytes.Length - 8, ref index);\r\n" + 
                                        $"{writingStr}" +
                                        "\t\t\treturn bytes;\r\n" +
                                    "\t\t}\r\n\r\n" +
                                    "\t\tpublic override int Reading(byte[] bytes, int beginIndex = 0)\r\n" +
                                    "\t\t{\r\n" +
                                        "\t\t\tint index = beginIndex;\r\n" +
                                        $"{readingStr}" +
                                        "\t\t\treturn index - beginIndex;\r\n" +
                                    "\t\t}\r\n\r\n" +
                                    "\t\tpublic override int GetID()\r\n" +
                                    "\t\t{\r\n" +
                                        "\t\t\treturn " + idStr + ";\r\n" +
                                    "\t\t}\r\n\r\n" +
                                "\t}\r\n" +
                              "}";

            //保存为 脚本对象
            //保存文件的路径
            string path = SAVE_PATH + namespaceStr + "/Msg/";
            //如果没有该路径 就创建
            if (!Directory.Exists(path))
                Directory.CreateDirectory(path);

            //字符串保存 存储为数据结构类脚本
            File.WriteAllText(path + classNameStr + ".cs", dataStr);

            //生成处理器脚本
            //判断消息处理器脚本是否存在 如果存在 就不要覆盖了 避免把写过的逻辑处理代码覆盖了
            //如果想要改变 那就直接把没用的删了 它就会自动生成
            if (File.Exists(path + classNameStr + "Handler.cs"))
                continue;

            string handlerStr = $"namespace {namespaceStr}\r\n" +
                                "{\r\n" +
                                    $"\tpublic class {classNameStr}Handler : BaseHandler\r\n" + 
                                    "\t{\r\n" + 
                                        "\t\tpublic override void MsgHandle()\r\n" +
                                        "\t\t{\r\n" + 
                                            $"\t\t\t{classNameStr} msg = message as {classNameStr};\r\n" + 
                                        "\t\t}\r\n" + 
                                    "\t}\r\n" + 
                                "}\r\n";

            //把消息处理器类的内容保存到本地
            File.WriteAllText(path + classNameStr + "Handler.cs", handlerStr);

        }

        Debug.Log("消息类生成结束");
    }

    //生成消息池 主要就是ID和消息类型以及消息处理器类型的对应关系
    public void GenerateMsgPool(XmlNodeList nodes)
    {
        List<string> ids = new List<string>();
        List<string> names = new List<string>();
        List<string> nameSpaces = new List<string>();

        foreach (XmlNode dataNode in nodes)
        {
            //记录所有消息的ID
            string id = dataNode.Attributes["id"].Value;
            if (!ids.Contains(id))
                ids.Add(id);
            else
                Debug.LogError("存在相同ID的消息" + id);

            //记录所有消息的名字
            string name = dataNode.Attributes["name"].Value;
            if (!names.Contains(name))
                names.Add(name);
            else
                Debug.LogError("存在相同名字的消息" + id + ",建议即使在不同命名空间中也不要要同名的信息");

            //获取所有消息的命名空间
            string msgNamespace = dataNode.Attributes["namespace"].Value;
            if (!nameSpaces.Contains(msgNamespace))
                nameSpaces.Add(msgNamespace);

            //获取所有消息注册相关的内容
            string registerStr = "";
            for (int i = 0; i < ids.Count; i++)
            {
                registerStr += $"\t\tRegister({ids[i]}, typeof({names[i]}), typeof({names[i]}Handler));\r\n";
            }

            //获取所有需要引用的命名空间 
            string nameSpaceStr = "";
            for (int i = 0; i < nameSpaces.Count; i++)
            {
                nameSpaceStr += $"using {nameSpaces[i]};\r\n";
            }

            //消息池对应的类的字符串信息
            string msgPoolStr = "using System;\r\n" +
                                "using System.Collections.Generic;\r\n" +
                                nameSpaceStr +
                                "public class MsgPool\r\n" +
                                "{\r\n" +
                                    "\tprivate Dictionary<int, Type> messages = new Dictionary<int, Type>();\r\n" +
                                    "\tprivate Dictionary<int, Type> handlers = new Dictionary<int, Type>();\r\n\r\n" +
                                    "\tpublic MsgPool()\r\n" +
                                    "\t{\r\n" +
                                        registerStr +
                                    "\t}\r\n" +
                                    "\tpublic void Register(int id, Type messageType, Type handlerType)\r\n" +
                                    "\t{\r\n" +
                                        "\t\tmessages.Add(id, messageType);\r\n" +
                                        "\t\thandlers.Add(id, handlerType);\r\n" +
                                    "\t}\r\n" +
                                    "\tpublic BaseMsg GetMessage(int id)\r\n" +
                                    "\t{\r\n" +
                                        "\t\tif (!messages.ContainsKey(id))\r\n" +
                                            "\t\t\treturn null;\r\n" +
                                        "\t\treturn Activator.CreateInstance(messages[id]) as BaseMsg;\r\n" +
                                    "\t}\r\n" +
                                    "\tpublic BaseHandler GetHandler(int id)\r\n" +
                                    "\t{\r\n" +
                                        "\t\tif (!handlers.ContainsKey(id))\r\n" +
                                            "\t\t\treturn null;\r\n" +
                                        "\t\treturn Activator.CreateInstance(handlers[id]) as BaseHandler;\r\n" +
                                    "\t}\r\n" +
                                "}\r\n";

            //看看有没有这个路径
            string path = SAVE_PATH + "/Pool/";
            if (!Directory.Exists(path))
                Directory.CreateDirectory(path);

            //保存到本地
            File.WriteAllText(path + "MsgPool.cs", msgPoolStr);

            Debug.Log("消息池生成结束");
        }

        

    }

    /// <summary>
    /// 获取成员变量声明内容
    /// </summary>
    /// <param name="fields"></param>
    /// <returns></returns>
    private string GetFieldStr(XmlNodeList fields)
    {
        string fieldStr = "";
        foreach (XmlNode field in fields)
        {
            //变量类型
            string type = field.Attributes["type"].Value;
            //变量名
            string fieldName = field.Attributes["name"].Value;

            if (type == "list")
            {
                string T = field.Attributes["T"].Value;
                fieldStr += "\t\tpublic " + "List<" + T + "> ";
            }
            else if (type == "array")
            {
                string data = field.Attributes["data"].Value;
                fieldStr += "\t\tpublic " + data + "[] ";
            }
            else if(type == "dic")
            {
                string Tkey = field.Attributes["Tkey"].Value;
                string Tvalue = field.Attributes["Tvalue"].Value;
                fieldStr += "\t\tpublic " + "Dictionary<" + Tkey + ", " + Tvalue + "> ";
            }
            else if(type == "enum")
            {
                string data = field.Attributes["data"].Value;
                fieldStr += "\t\tpublic " + data + " ";
            }
            else
            {
                fieldStr += "\t\tpublic " + type + " ";
            }

            fieldStr += fieldName + ";\r\n";

        }
        return fieldStr;
    }

    /// <summary>
    /// 拼接 GetBytesNum函数的方法
    /// </summary>
    /// <param name="fields"></param>
    /// <returns></returns>
    private string GetGetBytesNumStr(XmlNodeList fields)
    {
        string bytesNumStr = "";

        string type = "";
        string name = "";
        foreach (XmlNode field in fields)
        {
            type = field.Attributes["type"].Value;
            name = field.Attributes["name"].Value;
            if (type == "list")
            {
                string T = field.Attributes["T"].Value;
                bytesNumStr += "\t\t\tnum += 2;\r\n"; // 2 是为了节约字节数 用一个short去存储数量信息
                bytesNumStr += "\t\t\tfor(int i = 0; i < " + name + ".Count; i++)\r\n";
                //这里使用的是 name + [i] 目的是获取 list当中的元素传入进行使用
                bytesNumStr += "\t\t\t\tnum += " + GetValueBytesNum(T, name + "[i]") + ";\r\n";
            }
            else if (type == "array")
            {
                string data = field.Attributes["data"].Value;
                bytesNumStr += "\t\t\tnum += 2;\r\n";
                bytesNumStr += "\t\t\tfor(int i = 0; i < " + name + ".Length; i++)\r\n";
                bytesNumStr += "\t\t\t\tnum += " + GetValueBytesNum(data, name + "[i]") + ";\r\n";
            }
            else if (type == "dic")
            {
                string Tkey = field.Attributes["Tkey"].Value;
                string Tvalue = field.Attributes["Tvalue"].Value;
                bytesNumStr += "\t\t\tnum += 2;\r\n";
                bytesNumStr += "\t\t\tforeach(" + Tkey + " key in " + name + ".Keys)\r\n";
                bytesNumStr += "\t\t\t{\r\n";
                bytesNumStr += "\t\t\t\tnum += " + GetValueBytesNum(Tkey, "key") + ";\r\n";
                bytesNumStr += "\t\t\t\tnum += " + GetValueBytesNum(Tvalue, name + "[key]") + ";\r\n";
                bytesNumStr += "\t\t\t}\r\n";
            }
            else
                bytesNumStr += "\t\t\tnum += " + GetValueBytesNum(type, name) + ";\r\n";
        }

        return bytesNumStr;

    }

    //获取指定类型的字节数
    private string GetValueBytesNum(string type, string name)
    {
        //其它类型根据需求添加
        switch (type)
        {
            case "int":
            case "float":
            case "enum":
                return "4";
            case "bool":
            case "byte":
                return "1";
            case "short":
                return "2";
            case "long":
            case "double":
                return "8";
            case "string":
                return "4 + Encoding.UTF8.GetByteCount(" + name + ")";
            default:
                return name + ".GetByteNum()";
        }
    }

    /// <summary>
    /// 拼接 Writing函数的方法
    /// </summary>
    /// <param name="field"></param>
    /// <returns></returns>
    private string GetWritingStr(XmlNodeList fields)
    {
        string writingStr = "";

        string type = "";
        string name = "";
        foreach (XmlNode field in fields)
        {
            type = field.Attributes["type"].Value;
            name = field.Attributes["name"].Value;
            if (type == "list")
            {
                string T = field.Attributes["T"].Value;
                writingStr += "\t\t\tWriteShort(bytes, (short)" + name + ".Count, ref index);\r\n";
                writingStr += "\t\t\tfor(int i = 0; i < " + name + ".Count; i++)\r\n";
                writingStr += "\t\t\t\t" + GetFieldWritingStr(T, name + "[i]") + "\r\n";
            }
            else if(type == "array")
            {
                string data = field.Attributes["data"].Value;
                writingStr += "\t\t\tWriteShort(bytes, (short)" + name + ".Length, ref index);\r\n";
                writingStr += "\t\t\tfor(int i = 0; i < " + name + ".Length; i++)\r\n";
                writingStr += "\t\t\t\t" + GetFieldWritingStr(data, name + "[i]") + "\r\n";
            }
            else if (type == "dic")
            {
                string Tkey = field.Attributes["Tkey"].Value;
                string Tvalue = field.Attributes["Tvalue"].Value;
                writingStr += "\t\t\tWriteShort(bytes, (short)" + name + ".Count, ref index);\r\n";
                writingStr += "\t\t\tforeach(" + Tkey + " key in " + name + ".Keys)\r\n";
                writingStr += "\t\t\t{\r\n";
                writingStr += "\t\t\t\t" + GetFieldWritingStr(Tkey, "key") + "\r\n";
                writingStr += "\t\t\t\t" + GetFieldWritingStr(Tvalue, name + "[key]") + "\r\n";
                writingStr += "\t\t\t}\r\n";

            }
            else
            {
                writingStr += "\t\t\t" + GetFieldWritingStr(type, name) + "\r\n";
            }


        }

        return writingStr;
    }

    private string GetFieldWritingStr(string type, string name)
    {
        switch (type)
        {
            case "byte":
                return "WriteByte(bytes, " + name + ", ref index);";
            case "int":
                return "WriteInt(bytes, " + name + ", ref index);";
            case "short":
                return "WriteShort(bytes, " + name + ", ref index);";
            case "long":
                return "WriteLong(bytes, " + name + ", ref index);";
            case "float":
                return "WriteFloat(bytes, " + name + ", ref index);";
            case "bool":
                return "WriteBool(bytes, " + name + ", ref index);";
            case "string":
                return "WriteString(bytes, " + name + ", ref index);";
            case "enum":
                return "WriteInt(bytes, Convert.ToInt32(" + name + "), ref index);"; 
            default:
                return "WriteData(bytes, " + name + ", ref index);";
        }
    }

    //
    private string GetReadingStr(XmlNodeList fields)
    {
        string readingStr = "";

        string type = "";
        string name = "";

        foreach (XmlNode field in fields)
        {
            type = field.Attributes["type"].Value;
            name = field.Attributes["name"].Value;
            if (type == "list")
            {
                string T = field.Attributes["T"].Value;
                readingStr += "\t\t\t" + name + " = new List<" + T + ">();\r\n";
                readingStr += "\t\t\tshort " + name + "Count = ReadShort(bytes, ref index);\r\n";
                readingStr += "\t\t\tfor(int i = 0; i < " + name + "Count; i++)\r\n";
                readingStr += "\t\t\t\t" + name + ".Add(" + GetFieldReadingStr(T) + ");\r\n";
            }
            else if (type == "array")
            {
                string data = field.Attributes["data"].Value;                
                readingStr += "\t\t\tshort " + name + "Length = ReadShort(bytes, ref index);\r\n";
                readingStr += "\t\t\t" + name + " = new " + data + "[" + name + "Length];\r\n";
                readingStr += "\t\t\tfor(int i = 0; i < " + name + "Length; i++)\r\n";
                readingStr += "\t\t\t\t" + name + "[i] = " + GetFieldReadingStr(data) + ";\r\n";
            }
            else if (type == "dic")
            {
                string Tkey = field.Attributes["Tkey"].Value;
                string Tvalue = field.Attributes["Tvalue"].Value;
                readingStr += "\t\t\t" + name + " = new Dictionary<" + Tkey + ", " + Tvalue + ">();\r\n";
                readingStr += "\t\t\tshort " + name + "Count = ReadShort(bytes, ref index);\r\n";
                readingStr += "\t\t\tfor(int i = 0; i < " + name + "Count; i++)\r\n";
                readingStr += "\t\t\t\t" + name + ".Add(" + GetFieldReadingStr(Tkey)
                    + ", " + GetFieldReadingStr(Tvalue) + ");\r\n";
            }
            else if (type == "enum")
            {
                string data = field.Attributes["data"].Value;
                readingStr += "\t\t\t" + name + " = (" + data + ")ReadInt(bytes, ref index);\r\n"; 
            }
            else
                readingStr += "\t\t\t" + name + " = " + GetFieldReadingStr(type) + ";\r\n";
        }

        return readingStr;
    }

    private string GetFieldReadingStr(string type)
    {
        switch (type)
        {
            case "byte":
                return "ReadByte(bytes, ref index)";
            case "int":
                return "ReadInt(bytes, ref index)";
            case "short":
                return "ReadShort(bytes, ref index)";
            case "long":
                return "ReadLong(bytes, ref index)";
            case "bool":
                return "ReadBool(bytes, ref index)";
            case "float":
                return "ReadFloat(bytes, ref index)";
            case "string":
                return "ReadString(bytes, ref index)";
            default:
                return "ReadData<" + type + ">(bytes, ref index)";
        }
    }

}

断线重连

总结

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2204092.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

(五)Proteus仿真STM32单片机串口数据流收发

&#xff08;五&#xff09;Protues仿真STM32单片机串口数据流收发 – ARMFUN 1&#xff0c;打开STM32CubeMX&#xff0c;找到USART1,配置模式Asynchronous&#xff0c;此时PA9、PA10自动变成串口模式 串口默认参数:115200bps 8bit None 1stop 2&#xff0c;NVIC Settings使能…

Linux-Docker阿里云镜像仓库失效

写在前面&#xff0c;这个是我很早之前在VmWare安装的Linux7,通过yum 安装的docker&#xff0c;但是今天怎么都无法pull镜像&#xff0c;报错如下。 Error response from daemon: Get "https://registry-1.docker.io/v2/": net/http: request canceled while waitin…

在IDEA里用XDebug调试PHP,断点....

做程序开发,调试必不可少,这里最近用到了PHP,顺便写个关于PHP的调试安装使用: 1、首先是PHP先安装xdebug扩展(还有zend的),这个我的工具是IDEA,所以安装方法也相对简单,如果你是用VSCode等应该也是一样,如下图,找到这个PHP->DEBUG 2、直接点上面的Install XDebug 就可以帮你…

Unity网络开发 - C#开源网络通信库PESocket的使用

概述 在现代多人在线游戏中&#xff0c;稳定且高效的网络通信是确保游戏体验的关键。本文将探讨如何利用C#开源网络通信库PESocket来构建一个简单的Unity客户端与.NET控制台服务器之间的实时消息传递系统。通过本例&#xff0c;读者不仅能够了解PESocket的基本用法&#xff0c…

Windows11系统下Sentinel环境搭建教程

目录 前言Sentinel简介Sentinel下载安装Sentinel配置与启动总结 前言 本文为博主在项目环境搭建时记录的Sentinel安装流程&#xff0c;希望对大家能够有所帮助&#xff0c;不足之处欢迎批评指正&#x1f91d;&#x1f91d;&#x1f91d; Sentinel简介 github主页地址 &#x…

004、合并两个有序数组

0、题目描述 合并两个有序数组 1、法1 数组nums1有m个元素&#xff0c; 直接在下标为m的位置处追加nums2的元素。然后再qsort整体排序。 —— —— qsort函数&#xff0c;&#xff08;数组首元素地址&#xff0c;排序的个数&#xff0c;排序元素大小&#xff0c; 比较函数&…

Vue】Vue扫盲(四)组件化思想与简单应用

【Vue】Vue扫盲&#xff08;一&#xff09;事件标签、事件修饰符&#xff1a;click.prevent click.stop click.stop.prevent、按键修饰符、及常用指令 【Vue】Vue扫盲&#xff08;二&#xff09;指令&#xff1a;v-for 、v-if、v-else-if、v-else、v-show 【Vue】Vue扫盲&…

Ruby脚本:自动化网页图像下载的实践案例

随着互联网的快速发展&#xff0c;网页上的内容变得越来越丰富&#xff0c;尤其是图像资源。对于需要大量图像资源的设计师、内容创作者或数据分析师来说&#xff0c;手动下载这些图片不仅耗时耗力&#xff0c;而且效率低下。因此&#xff0c;自动化网页图像下载成为了一个迫切…

3_路由器分组交换知多少?20241009

上次介绍到了路由器的分组交换戛然而止&#xff0c;这次扫盲式介绍下。 1、分组交换的主要特点 分组交换则采用存储转发技术1-11 表示把一个报文划分为几个分组后再进行传送。通常我们把要发送的整块数据称为一个报文(message)。在发送报文之前&#xff0c;先把较长的报文划分成…

java-02 数据结构-队列

在Java中&#xff0c;队列是一种常见的数据结构&#xff0c;用于在保持顺序的同时存储和检索数据。Java提供了java.util.Queue接口&#xff0c;它的常见实现包括ArrayDeque、LinkedList和PriorityQueue等。 如果你觉得我分享的内容或者我的努力对你有帮助&#xff0c;或者你只…

元数据 - iXML

在专业的音频和视频制作中&#xff0c;元数据的准确传递对于后期制作和编辑至关重要。iXML&#xff08;iXML Metadata&#xff09;是一种开放的、可扩展的元数据规范&#xff0c;旨在在录音设备和数字音频工作站&#xff08;DAW&#xff09;之间传递详细的录音信息。 一、什么是…

安卓使用.9图实现阴影效果box-shadow: 0 2px 6px 1px rgba(0,0,0,0.08);

1.安卓实现阴影效果有很多种&#xff0c;一般UX设计会给以H5参数box-shadow: 0 2px 6px 1px rgba(0,0,0,0.08);这种方式提供背景阴影效果&#xff0c;这里记录一下实现过程 2.界面xml源码 <?xml version"1.0" encoding"utf-8"?> <layout xmlns…

小北的技术博客:探索华为昇腾CANN训练营与AI技术创新——Ascend C算子开发能力认证考试(中级)

前言 哈喽哈喽,这里是zyll~,北浊.(大家可以亲切的呼唤我叫小北)智慧龙阁的创始人,一个在大数据和全站领域不断深耕的技术创作者。今天,我想和大家分享一些关于华为昇腾CANN训练营以及AI技术创新的最新资讯和实践经验~(初级证书还没拿到的小伙伴,可以先参考小北的这篇技术…

QTableView-mode中嵌入复选框CheckBox

QTableView中嵌入复选框CheckBox 第二种方法&#xff1a;设置QAbstractTableModel的flags()函数法 通过Delegate创建QCheckBox来实现的Check列&#xff0c;只有在该列进入编辑模式时才能够Check/Uncheck。这显然不是我们想要的&#xff0c;网上翻来翻去&#xff0c;在一个国外论…

SpringBoot+Vue智能社区服务小程序

SpringBootVue智能社区服务小程序 SpringBootVue智能社区服务小程序 项目描述 智能社区服务小程序的前台小程序是一个集成多功能的综合性平台&#xff0c;旨在提供便捷、高效的社区服务。以下是关于各个功能的简单介绍&#xff1a; 用户管理&#xff1a;用户管理模块负责社区…

基于SpringBoot+Vue的非物质文化遗产保护与传播系统设计实现【原创】(地图组件)

&#x1f388;系统亮点&#xff1a;地图组件&#xff1b; 一.系统开发工具与环境搭建 1.系统设计开发工具 后端使用Java编程语言的Spring boot框架 项目架构&#xff1a;B/S架构 运行环境&#xff1a;win10/win11、jdk17 前端&#xff1a; 技术&#xff1a;框架Vue.js&#x…

Mysql(五) --- 数据库设计

文章目录 前言1.范式1.1.第一范式1.1.1 定义1.1.2.例子 1.2.第二范式1.2.1 定义1.2.2 例子1.2.3.不满足第二范式可能会出现的问题 1.3.第三范式1.3.1 定义2.3.2 示例 2. 设计过程3. 实体-关系图3.1 E-R图的基本组成3.2 关系的类型3.2.1 一对一关系(1:1)3.2.2 ⼀对多关系(1:N)3.…

Mac 需要杀毒软件?

大部分 mac用户普遍认为 Apple mac 不受病毒和恶意软件的影响。这导致许多 Mac 用户误以为无需为 Mac 安装防病毒软件&#xff0c;但事实并非如此。 在这篇文章中&#xff0c;将深入探讨 Mac 安全性的细节&#xff0c;探索针对 Apple 设备的恶意软件类型&#xff0c;并为您…

高质量SCI论文撰写及投稿丨论文选题、文献调研、实验设计、数据分析、论文结构及语言规范等----AI强大功能

科学研究的核心在于将复杂的思想和实验成果通过严谨的写作有效地传递给学术界和工业界。对于研究生、青年学者及科研人员&#xff0c;如何高效撰写和发表SCI论文&#xff0c;成为提升学术水平和科研成果的重要环节。系统掌握从选题到投稿的全过程&#xff0c;提高论文撰写效率与…

petalinux 自动登陆 自动启动程序

PetaLinux 自动登陆 (1) cd 到项目工程目录下&#xff1b; (2) 运行命令&#xff1a;petalinux-config -c rootfs (3) 依次选择 Image Features -> serial-autologin-root 保存退出 创建APP petalinux-create apps --template install --name init-app --enable编辑文件 …