com.alicizax.unity.framework/Runtime/ABase/Extension/Extension/BufferExtension.cs

using System;
using System.Buffers.Binary;
using System.Text;

public static class BufferExtension
{
    /// <summary>
    /// 整型的大小
    /// </summary>
    public const int IntSize = sizeof(int);

    /// <summary>
    /// 无符号整型的大小
    /// </summary>
    public const int UIntSize = sizeof(uint);

    /// <summary>
    /// 短整型的大小
    /// </summary>
    public const int ShortSize = sizeof(short);

    /// <summary>
    /// 无符号短整型的大小
    /// </summary>
    public const int UShortSize = sizeof(ushort);

    /// <summary>
    /// 长整型的大小
    /// </summary>
    public const int LongSize = sizeof(long);

    /// <summary>
    /// 单精度浮点数的大小
    /// </summary>
    public const int FloatSize = sizeof(float);

    /// <summary>
    /// 双精度浮点数的大小
    /// </summary>
    public const int DoubleSize = sizeof(double);

    /// <summary>
    /// 字节的大小
    /// </summary>
    public const int ByteSize = sizeof(byte);

    /// <summary>
    /// 有符号字节的大小
    /// </summary>
    public const int SbyteSize = sizeof(sbyte);

    /// <summary>
    /// 布尔值的大小
    /// </summary>
    public const int BoolSize = sizeof(bool);


    #region Write

    /// <summary>
    /// 将整数写入字节数组中的指定偏移量处。
    /// </summary>
    /// <param name="buffer">要写入的字节数组。</param>
    /// <param name="value">要写入的整数值。</param>
    /// <param name="offset">写入操作的偏移量。</param>
    public static unsafe void WriteInt(this byte[] buffer, int value, ref int offset)
    {
        if (offset + IntSize > buffer.Length)
        {
            offset += IntSize;
            return;
        }

        fixed (byte* ptr = buffer)
        {
            *(int*)(ptr + offset) = System.Net.IPAddress.HostToNetworkOrder(value);
            offset += IntSize;
        }
    }

    /// <summary>
    /// 将无符号整数写入字节数组中的指定偏移量处。
    /// </summary>
    /// <param name="buffer">要写入的字节数组。</param>
    /// <param name="value">要写入的整数值。</param>
    /// <param name="offset">写入操作的偏移量。</param>
    public static unsafe void WriteUInt(this byte[] buffer, uint value, ref int offset)
    {
        if (offset + IntSize > buffer.Length)
        {
            offset += IntSize;
            return;
        }

        var span = buffer.AsSpan<byte>();
        ref var local = ref span;
        int start = offset;
        BinaryPrimitives.WriteUInt32BigEndian(local.Slice(start, local.Length - start), value);
        offset += IntSize;
    }

    /// <summary>将一个16位无符号整数写入指定的缓冲区，并更新偏移量。</summary>
    /// <param name="buffer">要写入的缓冲区。</param>
    /// <param name="value">要写入的值。</param>
    /// <param name="offset">要写入值的缓冲区中的偏移量。</param>
    public static void WriteUShort(this byte[] buffer, ushort value, ref int offset)
    {
        if (offset + 2 > buffer.Length)
        {
            offset += 2;
        }
        else
        {
            Span<byte> span = buffer.AsSpan<byte>();
            ref Span<byte> local = ref span;
            int start = offset;
            BinaryPrimitives.WriteUInt16BigEndian(local.Slice(start, local.Length - start), value);
            offset += 2;
        }
    }

    /// <summary>
    /// 将短整数写入字节数组中的指定偏移量处。
    /// </summary>
    /// <param name="buffer">要写入的字节数组。</param>
    /// <param name="value">要写入的短整数值。</param>
    /// <param name="offset">写入操作的偏移量。</param>
    public static unsafe void WriteShort(this byte[] buffer, short value, ref int offset)
    {
        if (offset + ShortSize > buffer.Length)
        {
            offset += ShortSize;
            return;
        }

        fixed (byte* ptr = buffer)
        {
            *(short*)(ptr + offset) = System.Net.IPAddress.HostToNetworkOrder(value);
            offset += ShortSize;
        }
    }

    /// <summary>
    /// 将长整数写入字节数组中的指定偏移量处。
    /// </summary>
    /// <param name="buffer">要写入的字节数组。</param>
    /// <param name="value">要写入的长整数值。</param>
    /// <param name="offset">写入操作的偏移量。</param>
    public static unsafe void WriteLong(this byte[] buffer, long value, ref int offset)
    {
        if (offset + LongSize > buffer.Length)
        {
            offset += LongSize;
            return;
        }

        fixed (byte* ptr = buffer)
        {
            *(long*)(ptr + offset) = System.Net.IPAddress.HostToNetworkOrder(value);
            offset += LongSize;
        }
    }

    /// <summary>
    /// 将单精度浮点数写入字节数组中的指定偏移量处。
    /// </summary>
    /// <param name="buffer">要写入的字节数组。</param>
    /// <param name="value">要写入的单精度浮点数值。</param>
    /// <param name="offset">字节数组中的偏移量，传递引用以便更新偏移量。</param>
    public static unsafe void WriteFloat(this byte[] buffer, float value, ref int offset)
    {
        if (offset + FloatSize > buffer.Length)
        {
            offset += FloatSize;
            return;
        }

        fixed (byte* ptr = buffer)
        {
            *(float*)(ptr + offset) = value;
            *(int*)(ptr + offset) = System.Net.IPAddress.HostToNetworkOrder(*(int*)(ptr + offset));
            offset += FloatSize;
        }
    }

    /// <summary>
    /// 将双精度浮点数写入字节数组中的指定偏移量处。
    /// </summary>
    /// <param name="buffer">要写入的字节数组。</param>
    /// <param name="value">要写入的双精度浮点数值。</param>
    /// <param name="offset">字节数组中的偏移量，传递引用以便更新偏移量。</param>
    public static unsafe void WriteDouble(this byte[] buffer, double value, ref int offset)
    {
        if (offset + DoubleSize > buffer.Length)
        {
            offset += DoubleSize;
            return;
        }

        fixed (byte* ptr = buffer)
        {
            *(double*)(ptr + offset) = value;
            *(long*)(ptr + offset) = System.Net.IPAddress.HostToNetworkOrder(*(long*)(ptr + offset));
            offset += DoubleSize;
        }
    }

    /// <summary>
    /// 将字节写入字节数组中的指定偏移量处。
    /// </summary>
    /// <param name="buffer">要写入的字节数组。</param>
    /// <param name="value">要写入的字节值。</param>
    /// <param name="offset">字节数组中的偏移量，传递引用以便更新偏移量。</param>
    public static unsafe void WriteByte(this byte[] buffer, byte value, ref int offset)
    {
        if (offset + ByteSize > buffer.Length)
        {
            offset += ByteSize;
            return;
        }

        fixed (byte* ptr = buffer)
        {
            *(ptr + offset) = value;
            offset += ByteSize;
        }
    }

    /// <summary>
    /// 在给定的偏移量位置，向缓冲区中写入字节序列，不包含长度信息。
    /// </summary>
    /// <param name="buffer">目标缓冲区。</param>
    /// <param name="value">要写入的字节数组。</param>
    /// <param name="offset">偏移量。</param>
    public static unsafe void WriteBytesWithoutLength(this byte[] buffer, byte[] value, ref int offset)
    {
        if (value == null)
        {
            buffer.WriteInt(0, ref offset);
            return;
        }

        if (offset + value.Length + IntSize > buffer.Length)
        {
            throw new ArgumentException($"buffer write out of index {offset + value.Length + IntSize}, {buffer.Length}");
        }

        fixed (byte* ptr = buffer, valPtr = value)
        {
            Buffer.MemoryCopy(valPtr, ptr + offset, value.Length, value.Length);
            offset += value.Length;
        }
    }

    /// <summary>
    /// 将字节数组写入到缓冲区中，同时更新偏移量。
    /// </summary>
    /// <param name="buffer">目标缓冲区。</param>
    /// <param name="value">要写入的字节数组。</param>
    /// <param name="offset">偏移量。</param>
    public static unsafe void WriteBytes(this byte[] buffer, byte[] value, ref int offset)
    {
        if (value == null)
        {
            buffer.WriteInt(0, ref offset);
            return;
        }

        if (offset + value.Length + IntSize > buffer.Length)
        {
            offset += value.Length + IntSize;
            return;
        }

        buffer.WriteInt(value.Length, ref offset);
        System.Array.Copy(value, 0, buffer, offset, value.Length);
        offset += value.Length;
    }

    /// <summary>
    /// 将有符号字节写入到缓冲区中，同时更新偏移量。
    /// </summary>
    /// <param name="buffer">目标缓冲区。</param>
    /// <param name="value">要写入的有符号字节。</param>
    /// <param name="offset">偏移量。</param>
    public static unsafe void WriteSByte(this byte[] buffer, sbyte value, ref int offset)
    {
        if (offset + SbyteSize > buffer.Length)
        {
            offset += SbyteSize;
            return;
        }

        fixed (byte* ptr = buffer)
        {
            *(sbyte*)(ptr + offset) = value;
            offset += SbyteSize;
        }
    }

    /// <summary>
    /// 将字符串写入到缓冲区中，同时更新偏移量。
    /// </summary>
    /// <param name="buffer">目标缓冲区。</param>
    /// <param name="value">要写入的字符串。</param>
    /// <param name="offset">偏移量。</param>
    public static unsafe void WriteString(this byte[] buffer, string value, ref int offset)
    {
        if (value == null)
        {
            value = string.Empty;
        }

        int len = System.Text.Encoding.UTF8.GetByteCount(value);

        if (len > short.MaxValue)
        {
            throw new ArgumentException($"字符串长度超过了 short.MaxValue {len}, {short.MaxValue}");
        }

        // 预判已经超出长度了，直接计算长度就行了
        if (offset + len + ShortSize > buffer.Length)
        {
            offset += len + ShortSize;
            return;
        }

        fixed (byte* ptr = buffer)
        {
            System.Text.Encoding.UTF8.GetBytes(value, 0, value.Length, buffer, offset + ShortSize);
            buffer.WriteShort((short)len, ref offset);
            offset += len;
        }
    }

    /// <summary>
    /// 将布尔值写入到缓冲区中，同时更新偏移量。
    /// </summary>
    /// <param name="buffer">目标缓冲区。</param>
    /// <param name="value">要写入的布尔值。</param>
    /// <param name="offset">偏移量。</param>
    public static unsafe void WriteBool(this byte[] buffer, bool value, ref int offset)
    {
        if (offset + BoolSize > buffer.Length)
        {
            offset += BoolSize;
            return;
        }

        fixed (byte* ptr = buffer)
        {
            *(bool*)(ptr + offset) = value;
            offset += BoolSize;
        }
    }

    #endregion

    #region Read

    /// <summary>
    /// 从字节数组中读取一个整数值。
    /// </summary>
    /// <param name="buffer">包含整数值的字节数组。</param>
    /// <param name="offset">从字节数组中读取整数值的偏移量。</param>
    /// <returns>从字节数组中读取的整数值。</returns>
    public static unsafe int ReadInt(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + IntSize)
        {
            throw new ArgumentOutOfRangeException(nameof(offset), "buffer read out of index");
        }

        fixed (byte* ptr = buffer)
        {
            var value = *(int*)(ptr + offset);
            offset += IntSize;
            return System.Net.IPAddress.NetworkToHostOrder(value);
        }
    }

    /// <summary>
    /// 从字节数组中读取一个无符号整数值。
    /// </summary>
    /// <param name="buffer">包含整数值的字节数组。</param>
    /// <param name="offset">从字节数组中读取整数值的偏移量。</param>
    /// <returns>从字节数组中读取的无符号整数值。</returns>
    /// <exception cref="Exception"></exception>
    public static uint ReadUInt(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + UIntSize)
        {
            throw new Exception("buffer read out of index");
        }

        Span<byte> span = buffer.AsSpan<byte>();
        ref Span<byte> local = ref span;
        int start = offset;
        int num = (int)BinaryPrimitives.ReadUInt32BigEndian((ReadOnlySpan<byte>)local.Slice(start, local.Length - start));
        offset += UIntSize;
        return (uint)num;
    }

    /// <summary>
    /// 从字节数组中读取一个短整数值。
    /// </summary>
    /// <param name="buffer">包含短整数值的字节数组。</param>
    /// <param name="offset">从字节数组中读取短整数值的偏移量。</param>
    /// <returns>从字节数组中读取的短整数值。</returns>
    public static unsafe short ReadShort(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + ShortSize)
        {
            throw new ArgumentOutOfRangeException(nameof(offset), "buffer read out of index");
        }

        fixed (byte* ptr = buffer)
        {
            var value = *(short*)(ptr + offset);
            offset += ShortSize;
            return System.Net.IPAddress.NetworkToHostOrder(value);
        }
    }

    /// <summary>从字节数组中读取16位无符号整数，并将偏移量向前移动。</summary>
    /// <param name="buffer">要读取的字节数组。</param>
    /// <param name="offset">引用偏移量。</param>
    /// <returns>返回读取的16位无符号整数。</returns>
    public static ushort ReadUShort(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + UShortSize)
        {
            throw new Exception("buffer read out of index");
        }

        Span<byte> span = buffer.AsSpan<byte>();
        ref Span<byte> local = ref span;
        int start = offset;
        int num = (int)BinaryPrimitives.ReadUInt16BigEndian((ReadOnlySpan<byte>)local.Slice(start, local.Length - start));
        offset += UShortSize;
        return (ushort)num;
    }

    /// <summary>
    /// 从字节数组中读取一个长整型数值。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <returns>长整型数值。</returns>
    public static unsafe long ReadLong(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + LongSize)
        {
            throw new ArgumentOutOfRangeException(nameof(offset), "buffer read out of index");
        }

        fixed (byte* ptr = buffer)
        {
            var value = *(long*)(ptr + offset);
            offset += LongSize;
            return System.Net.IPAddress.NetworkToHostOrder(value);
        }
    }

    /// <summary>
    /// 从字节数组中读取一个单精度浮点数值。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <returns>单精度浮点数值。</returns>
    public static unsafe float ReadFloat(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + FloatSize)
        {
            throw new ArgumentOutOfRangeException(nameof(offset), "buffer read out of index");
        }

        fixed (byte* ptr = buffer)
        {
            *(int*)(ptr + offset) = System.Net.IPAddress.NetworkToHostOrder(*(int*)(ptr + offset));
            var value = *(float*)(ptr + offset);
            offset += FloatSize;
            return value;
        }
    }

    /// <summary>
    /// 从字节数组中读取一个双精度浮点数值。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <returns>双精度浮点数值。</returns>
    public static unsafe double ReadDouble(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + DoubleSize)
        {
            throw new ArgumentOutOfRangeException(nameof(offset), "buffer read out of index");
        }

        fixed (byte* ptr = buffer)
        {
            *(long*)(ptr + offset) = System.Net.IPAddress.NetworkToHostOrder(*(long*)(ptr + offset));
            var value = *(double*)(ptr + offset);
            offset += DoubleSize;
            return value;
        }
    }

    /// <summary>
    /// 从字节数组中读取一个字节。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <returns>字节值。</returns>
    public static unsafe byte ReadByte(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + ByteSize)
        {
            throw new ArgumentOutOfRangeException(nameof(offset), "buffer read out of index");
        }

        fixed (byte* ptr = buffer)
        {
            var value = *(ptr + offset);
            offset += ByteSize;
            return value;
        }
    }

    /// <summary>
    /// 从字节数组中读取一定长度的字节。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <param name="len">数据长度。</param>
    /// <returns>读取的字节数组。</returns>
    public static unsafe byte[] ReadBytes(this byte[] buffer, int offset, int len)
    {
        //数据不可信
        if (len <= 0 || offset > buffer.Length + len * ByteSize)
        {
            return Array.Empty<byte>();
        }

        var data = new byte[len];
        System.Array.Copy(buffer, offset, data, 0, len);
        return data;
    }

    /// <summary>
    /// 从字节数组中读取一定长度的字节。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <param name="len">数据长度。</param>
    /// <returns>读取的字节数组。</returns>
    public static unsafe byte[] ReadBytes(this byte[] buffer, ref int offset, int len)
    {
        //数据不可信
        if (len <= 0 || offset > buffer.Length + len * ByteSize)
        {
            return Array.Empty<byte>();
        }

        var data = new byte[len];
        System.Array.Copy(buffer, offset, data, 0, len);
        offset += len;
        return data;
    }

    /// <summary>
    /// 从字节数组中读取一定长度的字节。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <returns>读取的字节数组。</returns>
    public static unsafe byte[] ReadBytes(this byte[] buffer, ref int offset)
    {
        var len = ReadInt(buffer, ref offset);
        //数据不可信
        if (len <= 0 || offset > buffer.Length + len * ByteSize)
        {
            return Array.Empty<byte>();
        }

        var data = new byte[len];
        System.Array.Copy(buffer, offset, data, 0, len);
        offset += len;
        return data;
    }

    /// <summary>
    /// 从字节数组中读取有符号字节。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <returns>读取的有符号字节。</returns>
    public static unsafe sbyte ReadSByte(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + ByteSize)
        {
            throw new ArgumentOutOfRangeException(nameof(offset), "buffer read out of index");
        }

        fixed (byte* ptr = buffer)
        {
            var value = *(sbyte*)(ptr + offset);
            offset += ByteSize;
            return value;
        }
    }

    /// <summary>
    /// 从字节数组中读取字符串。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <returns>读取的字符串。</returns>
    public static unsafe string ReadString(this byte[] buffer, ref int offset)
    {
        fixed (byte* ptr = buffer)
        {
            var len = ReadShort(buffer, ref offset);
            //数据不可信
            if (len <= 0 || offset > buffer.Length + len * ByteSize)
                return "";

            var value = System.Text.Encoding.UTF8.GetString(buffer, offset, len);
            offset += len;
            return value;
        }
    }

    /// <summary>
    /// 从字节数组中读取布尔值。
    /// </summary>
    /// <param name="buffer">字节数组。</param>
    /// <param name="offset">偏移量。</param>
    /// <returns>读取的布尔值。</returns>
    public static unsafe bool ReadBool(this byte[] buffer, ref int offset)
    {
        if (offset > buffer.Length + BoolSize)
        {
            throw new ArgumentOutOfRangeException(nameof(offset), "buffer read out of index");
        }

        fixed (byte* ptr = buffer)
        {
            var value = *(bool*)(ptr + offset);
            offset += BoolSize;
            return value;
        }
    }

    #endregion

    /// <summary>
    /// 将字节数组转换为字符串
    /// </summary>
    /// <param name="bytes"></param>
    /// <returns></returns>
    public static string ToArrayString(this byte[] bytes)
    {
        StringBuilder.Clear();
        foreach (byte b in bytes)
        {
            StringBuilder.Append(b + " ");
        }

        return StringBuilder.ToString();
    }

    private static readonly StringBuilder StringBuilder = new StringBuilder();

    /// <summary>
    /// 将字节转换为十六进制字符串。
    /// </summary>
    /// <param name="b">要转换的字节。</param>
    /// <returns>表示字节的十六进制字符串。</returns>
    public static string ToHex(this byte b)
    {
        return b.ToString("X2");
    }

    /// <summary>
    /// 将字节数组转换为十六进制字符串。
    /// </summary>
    /// <param name="bytes">要转换的字节数组。</param>
    /// <returns>表示字节数组的十六进制字符串。</returns>
    public static string ToHex(this byte[] bytes)
    {
        StringBuilder.Clear();
        foreach (byte b in bytes)
        {
            StringBuilder.Append(b.ToString("X2"));
        }

        return StringBuilder.ToString();
    }

    /// <summary>
    /// 使用指定格式将字节数组转换为十六进制字符串。
    /// </summary>
    /// <param name="bytes">要转换的字节数组。</param>
    /// <param name="format">十六进制格式。</param>
    /// <returns>表示字节数组的十六进制字符串。</returns>
    public static string ToHex(this byte[] bytes, string format)
    {
        StringBuilder.Clear();
        foreach (byte b in bytes)
        {
            StringBuilder.Append(b.ToString(format));
        }

        return StringBuilder.ToString();
    }

    /// <summary>
    /// 将字节数组中指定范围的字节转换为十六进制字符串。
    /// </summary>
    /// <param name="bytes">要转换的字节数组。</param>
    /// <param name="offset">起始偏移量。</param>
    /// <param name="count">要转换的字节数。</param>
    /// <returns>表示指定范围内字节的十六进制字符串。</returns>
    public static string ToHex(this byte[] bytes, int offset, int count)
    {
        StringBuilder.Clear();
        for (int i = offset; i < offset + count; ++i)
        {
            StringBuilder.Append(bytes[i].ToString("X2"));
        }

        return StringBuilder.ToString();
    }

    /// <summary>
    /// 将字节数组转换为字符串，使用默认编码。
    /// </summary>
    /// <param name="bytes">要转换的字节数组。</param>
    /// <returns>转换后的字符串。</returns>
    public static string ToDefaultString(this byte[] bytes)
    {
        return Encoding.Default.GetString(bytes);
    }

    /// <summary>
    /// 将字节数组的一部分转换为字符串，使用默认编码。
    /// </summary>
    /// <param name="bytes">要转换的字节数组。</param>
    /// <param name="index">起始位置。</param>
    /// <param name="count">要转换的字节数。</param>
    /// <returns>转换后的字符串。</returns>
    public static string ToDefaultString(this byte[] bytes, int index, int count)
    {
        return Encoding.Default.GetString(bytes, index, count);
    }

    /// <summary>
    /// 将字节数组转换为字符串，使用UTF-8编码。
    /// </summary>
    /// <param name="bytes">要转换的字节数组。</param>
    /// <returns>转换后的字符串。</returns>
    public static string ToUtf8String(this byte[] bytes)
    {
        return Encoding.UTF8.GetString(bytes);
    }

    /// <summary>
    /// 将字节数组的一部分转换为字符串，使用UTF-8编码。
    /// </summary>
    /// <param name="bytes">要转换的字节数组。</param>
    /// <param name="index">起始位置。</param>
    /// <param name="count">要转换的字节数。</param>
    /// <returns>转换后的字符串。</returns>
    public static string ToUtf8String(this byte[] bytes, int index, int count)
    {
        return Encoding.UTF8.GetString(bytes, index, count);
    }
}