登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›理解 .NET 结构体字段的内存布局

理解 .NET 结构体字段的内存布局

龙骋唧 2025-6-5 18:02:31
目录

  • 前言
  • 基本概念
  • 结构体的默认字段布局

    • 对齐
    • 64 位系统与 32 位系统的对齐要求差异
    • 默认字段布局中 对齐要求 与 偏移量 的关系
    • 填充

  • 包含引用类型字段的结构体的默认字段布局
  • 用 StructLayoutAttribute 控制字段布局

    • LayoutKind.Sequential

      • Pack 为 0 时等于默认布局
      • Pack 不为 0 时，取 Pack 和 字段类型大小 的较小值
      • Pack 设置为 1 时，会形成密集的字段布局
      • Pack 不为 0 的结构体作为其他结构体字段时

    • LayoutKind.Explicit

      • Pack 为 0 时，结构体按照最大字段默认对齐要求对齐
      • Pack 不为 0 时，结构体实例按照 Pack 与 最大字段对齐要求 的较小值对齐
      • 将 Pack 属性设置为 1 可以消除结构体实例的末尾填充
      • Pack 属性不为 0 的结构体作为其他结构体字段时

    • LayoutKind.Auto

  • 作为数组元素时的结构体实例

    • 默认字段布局
    • 非默认字段布局


前言

大部分情况下我们并不需要关心结构体字段的内存布局，但是在一些特殊情况下，比如性能优化、和非托管代码交互、对结构体进行序列化等场景下，了解字段的内存布局是非常重要的。
本文写作时 最新的 .NET 正式版是 .NET 9，以后的版本不保证本文内容的准确性，仅供参考。
本文将介绍 .NET 中结构体字段的内存布局，包括字段的对齐（Alignment）、填充（Padding）以及如何使用 StructLayoutAttribute 来控制字段的内存布局。
对齐的目的是为了 CPU 访问内存的效率，64 位系统和 32 位系统中对齐要求存在差异，下文如果没有特别说明，均指 64 位系统。
填充则是为了满足对齐要求而在字段之间或结构体末尾添加的额外字节。
结构体的对其规则同时适用于栈上和堆上的结构体结构体实例，方便起见，大部分例子将使用栈上结构体实例来演示。
一些资料是从 字段的偏移量（offset）为出发点来介绍字段的内存布局的，但笔者认为从字段的 内存地址 出发更容易理解。
由于一些资料并没有找到明确的官方的解释，笔者是在实验和推导的基础上总结出这些规则的，可能会有不准确的地方，欢迎读者在评论区指出。
本文虽然没有直接介绍引用类型的字段布局，但引用类型实例的字段的内存布局概念与结构体实例的内存布局是相同的。不同之处在于引用类型的默认布局是 LayoutKind.Auto，而结构体的默认布局是 LayoutKind.Sequential。读者可以自己尝试观察引用类型实例字段的内存布局。
本文将使用下面的方法来观察字段的内存地址：
  1. // 打印日志头
  2. void PrintPointerHeader()
  3. {
  4.     Console.WriteLine(
  5.         $"| {"Expr",-15} | {"Address",-15} | {"Size",-4} | {"AlignedBySize",-13} | {"Addr/Size",-12} |");
  6. }
  8. // 打印指针的详细信息
  9. unsafe void PrintPointerDetails<T>(
  10.     T* ptr,
  11.     [CallerArgumentExpression("ptr")] string? pointerExpr = null)
  12.     where T : unmanaged
  13. {
  14.     ulong addressValue = (ulong)ptr;
  15.     ulong typeSize = (ulong)sizeof(T);
  17.     decimal addressDivBySize = addressValue / (decimal)typeSize;
  18.     bool isAlignedBySize = addressValue % typeSize == 0;
  20.     Console.WriteLine(
  21.         $"| {pointerExpr,-15} | {addressValue,-15} | {typeSize,-4} | {isAlignedBySize,-13} | {addressDivBySize,-12:0.##} |"
  22.     );
  23. }
复制代码
并使用 ObjectLayoutInspector 这个开源库来观察字段的内存布局。
项目地址：https://github.com/SergeyTeplyakov/ObjectLayoutInspector
nuget 包地址：https://www.nuget.org/packages/ObjectLayoutInspector
  1. dotnet add package ObjectLayoutInspector --version 0.1.4
复制代码
基本概念

以下是理解结构体字段布局的几个关键点：

  • 字段顺序：字段在结构体实例中的排列顺序，默认按声明顺序排列，但可以通过 StructLayoutAttribute 来控制。
  • 对齐（Alignment）：对齐需要分成三部分理解：

    • 字段的对齐要求（alignment requirement）：指字段在内存中的地址必须是其对齐要求的倍数。对于基元类型（primitive types），对齐要求默认等于其大小，非基元类型的对齐要求取决于结构体中最大字段的对齐要求。
    • 结构体实例的大小：必须是结构体对齐要求的整数倍。
    • 结构体实例的起始地址：在 64 位系统中，数据的地址按 8 字节 对齐有利于提升 CPU 的访问效率，32 位系统中则为 4 字节对齐。

  • 填充（Padding）：为了满足对齐要求，runtime 可能会在结构体实例字段之间及末尾插入填充字节。这些填充字节不会被显式声明，但会影响字段在内存中的实际布局。
结构体的默认字段布局

对齐

字段默认的对齐要求是类型的大小。例如，int 类型的字段需要在 4 字节对齐边界（alignment boundary）上，而 double 类型的字段需要在 8 字节对齐边界上。如果字段类型并非基元类型（primitive types），则对齐要求取决于结构体中最大字段的对齐要求。对齐要求为 2 的整数次幂，例如 1、2、4、8 等。最大对齐要求为 8 字节。
注意：decimal 不属于基元类型，目前版本中由三个字段组成，实例大小为 16 字节，按 8 字节对齐。
  1. Type layout for 'Decimal'
  2. Size: 16 bytes. Paddings: 0 bytes (%0 of empty space)
  3. |===============================|
  4. |   0-3: Int32 _flags (4 bytes) |
  5. |-------------------------------|
  6. |   4-7: UInt32 _hi32 (4 bytes) |
  7. |-------------------------------|
  8. |  8-15: UInt64 _lo64 (8 bytes) |
  9. |===============================|
复制代码
下面是一个简单的示例，展示了结构体字段的默认布局：
  1. using System.Runtime.CompilerServices;
  3. var foo = new Foo();
  4. var bar = new Bar();
  5. var baz = new Baz();
  7. unsafe
  8. {
  9.     PrintPointerHeader();
  11.     PrintPointerDetails(&foo);
  12.     PrintPointerDetails(&foo.a);
  13.     PrintPointerDetails(&foo.b);
  15.     PrintPointerDetails(&bar);
  16.     PrintPointerDetails(&bar.foo);
  17.     PrintPointerDetails(&bar.foo.a);
  18.     PrintPointerDetails(&bar.foo.b);
  20.     fixed (Foo* bazFooPtr = &baz.foo)
  21.     {
  22.         PrintPointerDetails(bazFooPtr);
  23.         PrintPointerDetails(&bazFooPtr->a);
  24.         PrintPointerDetails(&bazFooPtr->b);
  25.     }
  26. }
  28. struct Foo
  29. {
  30.     public int a;
  31.     public long b;
  32. }
  34. struct Bar
  35. {
  36.     public Foo foo;
  37. }
  39. class Baz
  40. {
  41.     public Foo foo;
  42. }
复制代码
输出结果如下：
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo            | 6095528264      | 16   | False         | 380970516.5  |
  3. | &foo.a          | 6095528264      | 4    | True          | 1523882066   |
  4. | &foo.b          | 6095528272      | 8    | True          | 761941034    |
  5. | &bar            | 6095528248      | 16   | False         | 380970515.5  |
  6. | &bar.foo        | 6095528248      | 16   | False         | 380970515.5  |
  7. | &bar.foo.a      | 6095528248      | 4    | True          | 1523882062   |
  8. | &bar.foo.b      | 6095528256      | 8    | True          | 761941032    |
  9. | bazFooPtr       | 12885617264     | 16   | True          | 805351079    |
  10. | &bazFooPtr->a   | 12885617264     | 4    | True          | 3221404316   |
  11. | &bazFooPtr->b   | 12885617272     | 8    | True          | 1610702159   |
复制代码
首先看 Foo 结构体，它有两个字段 a 和 b，分别是 int 和 long 类型，对齐要求分别是 4 字节和 8 字节。
所以 Foo 实例在栈上的地址按照 8 字节 对齐（6095528264 / 8 = 761941033）。
a 字段是 foo 的第一个字段，它的地址也就是 foo 的起始地址，自然也满足 int 的对齐要求（6095528264 / 4 = 1523882066）。
b 字段是 foo 的第二个字段，它的地址为 6095528272，满足 long 的对齐要求（6095528272 / 8 = 761941032）。
Bar 结构体包含一个 Foo 类型的字段 foo，它的对齐要求也是 8 字节（取最大字段 long 的对齐要求），所以 bar 的地址也是按照 8 字节对齐（6095528248 / 8 = 761941031）。bar.foo.a 和 bar.foo.b 的地址也满足各自的对齐要求。
Baz 类包含一个 Foo 类型的字段 foo，由于 Baz 是引用类型，所以它的实例在堆上分配内存。Baz 的 Foo 类型字段也依旧需要满足 8 字节对齐要求（12885617264 / 8 = 1610702158）。
64 位系统与 32 位系统的对齐要求差异

在 64 位系统中，结构体实例的起始地址默认按 8 字节对齐。
而在 32 位系统中，结构体实例的起始地址默认按 4 字节对齐。经笔者测试，CPU 为 intel 时 只按 4 字节对齐，CPU 为 AMD 时 如果结构体包含了 8 字节对齐的字段，则按 8 字节对齐，否则按 4 字节对齐。
首先在 64 位系统上运行下面的代码：
  1. using System.Runtime.CompilerServices;
  2. using ObjectLayoutInspector;
  4. unsafe
  5. {
  6.     var foo = new Foo();
  7.     var bar = new Bar();
  9.     // 方法 PrintPointerHeader 和 PrintPointerDetails 在前言部分已经定义
  10.     PrintPointerHeader();
  11.     PrintPointerDetails(&foo.a);
  12.     PrintPointerDetails(&foo.b);
  13.     PrintPointerDetails(&foo.c);
  14.     PrintPointerDetails(&bar.d);
  15.     PrintPointerDetails(&bar.e);
  16.     PrintPointerDetails(&bar.f);
  17. }
  19. TypeLayout.PrintLayout<Foo>();
  20. TypeLayout.PrintLayout<Bar>();
  22. struct Foo
  23. {
  24.     public int a;
  25.     public long b;
  26.     public byte c;
  27. }
  29. struct Bar
  30. {
  31.     public int d;
  32.     public int e;
  33.     public byte f;
  34. }
复制代码
输出结果如下：
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo.a          | 985964996520    | 4    | True          | 246491249130 |
  3. | &foo.b          | 985964996528    | 8    | True          | 123245624566 |
  4. | &foo.c          | 985964996536    | 1    | True          | 985964996536 |
  5. | &bar.d          | 985964996504    | 4    | True          | 246491249126 |
  6. | &bar.e          | 985964996508    | 4    | True          | 246491249127 |
  7. | &bar.f          | 985964996512    | 1    | True          | 985964996512 |
  8. Type layout for 'Foo'
  9. Size: 24 bytes. Paddings: 11 bytes (%45 of empty space)
  10. |==========================|
  11. |   0-3: Int32 a (4 bytes) |
  12. |--------------------------|
  13. |   4-7: padding (4 bytes) |
  14. |--------------------------|
  15. |  8-15: Int64 b (8 bytes) |
  16. |--------------------------|
  17. |    16: Byte c (1 byte)   |
  18. |--------------------------|
  19. | 17-23: padding (7 bytes) |
  20. |==========================|
  23. Type layout for 'Bar'
  24. Size: 12 bytes. Paddings: 3 bytes (%25 of empty space)
  25. |==========================|
  26. |   0-3: Int32 d (4 bytes) |
  27. |--------------------------|
  28. |   4-7: Int32 e (4 bytes) |
  29. |--------------------------|
  30. |     8: Byte f (1 byte)   |
  31. |--------------------------|
  32. |  9-11: padding (3 bytes) |
  33. |==========================|
复制代码
可以看到，Foo 和 Bar 结构体的实例大小分别为 24 字节和 12 字节，且它们的起始地址都满足 8 字节对齐要求。
在 Windows 环境中，如果安装了 x86 版本的 .NET SDK，可以在 csproj 文件中添加以下属性来让项目运行在 32 位的环境中：
  1. <PropertyGroup>
  2.     <RuntimeIdentifier>win-x86</RuntimeIdentifier>
  3. </PropertyGroup>
复制代码
下面是 intel CPU 的输出结果：
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo.a          | 43511772        | 4    | True          | 10877943     |
  3. | &foo.b          | 43511780        | 8    | False         | 5438972.5    |
  4. | &foo.c          | 43511788        | 1    | True          | 43511788     |
  5. | &bar.d          | 43511760        | 4    | True          | 10877940     |
  6. | &bar.e          | 43511764        | 4    | True          | 10877941     |
  7. | &bar.f          | 43511768        | 1    | True          | 43511768     |
  8. Type layout for 'Foo'
  9. Size: 24 bytes. Paddings: 11 bytes (%45 of empty space)
  10. |==========================|
  11. |   0-3: Int32 a (4 bytes) |
  12. |--------------------------|
  13. |   4-7: padding (4 bytes) |
  14. |--------------------------|
  15. |  8-15: Int64 b (8 bytes) |
  16. |--------------------------|
  17. |    16: Byte c (1 byte)   |
  18. |--------------------------|
  19. | 17-23: padding (7 bytes) |
  20. |==========================|
  23. Type layout for 'Bar'
  24. Size: 12 bytes. Paddings: 3 bytes (%25 of empty space)
  25. |==========================|
  26. |   0-3: Int32 d (4 bytes) |
  27. |--------------------------|
  28. |   4-7: Int32 e (4 bytes) |
  29. |--------------------------|
  30. |     8: Byte f (1 byte)   |
  31. |--------------------------|
  32. |  9-11: padding (3 bytes) |
  33. |==========================|
复制代码
Foo 和 Bar 结构体的起始地址和字段地址都只满足 4 字节对齐要求（43511772 / 4 = 10877943），而不是 8 字节对齐要求。
下面是 AMD CPU 的输出结果：
  1. 运行上述代码，输出结果如下：
  3. ```bash
  4. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  5. | &foo.a          | 47706560        | 4    | True          | 11926640     |
  6. | &foo.b          | 47706568        | 8    | True          | 5963321      |
  7. | &foo.c          | 47706576        | 1    | True          | 47706576     |
  8. | &bar.d          | 47706548        | 4    | True          | 11926637     |
  9. | &bar.e          | 47706552        | 4    | True          | 11926638     |
  10. | &bar.f          | 47706556        | 1    | True          | 47706556     |
  11. Type layout for 'Foo'
  12. Size: 24 bytes. Paddings: 11 bytes (%45 of empty space)
  13. |==========================|
  14. |   0-3: Int32 a (4 bytes) |
  15. |--------------------------|
  16. |   4-7: padding (4 bytes) |
  17. |--------------------------|
  18. |  8-15: Int64 b (8 bytes) |
  19. |--------------------------|
  20. |    16: Byte c (1 byte)   |
  21. |--------------------------|
  22. | 17-23: padding (7 bytes) |
  23. |==========================|
  26. Type layout for 'Bar'
  27. Size: 12 bytes. Paddings: 3 bytes (%25 of empty space)
  28. |==========================|
  29. |   0-3: Int32 d (4 bytes) |
  30. |--------------------------|
  31. |   4-7: Int32 e (4 bytes) |
  32. |--------------------------|
  33. |     8: Byte f (1 byte)   |
  34. |--------------------------|
  35. |  9-11: padding (3 bytes) |
  36. |==========================|
复制代码
Foo 的起始地址仍然满足 8 字节对齐要求，但 Bar 的起始地址不再满足 8 字节对齐要求（47706548 / 8 = 5963318.5），而是满足 4 字节对齐要求（47706548 / 4 = 11926637）。
默认字段布局中 对齐要求 与 偏移量 的关系

偏移量（offset）是指字段相对于结构体实例起始地址的距离，决定了字段在内存中的位置。
偏移量的值取决于对齐要求和字段的顺序，会在未被顺序在前的字段占用的内存空间中取对齐要求的最小整数倍。
下面几个设计确保了不管结构体实例的起始地址如何，任意一个字段只要给定一个满足对齐要求的偏移量，就可以满足该字段的对齐要求：

  • 对齐要求总是 2 的整数次幂。
  • 实例的起始地址（按 8 字节 对齐）总是满足最大字段的对齐要求。
  • 偏移量的值是对齐要求的整数倍
下面做一个简单的推导来帮助读者理解：
假设结构体中最大字段的对齐要求为 2^m（m 为  8 时， 等效于 Pack = 8，因为目前版本没有任何类型的对齐要求超过 8 字节。**
</ul>ack 属性在 LayoutKind.Auto 布局中无效。在 LayoutKind.Sequential 布局中，Pack 属性用于指定字段的对齐要求及结构体实例的对齐要求；在 LayoutKind.Explicit 布局中，Pack 属性用于结构体的对齐要求，会影响结构体实例的末尾填充。
LayoutKind.Sequential

Pack 为 0 时等于默认布局
  1. unsafe
  2. {
  3.     var foo = new Foo();
  5.     var addr = (ulong)&foo;
  7.     Console.WriteLine($"a offset: {(ulong)&foo.a - addr}");
  8.     Console.WriteLine($"b offset: {(ulong)&foo.b - addr}");
  9.     Console.WriteLine($"c offset: {(ulong)&foo.c - addr}");
  10. }
  12. struct Foo
  13. {
  14.     public int a;
  15.     public long b;
  16.     public byte c;
  17. }
复制代码
  1. a offset: 0
  2. b offset: 8
  3. c offset: 16
复制代码
Pack 不为 0 时，取 Pack 和 字段类型大小 的较小值

Pack 设置为 4 时，int 和 long 字段的对齐要求都将被设置为 4 字节，而 byte 字段的对齐要求仍然是 1 字节。结构体的对齐要求是 4 字节。
  1. using ObjectLayoutInspector;
  3. TypeLayout.PrintLayout<Foo>();
  4. TypeLayout.PrintLayout<Bar>();
  6. struct Foo
  7. {
  8.     public int a;
  9.     public long b;
  10.     public byte c;
  11. }
  13. struct Bar
  14. {
  15.     public byte c;
  16.     public int a;
  17.     public long b;
  18. }
复制代码
  1. Type layout for 'Foo'
  2. Size: 24 bytes. Paddings: 11 bytes (%45 of empty space)
  3. |==========================|
  4. |   0-3: Int32 a (4 bytes) |
  5. |--------------------------|
  6. |   4-7: padding (4 bytes) |
  7. |--------------------------|
  8. |  8-15: Int64 b (8 bytes) |
  9. |--------------------------|
  10. |    16: Byte c (1 byte)   |
  11. |--------------------------|
  12. | 17-23: padding (7 bytes) |
  13. |==========================|
  16. Type layout for 'Bar'
  17. Size: 16 bytes. Paddings: 3 bytes (%18 of empty space)
  18. |==========================|
  19. |     0: Byte c (1 byte)   |
  20. |--------------------------|
  21. |   1-3: padding (3 bytes) |
  22. |--------------------------|
  23. |   4-7: Int32 a (4 bytes) |
  24. |--------------------------|
  25. |  8-15: Int64 b (8 bytes) |
  26. |==========================|
复制代码
结构体实例的起始地址按 8 字节 对齐（782597876240 / 8 = 97824734530）。但其大小取满足 4 字节对齐要求的最小整数倍 16 字节（ 末尾字段 c 的偏移量为 12，最小只能取到 16），并在末尾添加 3 字节的填充。
Pack 设置为 1 时，会形成密集的字段布局

当 Pack 设置为 1 时，所有字段的对齐要求都将被设置为 1 字节，这意味着结构体实例将按照 1 字节对齐。此时，结构体实例的字段将紧密排列，不会有额外的填充字节。
  1. using ObjectLayoutInspector;
  3. TypeLayout.PrintLayout<Foo>();
  5. struct Foo
  6. {
  7.     public int a;
  8.     public string b;
  9.     public byte c;
  10. }
复制代码
  1. Type layout for 'Foo'
  2. Size: 16 bytes. Paddings: 3 bytes (%18 of empty space)
  3. |===========================|
  4. |   0-7: String b (8 bytes) |
  5. |---------------------------|
  6. |  8-11: Int32 a (4 bytes)  |
  7. |---------------------------|
  8. |    12: Byte c (1 byte)    |
  9. |---------------------------|
  10. | 13-15: padding (3 bytes)  |
  11. |===========================|
复制代码
起始地址为 8 的倍数（302463314288 / 8 = 37807914286），但结构体实例的大小变为 13 字节，没有末尾填充。
Pack 不为 0 的结构体作为其他结构体字段时

如果外层的结构体采用默认字段布局则，则其实例的起始地址取决嵌套结构体的最大字段默认对齐要求，其实例大小取决该结构体的最大字段对齐要求。
  1. using System.Runtime.InteropServices;
  2. using ObjectLayoutInspector;
  4. TypeLayout.PrintLayout<Foo>();
  6. [StructLayout(LayoutKind.Sequential, Pack = 0)]
  7. struct Foo
  8. {
  9.     public int a;
  10.     public long b;
  11.     public byte c;
  12. }
复制代码
  1. Type layout for 'Foo'
  2. Size: 24 bytes. Paddings: 11 bytes (%45 of empty space)
  3. |==========================|
  4. |   0-3: Int32 a (4 bytes) |
  5. |--------------------------|
  6. |   4-7: padding (4 bytes) |
  7. |--------------------------|
  8. |  8-15: Int64 b (8 bytes) |
  9. |--------------------------|
  10. |    16: Byte c (1 byte)   |
  11. |--------------------------|
  12. | 17-23: padding (7 bytes) |
  13. |==========================|
复制代码
在上面的例子中，Bar 结构体包含一个 Foo 类型的字段 foo。
Bar 的实例起始地址也满足 8 字节对齐要求（724703897336 / 8 = 90587987167）。
foo 的对齐要求为 1 字节， d 的对齐要求为 4 字节，所以 Bar 的实例大小为 20 字节（4 的整数倍），并在foo 和 d 之间添加了 3 字节的填充。
LayoutKind.Explicit

Pack 为 0 时，结构体按照最大字段默认对齐要求对齐

在 Explicit 布局中，我们需要显式指定每个字段的偏移量。使用 FieldOffsetAttribute 来指定字段的偏移量。此时偏移量可以是任意值，甚至允许重叠字段。
此时虽然字段地址可能由于是任意值而不满足对齐要求，但结构体实例的起始地址依旧按 8 字节 对齐，且结构体实例的大小是最大字段对齐要求的整数倍。
  1. using System.Runtime.CompilerServices;
  2. using System.Runtime.InteropServices;
  3. using ObjectLayoutInspector;
  5. {
  6.     var foo = new Foo();
  8.     // 方法 PrintPointerHeader 和 PrintPointerDetails 在前言部分已经定义
  9.     PrintPointerHeader();
  10.     PrintPointerDetails(&foo.a);
  11.     PrintPointerDetails(&foo.b);
  12.     PrintPointerDetails(&foo.c);
  13. }
  15. TypeLayout.PrintLayout<Foo>();
  17. [StructLayout(LayoutKind.Sequential, Pack = 4)]
  18. struct Foo
  19. {
  20.     public int a;
  21.     public long b;
  22.     public byte c;
  23. }
复制代码
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo.a          | 782597876240    | 4    | True          | 195649469060 |
  3. | &foo.b          | 782597876244    | 8    | False         | 97824734530.5 |
  4. | &foo.c          | 782597876252    | 1    | True          | 782597876252 |
  5. Type layout for 'Foo'
  6. Size: 16 bytes. Paddings: 3 bytes (%18 of empty space)
  7. |==========================|
  8. |   0-3: Int32 a (4 bytes) |
  9. |--------------------------|
  10. |  4-11: Int64 b (8 bytes) |
  11. |--------------------------|
  12. |    12: Byte c (1 byte)   |
  13. |--------------------------|
  14. | 13-15: padding (3 bytes) |
  15. |==========================|
复制代码
上面例子中，Foo 结构体的字段 a、b 和 c 的偏移量分别为 0、3 和 11。可以看到，虽然字段的地址不再满足对齐要求，但结构体实例的起始地址仍然按 8 字节 对齐（6095151432 / 8 = 761893929），且结构体实例的大小为 16 字节（最大字段对齐要求的整数倍），末尾添加了 4 字节的填充。
如果将 c 字段的偏移量改为 16，则结构体实例的大小将变为 24 字节，并且会在末尾添加 7 字节的填充。
  1. using System.Runtime.CompilerServices;
  2. using System.Runtime.InteropServices;
  3. using ObjectLayoutInspector;
  5. var foo = new Foo
  6. {
  7.     a = 1,
  8.     b = 2,
  9.     c = 3
  10. };
  12. unsafe
  13. {
  14.     // 方法 PrintPointerHeader 和 PrintPointerDetails 在前言部分已经定义
  15.     PrintPointerHeader();
  16.     PrintPointerDetails(&foo.a);
  17.     PrintPointerDetails(&foo.b);
  18.     PrintPointerDetails(&foo.c);
  19. }
  21. TypeLayout.PrintLayout<Foo>();
  23. [StructLayout(LayoutKind.Sequential, Pack = 1)]
  24. struct Foo
  25. {
  26.     public int a;
  27.     public long b;
  28.     public byte c;
  29. }
复制代码
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo.a          | 302463314288    | 4    | True          | 75615828572  |
  3. | &foo.b          | 302463314292    | 8    | False         | 37807914286.5 |
  4. | &foo.c          | 302463314300    | 1    | True          | 302463314300 |
  5. Type layout for 'Foo'
  6. Size: 13 bytes. Paddings: 0 bytes (%0 of empty space)
  7. |==========================|
  8. |   0-3: Int32 a (4 bytes) |
  9. |--------------------------|
  10. |  4-11: Int64 b (8 bytes) |
  11. |--------------------------|
  12. |    12: Byte c (1 byte)   |
  13. |==========================|
复制代码
Pack 不为 0 时，结构体实例按照 Pack 与 最大字段对齐要求 的较小值对齐

在 Explicit 布局中，如果设置了 Pack 属性且不为 0，则结构体实例将按照 Pack 的值对齐。字段的偏移量仍然可以是任意值，但结构体实例的大小将受到 Pack 属性的影响。
  1. using System.Runtime.CompilerServices;
  2. using System.Runtime.InteropServices;
  3. using ObjectLayoutInspector;
  5. unsafe
  6. {
  7.     PrintPointerHeader();
  8.     PrintPointerDetails(&bar.foo.a);
  9.     PrintPointerDetails(&bar.foo.b);
  10.     PrintPointerDetails(&bar.foo.c);
  11.     PrintPointerDetails(&bar.d);
  12. }
  14. TypeLayout.PrintLayout<Bar>();
  16. [StructLayout(LayoutKind.Sequential, Pack = 1)]
  17. struct Foo
  18. {
  19.     public int a;
  20.     public long b;
  21.     public byte c;
  22. }
  24. struct Bar
  25. {
  26.     public Foo foo;
  27.     public int d;
  28. }
复制代码
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &bar.foo.a      | 724703897336    | 4    | True          | 181175974334 |
  3. | &bar.foo.b      | 724703897340    | 8    | False         | 90587987167.5 |
  4. | &bar.foo.c      | 724703897348    | 1    | True          | 724703897348 |
  5. | &bar.d          | 724703897352    | 4    | True          | 181175974338 |
  6. Type layout for 'Bar'
  7. Size: 20 bytes. Paddings: 3 bytes (%15 of empty space)
  8. |==============================|
  9. |  0-12: Foo foo (13 bytes)    |
  10. | |==========================| |
  11. | |   0-3: Int32 a (4 bytes) | |
  12. | |--------------------------| |
  13. | |  4-11: Int64 b (8 bytes) | |
  14. | |--------------------------| |
  15. | |    12: Byte c (1 byte)   | |
  16. | |==========================| |
  17. |------------------------------|
  18. | 13-15: padding (3 bytes)     |
  19. |------------------------------|
  20. | 16-19: Int32 d (4 bytes)     |
  21. |==============================|
复制代码
在上面的例子中，由于 Pack 属性设置为 4，与 long 类型的 8 字节 比较则结构体实例应按照 4 字节 对齐。因为 c 的偏移量为 16，所以 Foo 的大小在取值此时符合条件的 4 的最小整数倍后变为 20 字节，并在末尾添加了 3 字节 的填充。
改成 Pack = 128 后，结构体实例的大小按照最大字段默认对齐要求 8 字节 对齐。
  1. using System.Runtime.CompilerServices;
  2. using System.Runtime.InteropServices;
  3. using ObjectLayoutInspector;
  5. var foo = new Foo
  6. {
  7.     a = 1,
  8.     b = 2,
  9.     c = 3
  10. };
  12. unsafe
  13. {
  14.     // 方法 PrintPointerHeader 和 PrintPointerDetails 在前言部分已经定义
  15.     PrintPointerHeader();
  16.     PrintPointerDetails(&foo.a);
  17.     PrintPointerDetails(&foo.b);
  18.     PrintPointerDetails(&foo.c);
  19. }
  21. TypeLayout.PrintLayout<Foo>();
  23. [StructLayout(LayoutKind.Explicit, Pack = 0)]
  25. struct Foo
  26. {
  27.     [FieldOffset(0)]
  28.     public int a;
  29.     [FieldOffset(3)]
  30.     public long b;
  31.     [FieldOffset(11)]
  32.     public byte c;
  33. }
复制代码
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo.a          | 6095151432      | 4    | True          | 1523787858   |
  3. | &foo.b          | 6095151435      | 8    | False         | 761893929.38 |
  4. | &foo.c          | 6095151443      | 1    | True          | 6095151443   |
  5. Type layout for 'Foo'
  6. Size: 16 bytes. Paddings: 4 bytes (%25 of empty space)
  7. |==========================|
  8. |   0-3: Int32 a (4 bytes) |
  9. |--------------------------|
  10. |  3-10: Int64 b (8 bytes) |
  11. |--------------------------|
  12. |    11: Byte c (1 byte)   |
  13. |--------------------------|
  14. | 12-15: padding (4 bytes) |
  15. |==========================|
复制代码
将 Pack 属性设置为 1 可以消除结构体实例的末尾填充
  1. using System.Runtime.CompilerServices;
  2. using System.Runtime.InteropServices;
  3. using ObjectLayoutInspector;
  5. var foo = new Foo
  6. {
  7.     a = 1,
  8.     b = 2,
  9.     c = 3
  10. };
  12. unsafe
  13. {
  14.     // 方法 PrintPointerHeader 和 PrintPointerDetails 在前言部分已经定义
  15.     PrintPointerHeader();
  16.     PrintPointerDetails(&foo.a);
  17.     PrintPointerDetails(&foo.b);
  18.     PrintPointerDetails(&foo.c);
  19. }
  21. TypeLayout.PrintLayout<Foo>();
  23. [StructLayout(LayoutKind.Sequential, Pack = 1)]
  24. struct Foo
  25. {
  26.     public int a;
  27.     public long b;
  28.     public byte c;
  29. }[StructLayout(LayoutKind.Explicit, Pack = 1)]struct Foo{    [FieldOffset(0)]    public int a;    [FieldOffset(5)]    public long b;    [FieldOffset(16)]    public byte c;}
复制代码
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo.a          | 6166536512      | 4    | True          | 1541634128   |
  3. | &foo.b          | 6166536515      | 8    | False         | 770817064.38 |
  4. | &foo.c          | 6166536528      | 1    | True          | 6166536528   |
  5. Type layout for 'Foo'
  6. Size: 24 bytes. Paddings: 12 bytes (%50 of empty space)
  7. |==========================|
  8. |   0-3: Int32 a (4 bytes) |
  9. |--------------------------|
  10. |  3-10: Int64 b (8 bytes) |
  11. |--------------------------|
  12. | 11-15: padding (5 bytes) |
  13. |--------------------------|
  14. |    16: Byte c (1 byte)   |
  15. |--------------------------|
  16. | 17-23: padding (7 bytes) |
  17. |==========================|
复制代码
此时实例的起始地址仍然按 8 字节 对齐（468685679112 / 8 = 58585709889），但实例的大小则是 17 字节，末尾填充为 0 字节。
Pack 属性不为 0 的结构体作为其他结构体字段时
  1. var foo = new Foo
  2. {
  3.     a = 1,
  4.     b = 2,
  5.     c = 3
  6. };
  8. unsafe
  9. {
  10.     PrintPointerHeader();
  11.     PrintPointerDetails(&foo.a);
  12.     PrintPointerDetails(&foo.b);
  13.     PrintPointerDetails(&foo.c);
  14. }
  16. TypeLayout.PrintLayout<Foo>();
  18. [StructLayout(LayoutKind.Explicit, Pack = 4)]
  19. struct Foo
  20. {
  21.     [FieldOffset(0)]
  22.     public int a;
  23.     [FieldOffset(5)]
  24.     public long b;
  25.     [FieldOffset(16)]
  26.     public byte c;
  27. }
复制代码
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo.a          | 6122676544      | 4    | True          | 1530669136   |
  3. | &foo.b          | 6122676549      | 8    | False         | 765334568.63 |
  4. | &foo.c          | 6122676560      | 1    | True          | 6122676560   |
  5. Type layout for 'Foo'
  6. Size: 20 bytes. Paddings: 7 bytes (%35 of empty space)
  7. |==========================|
  8. |   0-3: Int32 a (4 bytes) |
  9. |--------------------------|
  10. |     4: padding (1 byte)  |
  11. |--------------------------|
  12. |  5-12: Int64 b (8 bytes) |
  13. |--------------------------|
  14. | 13-15: padding (3 bytes) |
  15. |--------------------------|
  16. |    16: Byte c (1 byte)   |
  17. |--------------------------|
  18. | 17-19: padding (3 bytes) |
  19. |==========================|
复制代码
在上面的例子中，Bar 结构体包含一个 Foo 类型的字段 foo，由于 Foo 的最大字段对齐要求为 8 字节，所以 Bar 的实例起始地址也满足 8 字节对齐要求（967090628200 / 8 = 120886328525）。
foo 的对齐要求为 1 字节， d 的对齐要求为 4 字节，所以 Bar 的实例大小为 24 字节（4 的整数倍），并在foo 和 d 之间添加了 3 字节的填充。
LayoutKind.Auto

使用 LayoutKind.Auto 时，runtime 将根据字段的类型和声明顺序自动确定字段的布局，会调整实例字段的排列顺序和对齐要求，以优化内存布局和性能。
LayoutKind.Auto 也是引用类型实例字段的默认布局方式。
  1. using System.Runtime.CompilerServices;
  2. using System.Runtime.InteropServices;
  3. using ObjectLayoutInspector;
  5. var foo = new Foo
  6. {
  7.     a = 1,
  8.     b = 2,
  9.     c = 3
  10. };
  12. unsafe
  13. {
  14.     // 方法 PrintPointerHeader 和 PrintPointerDetails 在前言部分已经定义
  15.     PrintPointerHeader();
  16.     PrintPointerDetails(&foo.a);
  17.     PrintPointerDetails(&foo.b);
  18.     PrintPointerDetails(&foo.c);
  19. }
  21. TypeLayout.PrintLayout<Foo>();
  23. [StructLayout(LayoutKind.Sequential, Pack = 1)]
  24. struct Foo
  25. {
  26.     public int a;
  27.     public long b;
  28.     public byte c;
  29. }[StructLayout(LayoutKind.Auto)]struct Foo{    public int a;    public long b;    public byte c;}
复制代码
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo.a          | 6104211776      | 4    | True          | 1526052944   |
  3. | &foo.b          | 6104211781      | 8    | False         | 763026472.63 |
  4. | &foo.c          | 6104211792      | 1    | True          | 6104211792   |
  5. Type layout for 'Foo'
  6. Size: 24 bytes. Paddings: 11 bytes (%45 of empty space)
  7. |==========================|
  8. |   0-3: Int32 a (4 bytes) |
  9. |--------------------------|
  10. |     4: padding (1 byte)  |
  11. |--------------------------|
  12. |  5-12: Int64 b (8 bytes) |
  13. |--------------------------|
  14. | 13-15: padding (3 bytes) |
  15. |--------------------------|
  16. |    16: Byte c (1 byte)   |
  17. |--------------------------|
  18. | 17-23: padding (7 bytes) |
  19. |==========================|
复制代码
上面例子中，Foo 结构体的字段 b 被放在了前面，各字段都按照其类型大小进行了对齐，相较于默认布局，Foo 结构体的内存布局更加紧凑，减少了填充字节的数量。
等效于于下面的结构体定义
  1. using System.Runtime.CompilerServices;
  2. using System.Runtime.InteropServices;
  3. using ObjectLayoutInspector;
  5. var foo = new Foo
  6. {
  7.     a = 1,
  8.     b = 2,
  9.     c = 3
  10. };
  11. unsafe
  12. {
  13.     PrintPointerHeader();
  14.     PrintPointerDetails(&foo.a);
  15.     PrintPointerDetails(&foo.b);
  16.     PrintPointerDetails(&foo.c);
  17. }
  19. TypeLayout.PrintLayout<Foo>();
  21. [StructLayout(LayoutKind.Explicit, Pack = 1)]
  22. struct Foo
  23. {
  24.     [FieldOffset(0)]
  25.     public int a;
  26.     [FieldOffset(5)]
  27.     public long b;
  28.     [FieldOffset(16)]
  29.     public byte c;
  30. }
复制代码
作为数组元素时的结构体实例

默认字段布局

默认布局的结构体实例在数组中也会按照最大字段对齐要求进行对齐。每个结构体实例的起始地址都是该结构体最大字段对齐要求的整数倍。
因此默认布局下，数组中的每个结构体的字段都是满足对齐要求的。
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &foo.a          | 468685679112    | 4    | True          | 117171419778 |
  3. | &foo.b          | 468685679117    | 8    | False         | 58585709889.63 |
  4. | &foo.c          | 468685679128    | 1    | True          | 468685679128 |
  5. Type layout for 'Foo'
  6. Size: 17 bytes. Paddings: 4 bytes (%23 of empty space)
  7. |==========================|
  8. |   0-3: Int32 a (4 bytes) |
  9. |--------------------------|
  10. |     4: padding (1 byte)  |
  11. |--------------------------|
  12. |  5-12: Int64 b (8 bytes) |
  13. |--------------------------|
  14. | 13-15: padding (3 bytes) |
  15. |--------------------------|
  16. |    16: Byte c (1 byte)   |
  17. |==========================|
复制代码
  1. using System.Runtime.CompilerServices;
  2. using System.Runtime.InteropServices;
  3. using ObjectLayoutInspector;
  5. var bar = new Bar
  6. {
  7.     foo = new Foo(),
  8.     d = 4
  9. };
  11. unsafe
  12. {
  13.     PrintPointerHeader();
  14.     PrintPointerDetails(&bar.foo.a);
  15.     PrintPointerDetails(&bar.foo.b);
  16.     PrintPointerDetails(&bar.foo.c);
  17.     PrintPointerDetails(&bar.d);
  18. }
  20. TypeLayout.PrintLayout<Bar>();
  22. [StructLayout(LayoutKind.Explicit, Pack = 1)]
  23. struct Foo
  24. {
  25.     [FieldOffset(0)]
  26.     public int a;
  27.     [FieldOffset(5)]
  28.     public long b;
  29.     [FieldOffset(16)]
  30.     public byte c;
  31. }
  33. struct Bar
  34. {
  35.     public Foo foo;
  36.     public int d;
  37. }
复制代码
非默认字段布局

因为数组中结构体实例是连续存储的，如果结构体实例的字段布局进行了非默认的调整，则可能导致第二个开始的构体实例完全不满足对齐要求（包括实例的起始地址和字段地址）。
  1. | Expr            | Address         | Size | AlignedBySize | Addr/Size    |
  2. | &bar.foo.a      | 967090628200    | 4    | True          | 241772657050 |
  3. | &bar.foo.b      | 967090628205    | 8    | False         | 120886328525.63 |
  4. | &bar.foo.c      | 967090628216    | 1    | True          | 967090628216 |
  5. | &bar.d          | 967090628220    | 4    | True          | 241772657055 |
  6. Type layout for 'Bar'
  7. Size: 24 bytes. Paddings: 7 bytes (%29 of empty space)
  8. |==============================|
  9. |  0-16: Foo foo (17 bytes)    |
  10. | |==========================| |
  11. | |   0-3: Int32 a (4 bytes) | |
  12. | |--------------------------| |
  13. | |     4: padding (1 byte)  | |
  14. | |--------------------------| |
  15. | |  5-12: Int64 b (8 bytes) | |
  16. | |--------------------------| |
  17. | | 13-15: padding (3 bytes) | |
  18. | |--------------------------| |
  19. | |    16: Byte c (1 byte)   | |
  20. | |==========================| |
  21. |------------------------------|
  22. | 17-19: padding (3 bytes)     |
  23. |------------------------------|
  24. | 20-23: Int32 d (4 bytes)     |
  25. |==============================|
复制代码
  1. using System.Runtime.CompilerServices;
  2. using System.Runtime.InteropServices;
  3. using ObjectLayoutInspector;
  5. var foo = new Foo
  6. {
  7.     a = 1,
  8.     b = 2,
  9.     c = 3
  10. };
  12. unsafe
  13. {
  14.     PrintPointerHeader();
  15.     PrintPointerDetails(&foo.a);
  16.     PrintPointerDetails(&foo.b);
  17.     PrintPointerDetails(&foo.c);
  18. }
  20. TypeLayout.PrintLayout<Foo>();
  23. [StructLayout(LayoutKind.Auto)]
  24. struct Foo
  25. {
  26.     public int a;
  27.     public long b;
  28.     public byte c;
  29. }
复制代码
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
龙骋唧
2025-6-5 18:02:31

0

粉丝关注

15

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫