如何在C＃中将结构转换为字节数组？

如何在C＃中将结构转换为字节数组？

我定义了这样的结构：

public struct CIFSPacket
{
    public uint protocolIdentifier; //The value must be "0xFF+'SMB'".
    public byte command;

    public byte errorClass;
    public byte reserved;
    public ushort error;

    public byte flags;

    //Here there are 14 bytes of data which is used differently among different dialects.
    //I do want the flags2. However, so I'll try parsing them.
    public ushort flags2;

    public ushort treeId;
    public ushort processId;
    public ushort userId;
    public ushort multiplexId;

    //Trans request
    public byte wordCount;//Count of parameter words defining the data portion of the packet.
    //From here it might be undefined...

    public int parametersStartIndex;

    public ushort byteCount; //Buffer length
    public int bufferStartIndex;

    public string Buffer;
}

在我的主要方法中，我为其创建一个实例并为其分配值：

CIFSPacket packet = new CIFSPacket();
packet.protocolIdentifier = 0xff;
packet.command = (byte)CommandTypes.SMB_COM_NEGOTIATE;
packet.errorClass = 0xff;
packet.error = 0;
packet.flags = 0x00;
packet.flags2 = 0x0001;
packet.multiplexId = 22;
packet.wordCount = 0;
packet.byteCount = 119;

packet.Buffer = "NT LM 0.12";

现在，我想通过套接字发送此数据包。为此，我需要将结构转换为字节数组。我该怎么做？

我的完整代码如下。

static void Main(string[] args)
{

  Socket MyPing = new Socket(AddressFamily.InterNetwork,
  SocketType.Stream , ProtocolType.Unspecified ) ;


  MyPing.Connect("172.24.18.240", 139);

    //Fake an IP Address so I can send with SendTo
    IPAddress IP = new IPAddress(new byte[] { 172,24,18,240 });
    IPEndPoint IPEP = new IPEndPoint(IP, 139);

    //Local IP for Receiving
    IPEndPoint Local = new IPEndPoint(IPAddress.Any, 0);
    EndPoint EP = (EndPoint)Local;

    CIFSPacket packet = new CIFSPacket();
    packet.protocolIdentifier = 0xff;
    packet.command = (byte)CommandTypes.SMB_COM_NEGOTIATE;
    packet.errorClass = 0xff;
    packet.error = 0;
    packet.flags = 0x00;
    packet.flags2 = 0x0001;
    packet.multiplexId = 22;
    packet.wordCount = 0;
    packet.byteCount = 119;

    packet.Buffer = "NT LM 0.12";

    MyPing.SendTo(It takes byte array as parameter);
}

代码片段是什么？

使用编组，这相当容易。

文件顶部

using System.Runtime.InteropServices

功能

byte[] getBytes(CIFSPacket str) {
    int size = Marshal.SizeOf(str);
    byte[] arr = new byte[size];

    IntPtr ptr = Marshal.AllocHGlobal(size);
    Marshal.StructureToPtr(str, ptr, true);
    Marshal.Copy(ptr, arr, 0, size);
    Marshal.FreeHGlobal(ptr);
    return arr;
}

并将其转换回：

CIFSPacket fromBytes(byte[] arr) {
    CIFSPacket str = new CIFSPacket();

    int size = Marshal.SizeOf(str);
    IntPtr ptr = Marshal.AllocHGlobal(size);

    Marshal.Copy(arr, 0, ptr, size);

    str = (CIFSPacket)Marshal.PtrToStructure(ptr, str.GetType());
    Marshal.FreeHGlobal(ptr);

    return str;
}

在您的结构中，您需要将其放在字符串之前

[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 100)]
public string Buffer;

并确保SizeConst与您最大的字符串一样大。

您可能应该阅读以下内容：http : //msdn.microsoft.com/zh-cn/library/4ca6d5z7.aspx

如果您真的希望它在Windows上是FAST，则可以在CopyMemory中使用不安全的代码来实现。CopyMemory大约快5倍（例如，通过编组复制800MB的数据需要3s，而通过CopyMemory复制仅需要0.6s）。此方法的确限制您仅使用实际存储在struct blob本身中的数据，例如数字或固定长度的字节数组。

    [DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
    private static unsafe extern void CopyMemory(void *dest, void *src, int count);

    private static unsafe byte[] Serialize(TestStruct[] index)
    {
        var buffer = new byte[Marshal.SizeOf(typeof(TestStruct)) * index.Length];
        fixed (void* d = &buffer[0])
        {
            fixed (void* s = &index[0])
            {
                CopyMemory(d, s, buffer.Length);
            }
        }

        return buffer;
    }

看一下这些方法：

byte [] StructureToByteArray(object obj)
{
    int len = Marshal.SizeOf(obj);

    byte [] arr = new byte[len];

    IntPtr ptr = Marshal.AllocHGlobal(len);

    Marshal.StructureToPtr(obj, ptr, true);

    Marshal.Copy(ptr, arr, 0, len);

    Marshal.FreeHGlobal(ptr);

    return arr;
}

void ByteArrayToStructure(byte [] bytearray, ref object obj)
{
    int len = Marshal.SizeOf(obj);

    IntPtr i = Marshal.AllocHGlobal(len);

    Marshal.Copy(bytearray,0, i,len);

    obj = Marshal.PtrToStructure(i, obj.GetType());

    Marshal.FreeHGlobal(i);
}

这是我在谷歌搜索时发现的另一个线程的无耻复制！

更新：有关更多详细信息，请检查源

Vicent代码的变体，但内存分配减少了一个：

public static byte[] GetBytes<T>(T str)
{
    int size = Marshal.SizeOf(str);

    byte[] arr = new byte[size];

    GCHandle h = default(GCHandle);

    try
    {
        h = GCHandle.Alloc(arr, GCHandleType.Pinned);

        Marshal.StructureToPtr<T>(str, h.AddrOfPinnedObject(), false);
    }
    finally
    {
        if (h.IsAllocated)
        {
            h.Free();
        }
    }

    return arr;
}

public static T FromBytes<T>(byte[] arr) where T : struct
{
    T str = default(T);

    GCHandle h = default(GCHandle);

    try
    {
        h = GCHandle.Alloc(arr, GCHandleType.Pinned);

        str = Marshal.PtrToStructure<T>(h.AddrOfPinnedObject());

    }
    finally
    {
        if (h.IsAllocated)
        {
            h.Free();
        }
    }

    return str;
}

我GCHandle用来“固定”内存，然后直接使用h.AddrOfPinnedObject()。

由于主要的答案是使用CIFSPacket类型，而C＃中没有（或不再）CIFSPacket类型，因此我编写了正确的方法：

    static byte[] getBytes(object str)
    {
        int size = Marshal.SizeOf(str);
        byte[] arr = new byte[size];
        IntPtr ptr = Marshal.AllocHGlobal(size);

        Marshal.StructureToPtr(str, ptr, true);
        Marshal.Copy(ptr, arr, 0, size);
        Marshal.FreeHGlobal(ptr);

        return arr;
    }

    static T fromBytes<T>(byte[] arr)
    {
        T str = default(T);

        int size = Marshal.SizeOf(str);
        IntPtr ptr = Marshal.AllocHGlobal(size);

        Marshal.Copy(arr, 0, ptr, size);

        str = (T)Marshal.PtrToStructure(ptr, str.GetType());
        Marshal.FreeHGlobal(ptr);

        return str;
    }

经过测试，它们可以工作。

我知道这真的很晚，但是使用C＃7.3，您可以对非托管结构或任何其他未管理的结构（int，bool等...）执行此操作：

public static unsafe byte[] ConvertToBytes<T>(T value) where T : unmanaged {
        byte* pointer = (byte*)&value;

        byte[] bytes = new byte[sizeof(T)];
        for (int i = 0; i < sizeof(T); i++) {
            bytes[i] = pointer[i];
        }

        return bytes;
    }

然后像这样使用：

struct MyStruct {
        public int Value1;
        public int Value2;
        //.. blah blah blah
    }

    byte[] bytes = ConvertToBytes(new MyStruct());

您可以使用Marshal（StructureToPtr，ptrToStructure）和Marshal.copy，但这取决于平台。

序列化包括自定义序列化的功能。

public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
Protected Sub New(ByVal info As SerializationInfo, ByVal context As StreamingContext) 

SerializationInfo包含用于序列化每个成员的函数。

BinaryWriter和BinaryReader还包含用于保存/加载到字节数组（流）的方法。

请注意，您可以从字节数组创建字节流，也可以从MemoryStream创建字节数组。

您可以在结构上创建保存方法和新建方法：

   Save(Bw as BinaryWriter)
   New (Br as BinaryReader)

然后，选择要保存/加载到流->字节数组的成员。

这可以非常直接地完成。

明确定义您的结构 [StructLayout(LayoutKind.Explicit)]

int size = list.GetLength(0);
IntPtr addr = Marshal.AllocHGlobal(size * sizeof(DataStruct));
DataStruct *ptrBuffer = (DataStruct*)addr;
foreach (DataStruct ds in list)
{
    *ptrBuffer = ds;
    ptrBuffer += 1;
}

只能在不安全的上下文中编写此代码。完成后，您必须释放自由addr。

Marshal.FreeHGlobal(addr);

我想出了一种不同的方法，该方法可以转换任何内容 struct而没有固定长度的麻烦，但是生成的字节数组将有更多的开销。

这是一个示例struct：

[StructLayout(LayoutKind.Sequential)]
public class HelloWorld
{
    public MyEnum enumvalue;
    public string reqtimestamp;
    public string resptimestamp;
    public string message;
    public byte[] rawresp;
}

如您所见，所有这些结构都需要添加固定长度属性。最终可能会占用超出所需空间的空间。请注意，这LayoutKind.Sequential是必需的，因为我们希望反射为时总是给我们相同的顺序FieldInfo。我的灵感来自于TLVType-Length-Value。让我们看一下代码：

public static byte[] StructToByteArray<T>(T obj)
{
    using (MemoryStream ms = new MemoryStream())
    {
        FieldInfo[] infos = typeof(T).GetFields(BindingFlags.Public | BindingFlags.Instance);
        foreach (FieldInfo info in infos)
        {
            BinaryFormatter bf = new BinaryFormatter();
            using (MemoryStream inms = new MemoryStream()) {

                bf.Serialize(inms, info.GetValue(obj));
                byte[] ba = inms.ToArray();
                // for length
                ms.Write(BitConverter.GetBytes(ba.Length), 0, sizeof(int));

                // for value
                ms.Write(ba, 0, ba.Length);
            }
        }

        return ms.ToArray();
    }
}

上面的函数只是使用BinaryFormatter来序列化未知大小的raw object，并且我也简单地跟踪大小并将其存储在输出中MemoryStream。

public static void ByteArrayToStruct<T>(byte[] data, out T output)
{
    output = (T) Activator.CreateInstance(typeof(T), null);
    using (MemoryStream ms = new MemoryStream(data))
    {
        byte[] ba = null;
        FieldInfo[] infos = typeof(T).GetFields(BindingFlags.Public | BindingFlags.Instance);
        foreach (FieldInfo info in infos)
        {
            // for length
            ba = new byte[sizeof(int)];
            ms.Read(ba, 0, sizeof(int));

            // for value
            int sz = BitConverter.ToInt32(ba, 0);
            ba = new byte[sz];
            ms.Read(ba, 0, sz);

            BinaryFormatter bf = new BinaryFormatter();
            using (MemoryStream inms = new MemoryStream(ba))
            {
                info.SetValue(output, bf.Deserialize(inms));
            }
        }
    }
}

当我们想将其转换回原始格式时，struct我们只需读回长度，然后直接将其转回至BinaryFormatter中，然后将其转回至中struct。

这两个函数是通用的，可以与任何函数一起使用struct，我已经在我的C#项目中测试了上面的代码，在该项目中，我有一个服务器和一个客户端，通过它们进行连接和通信，NamedPipeStream并将struct字节数组从一个字节数组转发到另一个字节并将其转换回。

我相信我的方法可能会更好，因为它不能固定长度，struct并且唯一的开销只是int结构中每个字段的开销。由生成的字节数组中也有一些很小的开销BinaryFormatter，但除此之外，开销并不大。

我将看一下BinaryReader和BinaryWriter类。最近，我不得不将数据序列化为一个字节数组（然后再返回），并且只有在我自己基本重写了这些类之后才找到它们。

http://msdn.microsoft.com/en-us/library/system.io.binarywriter.aspx

该页面上也有一个很好的例子。

看起来像某些外部库的预定义（C级）结构。元帅是你的朋友。检查：

http://geekswithblogs.net/taylorrich/archive/2006/08/21/88665.aspx

对于初学者来说，该如何处理。请注意，您可以-通过属性-定义字节布局和字符串处理之类的内容。实际上，这是一种非常好的方法。

为此，BinaryFormatter和MemoryStream均未完成。

@Abdel Olakara答案donese在.net 3.5中不起作用，应作如下修改：

    public static void ByteArrayToStructure<T>(byte[] bytearray, ref T obj)
    {
        int len = Marshal.SizeOf(obj);
        IntPtr i = Marshal.AllocHGlobal(len);
        Marshal.Copy(bytearray, 0, i, len);
        obj = (T)Marshal.PtrToStructure(i, typeof(T));
        Marshal.FreeHGlobal(i);
    }

        Header header = new Header();
        Byte[] headerBytes = new Byte[Marshal.SizeOf(header)];
        Marshal.Copy((IntPtr)(&header), headerBytes, 0, headerBytes.Length);

这应该很快就能解决问题，对吧？

此处的示例仅适用于纯Blittable类型，例如可以直接在C中记忆的类型。

示例-众所周知的64位结构

[StructLayout(LayoutKind.Sequential)]  
public struct Voxel
{
    public ushort m_id;
    public byte m_red, m_green, m_blue, m_alpha, m_matid, m_custom;
}

完全像这样定义，该结构将自动打包为64位。

现在我们可以创建体素的体积：

Voxel[,,] voxels = new Voxel[16,16,16];

并将它们全部保存到字节数组中：

int size = voxels.Length * 8; // Well known size: 64 bits
byte[] saved = new byte[size];
GCHandle h = GCHandle.Alloc(voxels, GCHandleType.Pinned);
Marshal.Copy(h.AddrOfPinnedObject(), saved, 0, size);
h.Free();
// now feel free to save 'saved' to a File / memory stream.

但是，由于OP想要知道如何转换结构本身，因此我们的Voxel结构可以具有以下方法ToBytes：

byte[] bytes = new byte[8]; // Well known size: 64 bits
GCHandle h = GCHandle.Alloc(this, GCHandleType.Pinned);
Marshal.Copy(hh.AddrOfPinnedObject(), bytes, 0, 8);
h.Free();