byte [] Array zu Struktur mit Array variabler Länge

Question

Ich erhalte ein Array von Bytes von einem Socket und die Struktur der Bytes ist einfach ein großes char-Array von Strings mit fester Breite. In einigen Fällen ist das letzte Feld dynamisch (statt fester Länge) und ich versuche, die Bytes zu einer Struktur zu Marshalen. Ich habe gelesen, dass das Char-Array variabler Länge IntPtr sein muss, aber ich habe nicht herausgefunden, wie man es mit den verbleibenden Bytes marshale. Ich habe auch in einigen Artikeln gelesen, dass ich vielleicht eine zweite Struktur brauche, aber immer noch nicht herausfinden kann, wie man es richtig marshallen kann.

Hier ist eine solche site

Was ist der richtige Weg ist mit variabler Länge char-Arrays in Strukturen zu tun?

Die Struktur:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] 
public struct Header 
{ 
    #region private member fields 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 
    private char[] _f1; 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 
    private char[] _f2; 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 
    private char[] _f3; 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 
    private char[] _f4; 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 
    private char[] _f5; 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 
    private char[] _f6; 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] 
    private char[] _f7; 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)] 
    private char[] _f8; 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] 
    private char[] _f9; 

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] 
    private char[] _f10; 

    // how would this get filled with a char[] array from the byte array? 
    public IntPtr VariableLengthData; 

    #endregion 
} 

Die Funktion:

public static Header FromArray(byte[] array) 
{ 
    IntPtr buff = IntPtr.Zero; 

    try 
    { 
     int objsize = Marshal.SizeOf(typeof(Header)); 
     buff = Marshal.AllocHGlobal(objsize); 
     Marshal.Copy(array, 0, buff, objsize); 
     var result = (Header)Marshal.PtrToStructure(buff, typeof(HostHeader)); 

     // the variable length data needs to be filled in somehow 
     // but also note that an extra 4 bytes was added to the size 
     // of the struct with the IntPtr 
     if(objsize < array.Length) 
     { 
      Marshal.Copy(array, array.Length - objsize, result.VariableLengthData, array.Length - objsize); 
     } 

     return result; 
    } 
    finally 
    { 
     if (buff != IntPtr.Zero) 
     { 
      Marshal.FreeHGlobal(buff); 
      buff = IntPtr.Zero; 
     } 
    } 
} 

Dies funktioniert - aber jetzt Marshal.SizeOf (headerObj) sagt, es ist kleiner, als es wirklich ist, wenn ich versuche, es zu konvertieren zurück zu ein byte [] Array. Abgesehen davon ist irgendetwas falsch mit dieser Lösung?

Answer 1

Versuchen Sie nicht zu sehr, dass Ihre C# -Deklarationen genau dem Paketformat entsprechen. Sie würden dies bevorzugen:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)] 
public class Header { 
    //.... 
} 

public class Packet { 
    public Header Header; 
    public byte[] VariableLengthData; 
} 

Jetzt wird es einfach. Sie können den Header in einem Schlage Marschall und kopieren Sie einfach, was zusätzliche Bytes vorhanden sind:

static unsafe Packet FromArray(byte[] data) { 
    var hdrsize = Marshal.SizeOf(typeof(Header)); 
    if (data.Length < hdrsize) throw new ArgumentException(); 
    Packet result = new Packet(); 
    // Marshal the header 
    fixed (byte* pdata = &data[0]) { 
     result.Header = (Header)Marshal.PtrToStructure(new IntPtr(pdata), typeof(Header)); 
    } 
    // Copy the rest 
    var varsize = data.Length - hdrsize; 
    result.VariableLengthData = new byte[varsize]; 
    Array.Copy(data, hdrsize, result.VariableLengthData, 0, varsize); 
    return result; 
} 

und die Paketklasse ändern, wie Sie sehen, passen, werden Sie wahrscheinlich eine Reihe von Eigenschaften, um mit dem char [hinzufügen möchten ].