Lesen einer C / C ++ - Datenstruktur in C # aus einem Byte-Array

Was wäre der beste Weg, um eine C # -Struktur aus einem Byte [] -Array zu füllen, in dem die Daten aus einer C / C ++ - Struktur stammen? Die C-Struktur würde ungefähr so ​​aussehen (mein C ist sehr rostig):

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

Und würde so etwas füllen:

[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;
}

Was ist am besten Weg kopieren OldStuffzu NewStuff, wenn OldStuffals byte [] Array übergeben wurde?

Ich mache gerade so etwas wie das Folgende, aber es fühlt sich irgendwie klobig an.

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();

Gibt es einen besseren Weg, dies zu erreichen?

Würde die Verwendung der BinaryReaderKlasse Leistungssteigerungen gegenüber dem Fixieren des Speichers und der Verwendung bieten Marshal.PtrStructure?

Nach allem, was ich in diesem Zusammenhang sehen kann, müssen Sie nicht SomeByteArrayin einen Puffer kopieren . Sie müssen lediglich den Griff SomeByteArrayabrufen, ihn anheften, die IntPtrDaten mit kopieren PtrToStructureund dann freigeben. Keine Kopie erforderlich.

Das wäre:

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;
}

Generische Version:

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;
}

Einfachere Version (erfordert unsafeSchalter):

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

Hier ist eine ausnahmesichere Version der akzeptierten Antwort :

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();
    }
}

Achten Sie auf Verpackungsprobleme. In dem Beispiel, das Sie angegeben haben, befinden sich alle Felder an den offensichtlichen Offsets, da sich alles an 4-Byte-Grenzen befindet. Dies ist jedoch nicht immer der Fall. Visual C ++ packt standardmäßig 8-Byte-Grenzen.

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;
}   

Nimm das

Wenn Sie ein Byte [] haben, sollten Sie in der Lage sein, die BinaryReader-Klasse zu verwenden und mit den verfügbaren ReadX-Methoden Werte für NewStuff festzulegen.