Unity网络开发基础——基础知识（壹）

// 初始化
byte[] ipAddress = new byte[] { 192, 168, 79, 1 }; // IP地址
IPAddress ip = new IPAddress(ipAddress); // 方式一：byte数组
IPAddress ip2 = new IPAddress(0xC0A84F01); // 方式二：long长整型，即byte数组对应的long数值，不推荐使用
IPAddress ip3 = IPAddress.Parse("192.168.79.1"); // 方式三：字符串，推荐使用

// 一些属性
IPAddress.IPv6Any; // 表示IPv6的通配地址，值为 ::

// 初始化
IPEndPoint ipPoint = new IPEndPoint(0xC0A84F01, 8080); // 方式一：long长整型，不推荐使用
IPEndPoint ipPoint2 = new IPEndPoint(IPAddress.Parse("192.168.79.1"), 8080); // 方式二：IPAddress对象，推荐使用

ipHostEntry.AddressList; // 获取关联IP
ipHostEntry.Aliases; // 获取主机别名列表
ipHostEntry.HostName; // 获取DNS名称

Dns.GetHostName();

IPHostEntry entry = Dns.GetHostEntry("www.baidu.com");

async void GetHostEntry()
{
    Task<IPHostEntry> task = Dns.GetHostEntryAsync("www.baidu.com");
    await task; // 等待网路通信获取远程主机信息完成
    IPHostEntry entry = task.Result; // 获取
}

public class Player
{
    public int lev;
    public string name;
    public int atk;
    public bool gender;
}

// 类对象
Player player = new Player();
player.lev = 1;
player.name = "PMM";
player.atk = 10;
player.gender = true;

int total = sizeof(int) + // lev的字节数组大小
            sizeof(int) + // 代表name的字节数组长度的int值
            Encoding.UTF8.GetBytes(player.name).Length + // 真正的name字符串的字节数组大小
            sizeof(int) + // atk的字节数组大小
            sizeof(bool); // gender的字节数组大小

byte[] bytes = new byte[total];

int index = 0;

// lev
BitConverter.GetBytes(player.lev).CopyTo(bytes, index);
index += sizeof(int);

// name
byte[] nameBytes = Encoding.UTF8.GetBytes(player.name);
BitConverter.GetBytes(nameBytes.Length).CopyTo(bytes, index); // 先存储name字符串的字节数组长度
index += sizeof(int);
nameBytes.CopyTo(bytes, index); // 再存储真正的name字符串的字节数组
index += nameBytes.Length;

// atk
BitConverter.GetBytes(player.atk).CopyTo(bytes, index);
index += sizeof(int);

// gender
BitConverter.GetBytes(player.gender).CopyTo(bytes, index);
index += sizeof(bool);

Player player = new Player();
int index = 0;

// lev
player.lev = BitConverter.ToInt32(bytes, index);
index += sizeof(int);

// name
int length = BitConverter.ToInt32(bytes, index); // name的字节数组长度
index += sizeof(int);
player.name = Encoding.UTF8.GetString(bytes, index, length); // 获取真正的name
index += length;

// atk
player.atk = BitConverter.ToInt32(bytes, index);
index += sizeof(int);

// gender
player.gender = BitConverter.ToBoolean(bytes, index);
index += sizeof(bool);

public abstract class BaseData
{
    /// <summary>
    /// 获取字节数组容量
    /// </summary>
    /// <returns>字节数组容量</returns>
    public abstract int GetBytesLength();

    /// <summary>
    /// 序列化方法
    /// </summary>
    /// <returns>序列化后的字节数组</returns>
    public abstract byte[] Writing();

    /// <summary>
    /// 反序列化方法
    /// </summary>
    /// <param name="bytes">字节数组</param>
    /// <param name="beginIndex">字节数组开始读取的索引</param>
    /// <returns>读取的字节数</returns>
    public abstract int Reading(byte[] bytes, int beginIndex = 0);

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

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

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

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

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

    public void WriteByte(byte[] bytes, byte value, ref int index)
    {
        bytes[index] = value;
        index += sizeof(byte);
    }

    public void WriteString(byte[] bytes, string value, ref int index)
    {
        byte[] stringBytes = Encoding.UTF8.GetBytes(value);
        WriteInt(bytes, stringBytes.Length, ref index); // 先写入字符串的字节数组长度
        stringBytes.CopyTo(bytes, index); // 再写入真正的字符串的字节数组
        index += stringBytes.Length;
    }

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

    public short ReadShort(byte[] bytes, ref int index)
    {
        short value = BitConverter.ToInt16(bytes, index);
        index += sizeof(short);
        return value;
    }

    public int ReadInt(byte[] bytes, ref int index)
    {
        int value = BitConverter.ToInt32(bytes, index);
        index += sizeof(int);
        return value;
    }

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

    public long ReadLong(byte[] bytes, ref int index)
    {
        long value = BitConverter.ToInt64(bytes, index);
        index += sizeof(long);
        return value;
    }

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

    public byte ReadByte(byte[] bytes, ref int index)
    {
        byte value = bytes[index];
        index += sizeof(byte);
        return value;
    }

    public string ReadString(byte[] bytes, ref int index)
    {
        int length = ReadInt(bytes, ref index); // 先读取字符串的字节数组长度
        string value = Encoding.UTF8.GetString(bytes, index, length);
        index += length;
        return value;
    }

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

    //TODO：列表、字典等复杂数据类型的读写方法
    //TODO：也可以使用泛型反射等知识进行封装
}

public class TestData : BaseData
{
    public short lev;
    public PlayerData p;
    public int hp;
    public string name;
    public bool sex;

    public override int GetBytesLength()
    {
        return sizeof(short) + 
            p.GetBytesLength() + 
            sizeof(int) + 
            sizeof(int) + Encoding.UTF8.GetBytes(name).Length +
            sizeof(bool);
    }

    public override int Reading(byte[] bytes, int beginIndex = 0)
    {
        int index = beginIndex;
        lev = ReadShort(bytes, ref index);
        p = ReadData<PlayerData>(bytes, ref index);
        hp = ReadInt(bytes, ref index);
        name = ReadString(bytes, ref index);
        sex = ReadBool(bytes, ref index);
        return index - beginIndex;
    }

    public override byte[] Writing()
    {
        int index = 0;
        byte[] bytes = new byte[GetBytesLength()];
        WriteShort(bytes, lev, ref index);
        WriteData(bytes, p, ref index);
        WriteInt(bytes, hp, ref index);
        WriteString(bytes, name, ref index);
        WriteBool(bytes, sex, ref index);
        return bytes;
    }
}