C# 7.3中unmanaged泛型类型序列化的安全性与实现探讨

你的结论完全正确——直接序列化非托管类型T的原始字节只有在序列化和反序列化严格在同一硬件架构、同一.NET运行时环境下进行时才可靠，跨平台场景下风险极高。下面我展开解释原因，并给出安全的实现思路。

为什么直接序列化原始字节不安全？ #

你提到的两个顾虑完全命中了核心问题：

• 内存布局的不确定性：即使给泛型参数加上T : unmanaged约束，sizeof(T)仍需在unsafe上下文使用；更关键的是，默认情况下.NET结构体的布局是LayoutKind.Auto，运行时会根据平台优化内存对齐，这意味着同一结构体在x64、ARM等不同平台上的内存排布可能完全不同。就算手动指定LayoutKind.Sequential，如果结构体嵌套了其他未指定布局的类型，依然会存在布局不一致的风险。直接读取原始字节序列化，跨平台反序列化必然会出现数据错乱。
• 字节序差异：不同CPU架构的字节序（endianness）不同——x86/x64是小端序，而部分ARM、PowerPC架构是大端序。多字节数值类型（比如int、long、float）的原始字节在不同架构下存储顺序相反，直接序列化原始字节的话，跨架构反序列化得到的数值会完全错误。

如何实现安全的泛型非托管类型序列化？ #

核心思路是显式固定内存布局 + 统一字节序，可以选择自己实现逻辑，或者直接使用成熟的第三方库。

方案一：手动实现序列化逻辑 #

如果需要自定义实现，遵循以下步骤：

1. 强制固定内存布局：要求所有待序列化的非托管类型T必须标记[StructLayout(LayoutKind.Sequential, Pack = 1)]（Pack = 1确保跨平台内存对齐一致），且嵌套的所有子类型也必须满足这个要求。
2. 统一字节序处理：序列化时将所有多字节数值类型转换为统一的字节序（通常选择大端序，即网络字节序）；反序列化时再转换回当前平台的字节序。
3. 结合反射+unsafe读取字段：通过反射遍历类型的所有字段（包括嵌套字段），针对不同类型做字节序转换；或者在unsafe上下文固定结构体内存，逐个字段处理字节序后写入流。

下面是一个简化的示例代码，展示核心逻辑：

public static class SafeUnmanagedSerializer
{
    public static void Serialize<T>(T value, Stream stream) where T : unmanaged
    {
        // 校验类型是否有固定布局
        var layoutAttr = typeof(T).GetCustomAttribute<StructLayoutAttribute>();
        if (layoutAttr?.LayoutKind != LayoutKind.Sequential)
        {
            throw new InvalidOperationException("序列化类型必须标记为LayoutKind.Sequential");
        }

        unsafe
        {
            int size = sizeof(T);
            byte[] rawBytes = new byte[size];
            // 从内存拷贝原始字节
            Marshal.Copy((IntPtr)&value, rawBytes, 0, size);
            // 调整字节序为大端
            AdjustEndianness(rawBytes, typeof(T), isSerialization: true);
            // 写入流
            stream.Write(rawBytes, 0, size);
        }
    }

    public static T Deserialize<T>(Stream stream) where T : unmanaged
    {
        var layoutAttr = typeof(T).GetCustomAttribute<StructLayoutAttribute>();
        if (layoutAttr?.LayoutKind != LayoutKind.Sequential)
        {
            throw new InvalidOperationException("反序列化类型必须标记为LayoutKind.Sequential");
        }

        unsafe
        {
            int size = sizeof(T);
            byte[] rawBytes = new byte[size];
            stream.Read(rawBytes, 0, size);
            // 从大端调整为当前平台字节序
            AdjustEndianness(rawBytes, typeof(T), isSerialization: false);
            // 拷贝回结构体
            T result = default;
            Marshal.Copy(rawBytes, 0, (IntPtr)&result, size);
            return result;
        }
    }

    private static void AdjustEndianness(byte[] buffer, Type type, bool isSerialization)
    {
        // 处理基本数值类型的字节序
        if (type == typeof(int))
        {
            if ((BitConverter.IsLittleEndian && isSerialization) || (!BitConverter.IsLittleEndian && !isSerialization))
            {
                Array.Reverse(buffer);
            }
        }
        // 同理处理long、float、double等类型...
        
        // 处理嵌套结构体：遍历字段递归调整
        else if (type.IsValueType && type.IsDefined(typeof(StructLayoutAttribute), false))
        {
            int offset = 0;
            foreach (var field in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
            {
                var fieldType = field.FieldType;
                int fieldSize = Marshal.SizeOf(fieldType);
                byte[] fieldBytes = buffer.Skip(offset).Take(fieldSize).ToArray();
                AdjustEndianness(fieldBytes, fieldType, isSerialization);
                fieldBytes.CopyTo(buffer, offset);
                offset += fieldSize;
            }
        }
        // 处理非托管数组：遍历元素调整
        else if (type.IsArray && type.GetElementType()!.IsUnmanagedType)
        {
            int elementSize = Marshal.SizeOf(type.GetElementType()!);
            for (int i = 0; i < buffer.Length / elementSize; i++)
            {
                byte[] elementBytes = buffer.Skip(i * elementSize).Take(elementSize).ToArray();
                AdjustEndianness(elementBytes, type.GetElementType()!, isSerialization);
                elementBytes.CopyTo(buffer, i * elementSize);
            }
        }
    }
}

方案二：使用成熟第三方库 #

手动实现需要处理很多细节（比如嵌套类型、数组、不同数值类型的字节序转换），推荐直接使用现成的序列化库，这些库已经解决了跨平台兼容性问题：

• MessagePack-CSharp：专为高性能设计，原生支持非托管类型，默认处理字节序和内存布局，跨平台兼容性好。
• Protobuf-net：基于Protobuf协议，支持非托管类型的序列化，能保证跨平台数据一致性，生态成熟。

注意：避免使用BinaryFormatter，它已被.NET标记为过时，存在严重的安全漏洞，且跨平台兼容性差。

内容的提问来源于stack exchange，提问作者mbabramo