如何通过一个操作将字节数组转换为联合结构？

Question

我在C＃中类似工会在C++中声明：

[StructLayout(LayoutKind.Explicit, Size = 5)] 
public struct Marker 
{ 
     [FieldOffset(0)] public byte label; 
     [FieldOffset(1)] public int count; 

     [FieldOffset(1)] private byte count_0; 
     [FieldOffset(2)] private byte count_1; 
     [FieldOffset(3)] private byte count_2; 
     [FieldOffset(4)] private byte count_3; 
} 

我也有byte[] bytes大小为5，我需要我的数组来标记对象转换。

var marker = new Marker 
{ 
    label = bytes[0], 
    count = BitConverter.ToInt32(bytes, 1) 
} 

或者：我可以通过下面的方式做到这一点

var marker = new Marker 
{ 
    label = bytes[0], 
    count_0 = bytes[1], 
    count_1 = bytes[2], 
    count_2 = bytes[3], 
    count_3 = bytes[4] 
} 

这是确定的，但我认为这是可以通过更优化的方式从性能视图做的事情 - 只是点到的第一个字节bytes。我试图找到这样的事情：

BitConverter.To<Marker>(bytes); 

如何通过一个操作字节数组转换为工会结构？

Answer 1

这应该工作

static void Main(string[] args) 
    { 
     //Creating test data 
     List<byte> data = new List<byte>(); 
     data.Add(123); 
     data.AddRange(BitConverter.GetBytes((int)123456)); 

     //Converting test data to Struct 
     Marker m = StructFromBytes<Marker>(data.ToArray()); 

     //Check if it works 
     Console.WriteLine(m.label); //Prints 123 
     Console.WriteLine(m.count); //Prints 123456 
    } 

    private static T StructFromBytes<T>(byte[] bytes) 
    { 
     int structSize = Marshal.SizeOf(typeof(T)); 
     byte[] structBytes = new byte[structSize]; 
     Array.Copy(bytes, 0, structBytes, 0, structSize); 

     GCHandle handle = GCHandle.Alloc(structBytes, GCHandleType.Pinned); 
     T theStructure = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T)); 
     handle.Free(); 

     return theStructure; 
    } 

Answer 2

您可以创建一个构造函数：

[StructLayout(LayoutKind.Explicit, Size = 5)] 
public struct Marker 
{ 
    [FieldOffset(0)] public byte label; 
    [FieldOffset(1)] public int count; 

    [FieldOffset(1)] private byte count_0; 
    [FieldOffset(2)] private byte count_1; 
    [FieldOffset(3)] private byte count_2; 
    [FieldOffset(4)] private byte count_3; 

    public Marker(byte[] bytes) 
    { 
     label = bytes[0]; 
     count_0 = bytes[1]; 
     count_1 = bytes[2]; 
     count_2 = bytes[3]; 
     count_3 = bytes[4]; 
    } 
} 

或运算符重载：

[StructLayout(LayoutKind.Explicit, Size = 5)] 
public struct Marker 
{ 
    [FieldOffset(0)] public byte label; 
    [FieldOffset(1)] public int count; 

    [FieldOffset(1)] private byte count_0; 
    [FieldOffset(2)] private byte count_1; 
    [FieldOffset(3)] private byte count_2; 
    [FieldOffset(4)] private byte count_3; 

    public static explicit operator Marker(byte[] bytes) 
    { 
     Marker result = new Marker(); 
     result.label = bytes[0]; 
     result.count_0 = bytes[1]; 
     result.count_1 = bytes[2]; 
     result.count_2 = bytes[3]; 
     result.count_3 = bytes[4]; 
     return result; 
    } 
} 

这两种解决方案将使创建结构一个班轮：

Marker marker = new Marker(bytes); 
Marker marker = (Marker)bytes;