Marshal.SizeOf Struktur liefert übermäßige Anzahl

Question

I habe die folgende Struktur

[StructLayout(LayoutKind.Sequential)] 
public struct SFHeader 
{ 

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 5)] 
    public string FileName; 

    public int Offset; 

    public short Size; 

    public byte Flags; 

    public byte Source; 


    public long LastWriteTime; 


    public byte[] GetBytes() 
    { 
     int size = Marshal.SizeOf(this); 
     var buffer = new byte[size]; 
     IntPtr ptr = Marshal.AllocHGlobal(size); 

     Marshal.StructureToPtr(this, ptr, true); 
     Marshal.Copy(ptr, buffer, 0, size); 
     Marshal.FreeHGlobal(ptr); 

     return buffer; 
    } 


    public static SFHeader FromBytes(byte[] buffer) 
    { 
     var str = new SFHeader(); 
     int size = Marshal.SizeOf(str); 

     IntPtr ptr = Marshal.AllocHGlobal(size); 
     Marshal.Copy(buffer, 0, ptr, size); 
     str = (SFHeader)Marshal.PtrToStructure(ptr, str.GetType()); 
     Marshal.FreeHGlobal(ptr); 

     return str; 
    } 

} 

Muss der Struktur auf ein Array von Bytes konvertieren (als Paket mit Sockel senden), so verwende ich die GetBytes Methode, aber es gibt ein Array von Bytes 24 anstelle eines Arrays von 21 Bytes:

• Dateiname (string): 5 Byte
• Offset (int): 4 Byte
• Größe (kurz): 2 Byte
• Flags (Byte): 1 Byte
• Quelle (Byte): 1 Byte
• Lastwritetime (lang): 8 Byte

So: 5 + 4 + 2 + 1 + 1 + 8 = 21 Bytes.
Das passiert, weil Marshal.SizeOf 24 zurückgibt, warum? Und es scheint, dass die die Bytes im Überschuss nach dem Bytes der Zeichenfolge gespeichert werden und die folgenden Struktur in der Tat zum Beispiel:

[0] = 97 
[1] = 97 
[2] = 97 
[3] = 97 
[4] = 0 
[5] = 0 
[6] = 0 
[7] = 0 
[8] = 1 
[9] = 0 
[10] = 0 
[11] = 0 
[12] = 1 
[13] = 0 
... The following are all zero (0) 

Die fünfte:

var header = new SFHeader() 
{ 
    FileName = "aaaa", 
    Offset = 1, 
    Size = 1 
}; 

den folgenden Puffer umgewandelt wird, , sechste und siebte sind die Bytes im Übermaß. Wie kann ich dieses Problem lösen?

Answer 1

Sie stoßen auf ein Byte-Alignment-Problem. In einem Versuch, Felder auf Wortgrenzen für die Geschwindigkeit des Zugriffs zu halten, füllt der Compiler Ihre string mit 3 zusätzlichen Bytes. Um dies zu beheben, verwenden Sie das Feld Pack des StructLayoutAttribute.

[StructLayout(LayoutKind.Sequential, Pack=1)] // notice the packing here 
public struct SFHeader 
{ 
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 5)] 
    public string FileName; 

    public int Offset; 

    public short Size; 

    public byte Flags; 

    public byte Source; 

    public long LastWriteTime; 
} 

Answer 2

Sie könnten eine fixed size buffer anstelle einer Zeichenfolge verwenden.

[StructLayout(LayoutKind.Sequential)] 
public unsafe struct SFHeader 
{ 
    public fixed char FileName[5]; 
    public int Offset; 
    public short Size; 
    public byte Flags; 
    public byte Source; 
    public long LastWriteTime; 

    public byte[] GetBytes() 
    { 
     //omitted 
    } 

    public static SFHeader FromBytes(byte[] buffer) 
    { 
     //omitted 
    } 
}