Wie konvertiert man ein C/C-Byte-Array effizient in eine C#-Struktur?

C/C-Datenstruktur vom Byte-Array nach C# lesen

Frage

Diese Aufgabe beinhaltet die Konvertierung eines Byte-Arrays, das Daten aus einer C/C-Struktur enthält, in die entsprechende C#-Struktur. Die C/C-Struktur sieht so aus:

<code class="language-c++">typedef struct OldStuff {
    CHAR Name[8];
    UInt32 User;
    CHAR Location[8];
    UInt32 TimeStamp;
    UInt32 Sequence;
    CHAR Tracking[16];
    CHAR Filler[12];
} OldStuff;</code>

Die C#-Struktur mit dem Namen NewStuff ist wie folgt definiert:

<code class="language-csharp">[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;
}</code>

Lösungsvorschlag

Anfangs wurde über einen umständlicheren Ansatz nachgedacht, der einen angehefteten Speicher und die Verwendung von Marshal.PtrToStructure beinhaltete:

<code class="language-csharp">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();</code>

Verbesserungen

Nach weiterer Analyse wurde festgestellt, dass die Pufferkopie in der ursprünglichen Methode unnötig war. Stattdessen genügt das direkte Anheften des Griffs:

<code class="language-csharp">GCHandle handle;
NewStuff MyStuff;

handle = GCHandle.Alloc(SomeByteArray, GCHandleType.Pinned);
try
{
    MyStuff = (NewStuff)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(NewStuff));
}
finally
{
    handle.Free();
}</code>

Außerdem kann eine noch einfachere Version mit Generika verwendet werden (erfordert unsicheres Umschalten):

• Generisch:

<code class="language-csharp">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;
}</code>

• Einfacher (unsicher):

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

Verwenden Sie BinaryReader, um die Leistung zu verbessern

Während die bevorzugte Lösung Fixierung und Marshal.PtrToStructure umfasst, kann das Parsen von Daten mithilfe der Klasse BinaryReader in bestimmten Fällen zu Leistungsvorteilen führen. Allerdings müssen spezifische Implementierungen evaluiert werden, um festzustellen, ob solche Gewinne signifikant sind.

Das obige ist der detaillierte Inhalt vonWie konvertiert man ein C/C-Byte-Array effizient in eine C#-Struktur?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!