StructLayoutAttribute.Pack StructLayoutAttribute.Pack StructLayoutAttribute.Pack StructLayoutAttribute.Pack Field

Definition

Steuert die Ausrichtung der Datenfelder einer Klasse oder Struktur im Speicher.Controls the alignment of data fields of a class or structure in memory.

public: int Pack;
public int Pack;
val mutable Pack : int
Public Pack As Integer 

Feldwert

Hinweise

Die Pack Feld steuert die Ausrichtung eines Typs Felder im Arbeitsspeicher.The Pack field controls the alignment of a type's fields in memory. Sie wirkt sich auf beide LayoutKind.Sequential und LayoutKind.Explicit.It affects both LayoutKind.Sequential and LayoutKind.Explicit. Standardmäßig ist der Wert 0 (null), der angibt, der Standardkomprimierungsgröße für die aktuelle Plattform.By default, the value is 0, indicating the default packing size for the current platform. Der Wert des Pack muss 0, 1, 2, 4, 8, 16, 32, 64 oder 128 sein:The value of Pack must be 0, 1, 2, 4, 8, 16, 32, 64, or 128:

Die Felder einer Typinstanz werden ausgerichtet, mithilfe der folgenden Regeln:The fields of a type instance are aligned by using the following rules:

  • Die Ausrichtung des Typs ist die Größe des größten Elements (1, 2, 4, 8, usw., Byte) oder die angegebenen Packen Größe, welcher Wert kleiner ist.The alignment of the type is the size of its largest element (1, 2, 4, 8, etc., bytes) or the specified packing size, whichever is smaller.

  • Jedes Feld muss mit Feldern vom seine eigene Größe ausgerichtet sind (1, 2, 4, 8, usw., Byte) oder die Ausrichtung des Typs, welcher Wert kleiner ist.Each field must align with fields of its own size (1, 2, 4, 8, etc., bytes) or the alignment of the type, whichever is smaller. Da die standardausrichtung des Typs, die Größe des größten Elements, die größer als oder gleich allen anderen Feldlängen ist ist, bedeutet dies normalerweise, dass die Felder nach ihrer Größe ausgerichtet sind.Because the default alignment of the type is the size of its largest element, which is greater than or equal to all other field lengths, this usually means that fields are aligned by their size. Z. B. auch wenn das größte Feld eines Typs eine 64-Bit-Ganzzahl (8 Byte) oder das Feld Pack ist auf 8 festgelegt ist Byte Felder an 1-Byte-Grenzen ausgerichtet Int16 Felder auf 2-Byte-Begrenzungen ausgerichtet und Int32 Felder auf 4-Byte-Grenzen ausgerichtet.For example, even if the largest field in a type is a 64-bit (8-byte) integer or the Pack field is set to 8, Byte fields align on 1-byte boundaries, Int16 fields align on 2-byte boundaries, and Int32 fields align on 4-byte boundaries.

  • Auffüllung wird zwischen den Feldern, um die ausrichtungsanforderungen erfüllen, hinzugefügt.Padding is added between fields to satisfy the alignment requirements.

Betrachten Sie beispielsweise die folgende Struktur besteht aus zwei Byte -Felder und ein Int32 Feld bei einer Verwendung mit verschiedenen Werten für die Pack Feld.For example, consider the following structure, which consists of two Byte fields and one Int32 field, when it is used with various values for the Pack field.

using System;

struct ExampleStruct
{
   public byte b1;
   public byte b2;
   public int i3;
}

Wichtig

Um die C#-Beispiele erfolgreich zu kompilieren, geben Sie die /unsafe Compilerschalter.To successfully compile the C# examples, you must specify the /unsafe compiler switch.

Wenn Sie die Standardkomprimierungsgröße angeben, wird die Größe der Struktur 8 Bytes.If you specify the default packing size, the size of the structure is 8 bytes. Die zwei Bytes belegen die ersten zwei Bytes an Arbeitsspeicher, da Bytes an ein-Byte-Begrenzungen ausgerichtet werden müssen.The two bytes occupy the first two bytes of memory, because bytes must align on one-byte boundaries. Da die standardausrichtung des Typs 4 Bytes, also die Größe des größten Felder ist, i3, es gibt zwei Byte-Auffüllung, gefolgt von dem Ganzzahlfeld.Because the default alignment of the type is 4 bytes, which is the size of its largest fields, i3, there are two bytes of padding followed by the integer field.

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack=0)]
struct ExampleStruct
{
   public byte b1;
   public byte b2;
   public int i3;
}

public class Example
{
   public unsafe static void Main()
   {

      ExampleStruct ex = new ExampleStruct();
      byte* addr = (byte*) &ex;
      Console.WriteLine("Size:      {0}", sizeof(ExampleStruct));
      Console.WriteLine("b1 Offset: {0}", &ex.b1 - addr);
      Console.WriteLine("b2 Offset: {0}", &ex.b2 - addr);
      Console.WriteLine("i3 Offset: {0}", (byte*) &ex.i3 - addr);
   }
}
// The example displays the following output:
//       Size:      8
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 4

Wenn Pack festgelegt ist, 2, beträgt die Größe der Struktur 6 Bytes.If Pack is set to 2, the size of the structure is 6 bytes. Belegen, die zwei Bytes die ersten zwei Bytes an Arbeitsspeicher.As before, the two bytes occupy the first two bytes of memory. Da Felder jetzt an 2-Byte-Grenzen ausgerichtet sind, wird keine Auffüllung zwischen dem zweiten Byte und die ganze Zahl.Because fields now align on 2-byte boundaries, there is no padding between the second byte and the integer.

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack=2)]
struct ExampleStruct
{
   public byte b1;
   public byte b2;
   public int i3;
}

public class Example
{
   public unsafe static void Main()
   {

      ExampleStruct ex = new ExampleStruct();
      byte* addr = (byte*) &ex;
      Console.WriteLine("Size:      {0}", sizeof(ExampleStruct));
      Console.WriteLine("b1 Offset: {0}", &ex.b1 - addr);
      Console.WriteLine("b2 Offset: {0}", &ex.b2 - addr);
      Console.WriteLine("i3 Offset: {0}", (byte*) &ex.i3 - addr);
   }
}
// The example displays the following output:
//       Size:      6
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 2

Wenn Pack festgelegt ist, 4, die Größe der Struktur ist der gleiche wie in der Standardfall, in den Typ der Ausrichtung von der Größe der dem größten Feld definiert wurde, i3, dies ist 4.If Pack is set to 4, the size of the structure is the same as in the default case, where the type's alignment was defined by the size of its largest field, i3, which is 4.

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack=4)]
struct ExampleStruct
{
   public byte b1;
   public byte b2;
   public int i3;
}

public class Example
{
   public unsafe static void Main()
   {

      ExampleStruct ex = new ExampleStruct();
      byte* addr = (byte*) &ex;
      Console.WriteLine("Size:      {0}", sizeof(ExampleStruct));
      Console.WriteLine("b1 Offset: {0}", &ex.b1 - addr);
      Console.WriteLine("b2 Offset: {0}", &ex.b2 - addr);
      Console.WriteLine("i3 Offset: {0}", (byte*) &ex.i3 - addr);
   }
}
// The example displays the following output:
//       Size:      8
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 4

Wenn Pack festgelegt ist auf 8 fest, die Größe der Struktur ist immer noch in der Standardeinstellung identisch Fall, da die i3 Feld ausgerichtet, auf eine 4-Byte-Grenze, die kleiner als die 8-Byte-Grenze, die das Feld "Pack" angegeben ist.If Pack is set to 8, the size of the structure is the still same as in the default case, because the i3 field aligns on a 4-byte boundary, which is smaller than the 8-byte boundary specified by the Pack field.

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack=8)]
struct ExampleStruct
{
   public byte b1;
   public byte b2;
   public int i3;
}

public class Example
{
   public unsafe static void Main()
   {

      ExampleStruct ex = new ExampleStruct();
      byte* addr = (byte*) &ex;
      Console.WriteLine("Size:      {0}", sizeof(ExampleStruct));
      Console.WriteLine("b1 Offset: {0}", &ex.b1 - addr);
      Console.WriteLine("b2 Offset: {0}", &ex.b2 - addr);
      Console.WriteLine("i3 Offset: {0}", (byte*) &ex.i3 - addr);
   }
}
// The example displays the following output:
//       Size:      8
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 4

Um ein weiteres Beispiel nutzen zu können, sollten Sie in der folgenden Struktur besteht aus zwei Byte-Feldern, eine 32-Bit-Ganzzahl mit Vorzeichen-Feld, einen einzelnen Elementen bestehendes Bytearray und ein decimal-Wert.To take another example, consider the following structure, which consists of two byte fields, one 32-bit signed integer field, one single-element byte array, and a decimal value. Mit die Standardkomprimierungsgröße ist die Größe der Struktur 28 Bytes.With the default packing size, the size of the structure is 28 bytes. Die zwei Bytes belegen die ersten zwei Bytes an Arbeitsspeicher, gefolgt von zwei Byte-Auffüllung, gefolgt von der ganzen Zahl.The two bytes occupy the first two bytes of memory, followed by two bytes of padding, followed by the integer. Als Nächstes wird das 1-Byte-Array, gefolgt von drei Bytes Abstand.Next is the one-byte array, followed by three bytes of padding. Zum Schluss die Decimal d5, Feld, die von der 4-Byte-Begrenzung ausgerichtet werden, da ein decimal-Wert von vier besteht aus Int32 Felder, damit die Ausrichtung auf der Größe des größten basierend ihrer Felder und nicht auf die Größe des der Decimal Struktur als Ganzes.Finally, the Decimal field, d5, aligns on a 4-byte boundary because a decimal value consists of four Int32 fields, so its alignment is based on the size of the largest of its fields rather than on the size of the Decimal structure as a whole.

using System;
using System.Runtime.InteropServices;

unsafe struct ExampleStruct2
{

   public byte b1;
   public byte b2;
   public int i3;
   public fixed byte a4[1];
   public decimal d5;
}

public class Example
{
   public unsafe static void Main()
   {

      ExampleStruct2 ex = new ExampleStruct2();
      byte* addr = (byte*) &ex;
      Console.WriteLine("Size:      {0}", sizeof(ExampleStruct2));
      Console.WriteLine("b1 Offset: {0}", &ex.b1 - addr);
      Console.WriteLine("b2 Offset: {0}", &ex.b2 - addr);
      Console.WriteLine("i3 Offset: {0}", (byte*) &ex.i3 - addr);
      Console.WriteLine("a4 Offset: {0}", ex.a4 - addr);
      Console.WriteLine("d5 Offset: {0}", (byte*) &ex.d5 - addr);
   }
}
// The example displays the following output:
//       Size:      28
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 4
//       a4 Offset: 8
//       d5 Offset: 12

Wenn Pack festgelegt ist, 2, ist die Größe der Struktur 24 Bytes.If Pack is set to 2, the size of the structure is 24 bytes. Im Vergleich mit die standardausrichtung wurden die beiden Bytes der Auffüllung zwischen den beiden Bytes und die ganze Zahl entfernt, da des Typs Ausrichtung jetzt 4 statt 2 ist.In comparison with the default alignment, the two bytes of padding between the two bytes and the integer have been removed because the type's alignment is now 4 rather than 2. Und die drei Bytes Abstand nach dem a4 ersetzt wurden um ein Byte der Auffüllung, da d5 jetzt auf einen 2-Byte-Begrenzung statt 4-Byte-Begrenzung ausgerichtet.And the three bytes of padding after a4 have been replaced by one byte of padding, since d5 now aligns on a 2-byte boundary rather than a 4-byte boundary.

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 2)]
unsafe struct ExampleStruct2
{

   public byte b1;
   public byte b2;
   public int i3;
   public fixed byte a4[1];
   public decimal d5;
}

public class Example
{
   public unsafe static void Main()
   {

      ExampleStruct2 ex = new ExampleStruct2();
      byte* addr = (byte*) &ex;
      Console.WriteLine("Size:      {0}", sizeof(ExampleStruct2));
      Console.WriteLine("b1 Offset: {0}", &ex.b1 - addr);
      Console.WriteLine("b2 Offset: {0}", &ex.b2 - addr);
      Console.WriteLine("i3 Offset: {0}", (byte*) &ex.i3 - addr);
      Console.WriteLine("a4 Offset: {0}", ex.a4 - addr);
      Console.WriteLine("d5 Offset: {0}", (byte*) &ex.d5 - addr);
   }
}
// The example displays the following output:
//       Size:      24
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 2
//       a4 Offset: 6
//       d5 Offset: 8

Wenn Pack festgelegt ist auf 8 fest, die Größe der Struktur ist der gleiche wie in der Standardfall, da alle ausrichtungsanforderungen in dieser Struktur kleiner als 8 sind.If Pack is set to 8, the size of the structure is the same as in the default case, because all the alignment requirements in this structure are less than 8.

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 8)]
unsafe struct ExampleStruct2
{

   public byte b1;
   public byte b2;
   public int i3;
   public fixed byte a4[1];
   public decimal d5;
}

public class Example
{
   public unsafe static void Main()
   {

      ExampleStruct2 ex = new ExampleStruct2();
      byte* addr = (byte*) &ex;
      Console.WriteLine("Size:      {0}", sizeof(ExampleStruct2));
      Console.WriteLine("b1 Offset: {0}", &ex.b1 - addr);
      Console.WriteLine("b2 Offset: {0}", &ex.b2 - addr);
      Console.WriteLine("i3 Offset: {0}", (byte*) &ex.i3 - addr);
      Console.WriteLine("a4 Offset: {0}", ex.a4 - addr);
      Console.WriteLine("d5 Offset: {0}", (byte*) &ex.d5 - addr);
   }
}
// The example displays the following output:
//       Size:      28
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 4
//       a4 Offset: 8
//       d5 Offset: 12

Die Pack Feld wird häufig verwendet, wenn Schreibvorgänge im Netzwerk und Strukturen, die während der Datenträger exportiert werden.The Pack field is frequently used when structures are exported during disk and network write operations. Das Feld wird auch häufig verwendet, während der Plattformaufrufe aufrufen und Interop-Operationen.The field is also frequently used during platform invoke and interop operations.

In einigen Fällen wird das Feld verwendet, um arbeitsspeicheranforderungen zu reduzieren, indem Sie eine strengere Komprimierungsgröße erzeugen.Occasionally, the field is used to reduce memory requirements by producing a tighter packing size. Diese Verwendung erfordert allerdings sorgfältigen Einhaltung der tatsächlichen Hardware-Einschränkungen, und möglicherweise sogar verringert die Leistung.However, this usage requires careful consideration of actual hardware constraints, and may actually degrade performance.

Gilt für: