StructLayoutAttribute.Pack 字段

定义

控制类或结构的数据字段在内存中的对齐方式。

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

字段值

注解

字段 Pack 控制内存中类型字段的对齐方式。 它会影响 LayoutKind.Sequential 属性。 值指示当前平台的默认打包大小。 的值 Pack 必须为 0、1、2、4、8、16、32、64 或 128。 默认值为 0。

使用以下规则对齐类型实例的字段:

  • 类型的对齐方式是其最大元素 (的大小,例如,1、2、4 或 8 个字节) 或指定的包装大小(以较小者为准)。
  • 每个字段必须与其自身大小的字段或类型的对齐方式对齐,以较小者为准。 由于类型的默认对齐方式是其最大元素的大小(大于或等于所有其他字段长度),这通常意味着字段按其大小对齐。 例如,即使类型中最大的字段是 64 位 (8 字节) 整数,或者 Pack 字段设置为 8, Byte 字段在 1 字节边界上对齐, Int16 字段在 2 字节边界上对齐, Int32 字段在 4 字节边界上对齐。
  • 在字段之间添加填充以满足对齐要求。

例如,考虑以下结构,当它与字段的各种值Pack一起使用时,它由两Byte个字段和一个Int32字段组成。

using System;

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

重要

若要成功编译 C# 示例,必须指定 /unsafe 编译器开关。

如果指定默认打包大小,则结构的大小为 8 个字节。 这两个字节占用前两个字节的内存,因为字节必须在单字节边界上对齐。 由于类型的默认对齐方式为 4 个字节,即其最大字段 的大小, i3因此有两个字节的填充后跟整数字段。

using System;
using System.Runtime.InteropServices;

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

public class Example1
{
    public unsafe static void Main()
    {
        ExampleStruct1 ex = new();
        byte* addr = (byte*)&ex;
        Console.WriteLine("Size:      {0}", sizeof(ExampleStruct1));
        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

如果 Pack 设置为 2,则结构的大小为 6 个字节。 与之前一样,这两个字节占用前两个字节的内存。 由于字段现在在 2 字节边界上对齐,因此第二个字节和整数之间没有填充。

using System;
using System.Runtime.InteropServices;

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

public class Example2
{
    public unsafe static void Main()
    {
        ExampleStruct2 ex = new();
        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);
    }
}
// The example displays the following output:
//       Size:      6
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 2

如果 Pack 设置为 4,则结构的大小与在默认情况下相同,其中类型的对齐方式由其最大字段 i3(即 4)的大小定义。

using System;
using System.Runtime.InteropServices;

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

public class Example3
{
    public unsafe static void Main()
    {
        ExampleStruct3 ex = new();
        byte* addr = (byte*)&ex;
        Console.WriteLine("Size:      {0}", sizeof(ExampleStruct3));
        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

如果 Pack 设置为 8,则结构的大小仍与默认情况相同,因为 i3 字段在 4 字节边界上对齐,该边界小于 Pack 字段指定的 8 字节边界。

using System;
using System.Runtime.InteropServices;

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

public class Example4
{
    public unsafe static void Main()
    {
        ExampleStruct4 ex = new();
        byte* addr = (byte*)&ex;
        Console.WriteLine("Size:      {0}", sizeof(ExampleStruct4));
        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

以另一个示例为例,请考虑以下结构,该结构由两个字节字段、一个 32 位带符号整数字段、一个单元素字节数组和一个十进制值组成。 使用默认打包大小时,结构的大小在 .NET Framework 中为 28 字节,在 .NET 5+ 中为 32 字节。 这两个字节占用前两个字节的内存,后跟两个字节的填充,后跟整数。 接下来是单字节数组,后跟三个字节的填充。 由于十进制值由多个字段组成,因此对齐方式基于其最大字段,而不是整个结构的大小 Decimal 。 在 .NET 5 及更高版本中, Decimal 结构由两个 Int32 字段和一个 8 字节字段组成,因此字段 Decimal d5 在 8 字节边界上对齐。 在 .NET Framework 中 Decimal , 结构由四 Int32 个字段组成,因此 Decimal 字段 d5 在 4 字节边界上对齐。

using System;

unsafe struct ExampleStruct5
{

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

public class Example5
{
    public unsafe static void Main()
    {
        ExampleStruct5 ex = new();
        byte* addr = (byte*)&ex;
        Console.WriteLine("Size:      {0}", sizeof(ExampleStruct5));
        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:
//
// .NET 5+:
//       Size:      32
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 4
//       a4 Offset: 8
//       d5 Offset: 16
//
// .NET Framework:
//       Size:      28
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 4
//       a4 Offset: 8
//       d5 Offset: 12

如果 Pack 设置为 2,则结构的大小为 24 字节。 与默认对齐方式相比,删除了两个字节和整数之间的两个字节填充,因为该类型的对齐方式现在为 4 而不是 2。 之后 a4 的三个字节的填充已替换为一个字节的填充,因为 d5 现在在 2 字节边界而不是 4 字节边界上对齐。

using System;
using System.Runtime.InteropServices;

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

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

public class Example6
{
    public unsafe static void Main()
    {
        ExampleStruct6 ex = new();
        byte* addr = (byte*)&ex;
        Console.WriteLine("Size:      {0}", sizeof(ExampleStruct6));
        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

如果 Pack 设置为 16,则结构的大小与默认情况相同,因为此结构中的所有对齐要求都小于 16。

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 16)]
unsafe struct ExampleStruct7
{

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

public class Example7
{
    public unsafe static void Main()
    {
        ExampleStruct7 ex = new();
        byte* addr = (byte*)&ex;
        Console.WriteLine("Size:      {0}", sizeof(ExampleStruct7));
        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:
//
// .NET 5+:
//       Size:      32
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 4
//       a4 Offset: 8
//       d5 Offset: 16
//
// .NET Framework:
//       Size:      28
//       b1 Offset: 0
//       b2 Offset: 1
//       i3 Offset: 4
//       a4 Offset: 8
//       d5 Offset: 12

Pack 磁盘和网络写入操作期间导出结构时,经常使用 字段。 在平台调用和互操作操作期间,也经常使用 字段。

有时, 字段用于通过生成更严格的打包大小来降低内存需求。 但是,这种用法需要仔细考虑实际的硬件约束,实际上可能会降低性能。

适用于