การอ่านโครงสร้างข้อมูล C / C ++ ใน C # จากอาร์เรย์ไบต์

อะไรคือวิธีที่ดีที่สุดในการเติมโครงสร้าง C # จากอาร์เรย์ไบต์ [] ที่ข้อมูลมาจากโครงสร้าง C / C ++ โครงสร้าง C จะมีลักษณะดังนี้ (C ของฉันเป็นสนิมมาก):

typedef OldStuff {
    CHAR Name[8];
    UInt32 User;
    CHAR Location[8];
    UInt32 TimeStamp;
    UInt32 Sequence;
    CHAR Tracking[16];
    CHAR Filler[12];
}

และจะเติมเต็มสิ่งนี้:

[StructLayout(LayoutKind.Explicit, Size = 56, Pack = 1)]
public struct NewStuff
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
    [FieldOffset(0)]
    public string Name;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(8)]
    public uint User;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
    [FieldOffset(12)]
    public string Location;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(20)]
    public uint TimeStamp;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(24)]
    public uint Sequence;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    [FieldOffset(28)]
    public string Tracking;
}

อะไรคือวิธีที่ดีที่สุดที่จะคัดลอกOldStuffไปNewStuffถ้าOldStuffถูกส่งผ่านเป็น byte [] อาร์เรย์?

ตอนนี้ฉันกำลังทำสิ่งต่อไปนี้ แต่มันรู้สึกอึดอัด

GCHandle handle;
NewStuff MyStuff;

int BufferSize = Marshal.SizeOf(typeof(NewStuff));
byte[] buff = new byte[BufferSize];

Array.Copy(SomeByteArray, 0, buff, 0, BufferSize);

handle = GCHandle.Alloc(buff, GCHandleType.Pinned);

MyStuff = (NewStuff)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(NewStuff));

handle.Free();

มีวิธีที่ดีกว่าในการทำสิ่งนี้ให้สำเร็จหรือไม่?

การใช้BinaryReaderคลาสจะให้ประสิทธิภาพที่เพิ่มขึ้นจากการตรึงหน่วยความจำและใช้Marshal.PtrStructureหรือไม่

จากสิ่งที่ฉันเห็นในบริบทนั้นคุณไม่จำเป็นต้องคัดลอกSomeByteArrayลงในบัฟเฟอร์ คุณเพียงแค่ต้องรับที่จับจากSomeByteArrayปักหมุดคัดลอกIntPtrข้อมูลโดยใช้PtrToStructureแล้วปล่อย ไม่จำเป็นต้องมีสำเนา

นั่นจะเป็น:

NewStuff ByteArrayToNewStuff(byte[] bytes)
{
    GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
    try
    {
        NewStuff stuff = (NewStuff)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(NewStuff));
    }
    finally
    {
        handle.Free();
    }
    return stuff;
}

รุ่นทั่วไป:

T ByteArrayToStructure<T>(byte[] bytes) where T: struct 
{
    T stuff;
    GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
    try
    {
        stuff = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
    }
    finally
    {
        handle.Free();
    }
    return stuff;
}

รุ่นที่เรียบง่ายกว่า (ต้องใช้unsafeสวิตช์):

unsafe T ByteArrayToStructure<T>(byte[] bytes) where T : struct
{
    fixed (byte* ptr = &bytes[0])
    {
        return (T)Marshal.PtrToStructure((IntPtr)ptr, typeof(T));
    }
}

นี่คือคำตอบที่ยอมรับในเวอร์ชันปลอดภัยยกเว้น:

public static T ByteArrayToStructure<T>(byte[] bytes) where T : struct
{
    var handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
    try {
        return (T) Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
    }
    finally {
        handle.Free();
    }
}

ระวังปัญหาการบรรจุหีบห่อ ในตัวอย่างที่คุณให้ฟิลด์ทั้งหมดอยู่ในค่าออฟเซ็ตที่ชัดเจนเนื่องจากทุกอย่างอยู่ในขอบเขต 4 ไบต์ แต่จะไม่เป็นเช่นนั้นเสมอไป Visual C ++ บรรจุในขอบเขต 8 ไบต์โดยค่าเริ่มต้น

object ByteArrayToStructure(byte[] bytearray, object structureObj, int position)
{
    int length = Marshal.SizeOf(structureObj);
    IntPtr ptr = Marshal.AllocHGlobal(length);
    Marshal.Copy(bytearray, 0, ptr, length);
    structureObj = Marshal.PtrToStructure(Marshal.UnsafeAddrOfPinnedArrayElement(bytearray, position), structureObj.GetType());
    Marshal.FreeHGlobal(ptr);
    return structureObj;
}   

มีสิ่งนี้

หากคุณมีไบต์ [] คุณควรจะสามารถใช้คลาส BinaryReader และตั้งค่าบน NewStuff โดยใช้เมธอด ReadX ที่มี