随笔- 130 文章- 0 评论- 14 阅读- 15万

C# BitConverte扩展方法，提供基于大端模式下的数值和字节数组的相互转换

数值转字节数组，以及字节数组转数值，需要注意的是C#的本地字节序是小端模式的，而网络字节序却是（大端模式），所以我用到了IPAddress来进行Host和Network的转换

为了简单以及更好的性能，做了一些取巧的处理方式，尽量避免数组拷贝和反转，看上去很诡异，经过简单测试貌似没啥问题，不敢保证百分百没问题啊，如果有问题，望指出啊，不建议直接拿来用啊

2022-11-03改进net6版

最近开了个net6项目，用到了一些新特性，特意改进了下这个扩展方法库

    /// <summary>
    /// 对BitConverter进行方法扩展
    /// </summary>
    public static class BitConverterExtend {

        #region 将数值的字节数组写入到span中
        public static bool TryWriteInt16(this short num, Span<byte> span, bool bigEndian = true) {
            if (bigEndian) {
                num = IPAddress.HostToNetworkOrder(num);
            }
            return BitConverter.TryWriteBytes(span, num);
        }
        public static bool TryWriteUInt16(this ushort num, Span<byte> span, bool bigEndian = true) {
            return ((short)num).TryWriteInt16(span, bigEndian); //这样比反转数组快
        }
        public static bool TryWriteInt32(this int num, Span<byte> span, bool bigEndian = true) {
            if (bigEndian) {
                num = IPAddress.HostToNetworkOrder(num);
            }
            return BitConverter.TryWriteBytes(span, num);
        }
        public static bool TryWriteUInt32(this uint num, Span<byte> span, bool bigEndian = true) {
            return ((int)num).TryWriteInt32(span, bigEndian);
        }
        public static bool TryWriteInt64(this long num, Span<byte> span, bool bigEndian = true) {
            if (bigEndian) {
                num = IPAddress.HostToNetworkOrder(num);
            }
            return BitConverter.TryWriteBytes(span, num);
        }
        public static bool TryWriteUInt64(this ulong num, Span<byte> span, bool bigEndian = true) {
            return ((long)num).TryWriteInt64(span, bigEndian);
        }
        public static bool TryWriteFloat(this float num, Span<byte> span, bool bigEndian = true) {
            bool b = BitConverter.TryWriteBytes(span, num);
            if (bigEndian) {
                span[..4].Reverse(); //只能手动反转，注意要先切片后才能反转，因为外部传入的span可能很长
            };
            return b;
        }
        public static bool TryWriteDouble(this double num, Span<byte> span, bool bigEndian = true) {
            bool b = BitConverter.TryWriteBytes(span, num);
            if (bigEndian) {
                span[..8].Reverse();
            };
            return b;
        }
        public static bool WriteString(this string value, Span<byte> span, bool bigEndian = true) {
            int length = Encoding.UTF8.GetBytes(value.AsSpan(), span[4..]); //先偏移4个字节写数据
            return length.TryWriteInt32(span, bigEndian); //再写前4个字节的长度
        }
        #endregion

        #region 将span转成具体的数据
        public static short ReadInt16(this byte[] buffer, int startIndex, bool bigEndian = true) {
            short num = BitConverter.ToInt16(buffer, startIndex);
            if (bigEndian) {
                num = IPAddress.NetworkToHostOrder(num);
            }
            return num;
        }
        public static ushort ReadUInt16(this byte[] buffer, int startIndex, bool bigEndian = true) {
            return (ushort)ReadInt16(buffer, startIndex, bigEndian); //因为ushort没有IPAddress.NetworkToHostOrder，所以直接调用ToInt16转换
        }
        public static int ReadInt32(this byte[] buffer, int startIndex, bool bigEndian = true) {
            int num = BitConverter.ToInt32(buffer, startIndex);
            if (bigEndian) {
                num = IPAddress.NetworkToHostOrder(num);
            }
            return num;
        }
        public static uint ReadUInt32(this byte[] buffer, int startIndex, bool bigEndian = true) {
            return (uint)ReadInt32(buffer, startIndex, bigEndian);
        }
        public static long ReadInt64(this byte[] buffer, int startIndex, bool bigEndian = true) {
            long num = BitConverter.ToInt64(buffer, startIndex);
            if (bigEndian) {
                num = IPAddress.NetworkToHostOrder(num);
            }
            return num;
        }
        public static ulong ReadUInt64(this byte[] buffer, int startIndex, bool bigEndian = true) {
            return (ulong)ReadInt64(buffer, startIndex, bigEndian);
        }
        public static float ReadFloat(this byte[] buffer, int startIndex, bool bigEndian = true) {
            float val;
            if (bigEndian) {
                Array.Reverse(buffer, startIndex, 4); //需要先反转顺序，因为本地转换函数是小端的
                val = BitConverter.ToSingle(buffer, startIndex);
                Array.Reverse(buffer, startIndex, 4); //用完，再反转回来，避免破坏数据
            } else {
                val = BitConverter.ToSingle(buffer, startIndex);
            }
            return val;
        }
        public static double ReadDouble(this byte[] buffer, int startIndex, bool bigEndian = true) {
            double val;
            if (bigEndian) {
                Array.Reverse(buffer, startIndex, 8);
                val = BitConverter.ToDouble(buffer, startIndex);
                Array.Reverse(buffer, startIndex, 8);
            } else {
                val = BitConverter.ToDouble(buffer, startIndex);
            }
            return val;
        }
        public static string ReadString(this byte[] buffer, int startIndex, bool bigEndian = true) {
            int length = buffer.ReadInt32(startIndex, bigEndian);
            return Encoding.UTF8.GetString(buffer, startIndex + 4, length);
        }
        #endregion
    }

测试代码

    internal class TestBitConverterExtend {
        public static void Test() {
            Console.WriteLine("大端模式#################");
            TestAAA(true);
            Console.WriteLine("小端模式#################");
            TestAAA(false);
        }
        public static void TestAAA(bool bigEndian) {
            short p1 = 123;
            ushort p2 = 456;
            int p3 = 789;
            uint p4 = 101112;
            long p5 = 131415;
            ulong p6 = 161718;
            float p7 = 3.14f;
            double p8 = 2.718281828459045;
            string p9 = "测试啊123";
            byte[] buffer = new byte[1024];
            int offset = 0;
            p1.TryWriteInt16(buffer.AsSpan(offset), bigEndian);
            offset += 2;
            p2.TryWriteUInt16(buffer.AsSpan(offset), bigEndian);
            offset += 2;
            p3.TryWriteInt32(buffer.AsSpan(offset), bigEndian);
            offset += 4;
            p4.TryWriteUInt32(buffer.AsSpan(offset), bigEndian);
            offset += 4;
            p5.TryWriteInt64(buffer.AsSpan(offset), bigEndian);
            offset += 8;
            p6.TryWriteUInt64(buffer.AsSpan(offset), bigEndian);
            offset += 8;
            p7.TryWriteFloat(buffer.AsSpan(offset), bigEndian);
            offset += 4;
            p8.TryWriteDouble(buffer.AsSpan(offset), bigEndian);
            offset += 8;
            p9.WriteString(buffer.AsSpan(offset), bigEndian);

            offset = 0;
            Compare(p1, buffer.ReadInt16(offset, bigEndian), (t1, t2) => t1 == t2);
            offset += 2;
            Compare(p2, buffer.ReadUInt16(offset, bigEndian), (t1, t2) => t1 == t2);
            offset += 2;
            Compare(p3, buffer.ReadInt32(offset, bigEndian), (t1, t2) => t1 == t2);
            offset += 4;
            Compare(p4, buffer.ReadUInt32(offset, bigEndian), (t1, t2) => t1 == t2);
            offset += 4;
            Compare(p5, buffer.ReadInt64(offset, bigEndian), (t1, t2) => t1 == t2);
            offset += 8;
            Compare(p6, buffer.ReadUInt64(offset, bigEndian), (t1, t2) => t1 == t2);
            offset += 8;
            Compare(p7, buffer.ReadFloat(offset, bigEndian), (t1, t2) => t1 == t2);
            offset += 4;
            Compare(p8, buffer.ReadDouble(offset, bigEndian), (t1, t2) => t1 == t2);
            offset += 8;
            Compare(p9, buffer.ReadString(offset, bigEndian), (t1, t2) => t1 == t2);
        }
        static void Compare<T>(T t1, T t2, Func<T, T, bool> func) {
            Console.WriteLine($"相等:{func(t1, t2)} 原参数:{t1} 写入后再读取的参数:{t2} ");
        }
    }

之前的net4.8版本

/// <summary>
/// 对BitConverter进行方法扩展
/// </summary>
public static class BitConverterExtend {
    /// <summary>
    /// 得到数值的网络字节序（大端模式）的字节数组
    /// </summary> 
    public static byte[] GetBytes_Network(this short num) {
        return BitConverter.GetBytes(IPAddress.HostToNetworkOrder(num));
    }
    public static byte[] GetBytes_Network(this ushort num) {
        return ((short)num).GetBytes_Network();  //这样比反转数组快
    }
    public static byte[] GetBytes_Network(this int num) {
        return BitConverter.GetBytes(IPAddress.HostToNetworkOrder(num));
    }
    public static byte[] GetBytes_Network(this uint num) {
        return ((int)num).GetBytes_Network();
    }
    public static byte[] GetBytes_Network(this long num) {
        return BitConverter.GetBytes(IPAddress.HostToNetworkOrder(num));
    }
    public static byte[] GetBytes_Network(this ulong num) {
        return ((long)num).GetBytes_Network();
    }
    public static byte[] GetBytes_Network(this float num) {
        return BitConverter.GetBytes(num).Reverse().ToArray();
    }
    public static byte[] GetBytes_Network(this double num) {
        return BitConverter.GetBytes(num).Reverse().ToArray();
    }
    public static byte[] GetBytes_UTF8(this string value) {
        return Encoding.UTF8.GetBytes(value);
    }
    /// <summary>
    /// 将网络字节序（大端模式）的字节数组转成本地字节序（小端模式）的数值
    /// </summary> 
    public static short ToInt16_ByNetworkBytes(this byte[] networkBytes, int startIndex) {
        return IPAddress.NetworkToHostOrder(BitConverter.ToInt16(networkBytes, startIndex));  //传入引用和起始索引，减少一个数组拷贝
    }
    public static ushort ToUInt16_ByNetworkBytes(this byte[] networkBytes, int startIndex) {
        return (ushort)((networkBytes[startIndex++] << 8) | networkBytes[startIndex]); //直接自己按位操作，这样最快
    }
    public static int ToInt32_ByNetworkBytes(this byte[] networkBytes, int startIndex) {
        return IPAddress.NetworkToHostOrder(BitConverter.ToInt32(networkBytes, startIndex));
    }
    public static uint ToUInt32_ByNetworkBytes(this byte[] networkBytes, int startIndex) {
        return (uint)((networkBytes[startIndex++] << 24) | (networkBytes[startIndex++] << 16)
            | (networkBytes[startIndex++] << 8) | networkBytes[startIndex]);
    }
    public static long ToInt64_ByNetworkBytes(this byte[] networkBytes, int startIndex) {
        return IPAddress.NetworkToHostOrder(BitConverter.ToInt64(networkBytes, startIndex));
    }
    public static ulong ToUInt64_ByNetworkBytes(this byte[] networkBytes, int startIndex) {
        return (ulong)((networkBytes[startIndex++] << 56) | (networkBytes[startIndex++] << 48)
            | (networkBytes[startIndex++] << 40) | (networkBytes[startIndex++] << 32)
            | (networkBytes[startIndex++] << 24) | (networkBytes[startIndex++] << 16)
            | (networkBytes[startIndex++] << 8) | networkBytes[startIndex]);
    }
    public static float ToFloat_ByNetworkBytes(this byte[] networkBytes, int startIndex) {
        return BitConverter.ToSingle(CopyAndReverse(networkBytes, startIndex, 4), 0);
    }
    /// <summary>
    /// 拷贝反转
    /// </summary> 
    static byte[] CopyAndReverse(byte[] networkBytes, int startIndex, int len) {
        byte[] bs = new byte[len];
        for (int i = 0; i < len; i++) {
            bs[len - 1 - i] = networkBytes[startIndex + i];  //反转拷贝
        }
        return bs;
    }
    public static double ToDouble_ByNetworkBytes(this byte[] networkBytes, int startIndex) {
        return BitConverter.ToDouble(CopyAndReverse(networkBytes, startIndex, 8), 0);
    }
    public static string GetString_UTF8(this byte[] value, int startIndex, int count) {
        return Encoding.UTF8.GetString(value, startIndex, count);
    }
}