将字节数组强制转换为托管结构

//我在以下位置找到了这个： http://code.cheesydesign.com/?p=572 (我还没有测试过，但是乍一看，它会很好地工作。

    /// <summary>
    /// Reads in a block from a file and converts it to the struct
    /// type specified by the template parameter
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="reader"></param>
    /// <returns></returns>
    private static T FromBinaryReader<T>(BinaryReader reader)
    {
        // Read in a byte array
        byte[] bytes = reader.ReadBytes(Marshal.SizeOf(typeof(T)));
        // Pin the managed memory while, copy it out the data, then unpin it
        GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
        T theStructure = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
        handle.Free();
        return theStructure;
    }

我会把字节数组变成内存流。然后在该流上实例化二进制读取器。然后定义采用二进制读取器并分析单个类的帮助程序函数。

内置的BinaryReader类总是使用小端序。

我会在这里使用类而不是结构。

class PacketHeader 
{
    uint16_t magic;
    uint16_t packet_size;
    uint32_t unknown1;
    uint32_t unknown2;
    uint32_t unknown3;
    uint32_t unknown4;
    uint16_t unknown5;
    uint16_t unknown6;
    uint32_t unknown7;
    uint32_t unknown8;
    string packet_type; // replaced with a real string
};
PacketHeader ReadPacketHeader(BinaryReader reader)
{
  var result=new PacketHeader();
  result.magic = reader.ReadInt16();
  ...
  result.packet_type=ReadCString();//Some helper function you might need to define yourself
  return result;
}

我是这样做的：

using System;
using System.Runtime.InteropServices;
public static object GetObjectFromBytes(byte[] buffer, Type objType)
{
    object obj = null;
    if ((buffer != null) && (buffer.Length > 0))
    {
        IntPtr ptrObj = IntPtr.Zero;
        try
        {
            int objSize = Marshal.SizeOf(objType);
            if (objSize > 0)
            {
                if (buffer.Length < objSize)
                    throw new Exception(String.Format("Buffer smaller than needed for creation of object of type {0}", objType));
                ptrObj = Marshal.AllocHGlobal(objSize);
                if (ptrObj != IntPtr.Zero)
                {
                    Marshal.Copy(buffer, 0, ptrObj, objSize);
                    obj = Marshal.PtrToStructure(ptrObj, objType);
                }
                else
                    throw new Exception(String.Format("Couldn't allocate memory to create object of type {0}", objType));
            }
        }
        finally
        {
            if (ptrObj != IntPtr.Zero)
                Marshal.FreeHGlobal(ptrObj);
        }
    }
    return obj;
}

在结构定义中，我没有使用任何fixed区域，而是在标准编组不起作用的情况下使用 MarshalAs 属性。这是字符串可能需要的。

您将像这样使用此函数：

PacketHeader ph = (PacketHeader)GetObjectFromBytes(buffer, typeof(PacketHeader));

编辑：我在代码示例中没有看到您的 BigEndian "限制"。此解决方案仅在字节为小端序时才有效。

编辑 2：在示例的字符串中，您将用以下内容装饰它：

[MarshalAs(UnmanagedType.LPStr)]

在数组中，我会对 n 大小的数组使用这样的东西：

[MarshalAs(UnmanagedType.ByValArray, SizeConst = n)]

对于那些可以访问 C# 7.3 功能的人，我使用这段不安全的代码将"序列化"为字节：

public static class Serializer
{
    public static unsafe byte[] Serialize<T>(T value) where T : unmanaged
    {
        byte[] buffer = new byte[sizeof(T)];
        fixed (byte* bufferPtr = buffer)
        {
            Buffer.MemoryCopy(&value, bufferPtr, sizeof(T), sizeof(T));
        }
        return buffer;
    }
    public static unsafe T Deserialize<T>(byte[] buffer) where T : unmanaged
    {
        T result = new T();
        fixed (byte* bufferPtr = buffer)
        {
            Buffer.MemoryCopy(bufferPtr, &result, sizeof(T), sizeof(T));
        }
        return result;
    }
}

unmanaged类型可以是结构(没有引用类型的简单结构，那些被认为是托管结构(或本机类型，如int、short等。

如果你想要没有复制的快速代码，这就是解决方案。我们在这里工作 原始byte[] ，只需在unsafe代码中投射指针，就像在本机 C/C++ 中一样。因此，没有开销调用昂贵的框架方法，制作副本等。

对非托管struct的任何更改都将反映在托管byte[]中，反之亦然。

//FOR DEBUG/TEST ONLY
using System.Runtime.InteropServices;
namespace ByteStructCast1
{
    class Program
    {
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        unsafe struct StructTest//4B
        {
            [MarshalAs(UnmanagedType.U2)]
            public ushort item1; //2B
            public fixed byte item2[2]; //2B =2x 1B
        }
        static void Main(string[] args)
        {
            //managed byte array
            byte[] DB1 = new byte[7]; //7B more than we need. byte buffer usually is greater.
            DB1[0] = 2;//test data |> LITTLE ENDIAN
            DB1[1] = 0;//test data |
            DB1[2] = 3;//test data
            DB1[3] = 4;//test data
            unsafe //we'll now pin unmanaged struct over managed byte array
            {
                fixed(byte* db1 = DB1) //db1 is pinned pointer to DB1 byte[] array
                {
                    //StructTest t1 = *(StructTest*)db1;    //does not change DB1/db1
                    //t1.item1 = 11;                        //does not change DB1/db1
                    db1[0] = 22;                            //does CHANGE DB1/db1
                    DB1[0] = 33;                            //does CHANGE DB1/db1
                    StructTest* ptest = (StructTest*)db1;   //does CHANGE DB1/db1
                    ptest->item1 = 44;                      //does CHANGE DB1/db1
                    ptest->item2[0]++;                      //does CHANGE DB1/db1
                    ptest->item2[1]--;                      //does CHANGE DB1/db1
                }
            }
        }
    }
}

当您使用基元类型的fixed大小的缓冲区时，也可以使用它，并且需要将其元素作为成员struct处理，例如 ulong到MyStruct，都是64位长。

好吧，你在这里有两个任务。首先是将 byte[] 本质上解释为结构，其次是处理可能的不同字节序。

所以，它们有些分歧。AFAIK 如果你想使用封送处理 - 它只会解释字节，就好像它是托管结构一样。因此，从一个字节序转换为另一个字节序留给您。这并不难做到，但不会是自动的。

因此，要将 byte[] 解释为结构，您必须具有类似的东西：

[StructLayout(LayoutKind.Sequential)]
internal struct X
{
    public int IntValue;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3, ArraySubType = UnmanagedType.U1)] 
    public byte[] Array;
}
static void Main(string[] args)
{
    byte[] data = {1, 0, 0, 0, 9, 8, 7}; // IntValue = 1, Array = {9,8,7}
    IntPtr ptPoit = Marshal.AllocHGlobal(data.Length);
    Marshal.Copy(data, 0, ptPoit, data.Length);
    var x = (X) Marshal.PtrToStructure(ptPoit, typeof (X));
    Marshal.FreeHGlobal(ptPoit);
    Console.WriteLine("x.IntValue = {0}", x.IntValue);
    Console.WriteLine("x.Array = ({0}, {1}, {2})", x.Array[0], x.Array[1], x.Array[2]);
}

所以前 4 个字节转到 IntValue (1,0,0,0( -> [小端序] -> 1接下来的 3 个字节直接进入数组。

如果你想要BigEndian，你应该自己做：

int LittleToBigEndian(int littleEndian)
{
    byte[] buf = BitConverter.GetBytes(littleEndian).Reverse().ToArray();
    return BitConverter.ToInt32(buf, 0);
}

这样有点混乱，所以对你来说，最好坚持使用自定义编写的解析器，它从源字节[]中逐个获取字节，并在没有StructLayout和其他本机互操作的情况下填充数据类。

要将字节数组转换为字符串，请执行此操作;

byte [] dBytes = ...
string str;
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
str = enc.GetString(dBytes);

并将字符串转换回字节数组

public static byte[] StrToByteArray(string str)
{
    System.Text.UTF8Encoding  encoding=new System.Text.UTF8Encoding();
    return encoding.GetBytes(str);
}

现在读取您的字符串并查看您的数据是什么。