使用 C# 获取字段的大小（以字节为单位）

Question

我有一个类，我想检查它的字段并最终报告每个字段占用多少字节。我假设所有字段都是 Int32、字节等类型。

如何轻松找出该字段占用多少字节？

我需要类似的东西：

Int32 a;
// int a_size = a.GetSizeInBytes;
// a_size should be 4

Answer 1

System.Runtime.CompilerServices.Unsafe

使用System.Runtime.CompilerServices.Unsafe.SizeOf<T>() where T: unmanaged

（当不在 .NET Core 中运行时，您需要安装该 NuGet 包）

Documentation 状态：

返回给定类型参数的对象的大小。

它似乎使用sizeof IL 指令，就像Earlz solution 一样。 (source)

unmanaged 约束是 C# 7.3 中的新内容

Answer 2

最简单的方法是：int size = *((int*)type.TypeHandle.Value + 1)

我知道这是实现细节，但 GC 依赖于它，它需要尽可能接近方法表的开始以提高效率，并考虑到 GC 代码的复杂程度，以后没人敢更改它。事实上，它适用于 .net framework+.net core 的每个次要/主要版本。 （目前无法测试 1.0）
如果您想要更可靠的方法，请在具有 [StructLayout(LayoutKind.Auto)] 的动态程序集中发出一个结构，并以相同的顺序使用完全相同的字段，并使用 sizeof IL 指令获取其大小。您可能希望在 struct 中发出一个静态方法，该方法仅返回此值。然后为对象头添加 2*IntPtr.Size。这应该会给你准确的价值。
但是，如果您的类派生自另一个类，则需要分别找到基类的每个大小并再次添加它们 + 2*Inptr.Size 作为标题。您可以通过获取带有BindingFlags.DeclaredOnly 标志的字段来做到这一点。

Answer 3

您可以使用方法重载作为确定字段大小的技巧：

public static int FieldSize(int Field) { return sizeof(int); }
public static int FieldSize(bool Field) { return sizeof(bool); }
public static int FieldSize(SomeStructType Field) { return sizeof(SomeStructType); }

Answer 4

我不得不将它一直归结为 IL 级别，但我最终通过一个非常小的库将这个功能引入了 C#。

您可以在bitbucket 获得它（BSD 许可）

示例代码：

using Earlz.BareMetal;

...
Console.WriteLine(BareMetal.SizeOf<int>()); //returns 4 everywhere I've tested
Console.WriteLine(BareMetal.SizeOf<string>()); //returns 8 on 64-bit platforms and 4 on 32-bit
Console.WriteLine(BareMetal.SizeOf<Foo>()); //returns 16 in some places, 24 in others. Varies by platform and framework version

...

struct Foo
{
  int a, b;
  byte c;
  object foo;
}

基本上，我所做的是围绕sizeof IL 指令编写一个快速的类方法包装器。该指令将获取对对象的引用将使用的原始内存量。例如，如果您有一个 T 数组，那么 sizeof 指令会告诉您每个数组元素相隔多少字节。

这与 C# 的 sizeof 运算符非常不同。一方面，C# 只允许纯值类型，因为实际上不可能以静态方式获取其他任何东西的大小。相反，sizeof 指令在运行时级别工作。因此，无论在此特定实例期间对类型的引用将使用多少内存，都将返回。

您可以在我的blog 看到更多信息和更深入的示例代码

Answer 5

从 Jon Skeets 的答案中，我尝试制作他所指的助手类。欢迎提出改进建议。

public class MeasureSize<T>
{
    private readonly Func<T> _generator;
    private const int NumberOfInstances = 10000;
    private readonly T[] _memArray;

    public MeasureSize(Func<T> generator)
    {
        _generator = generator;
        _memArray = new T[NumberOfInstances];
    }

    public long GetByteSize()
    {
        //Make one to make sure it is jitted
        _generator();

        long oldSize = GC.GetTotalMemory(false);
        for(int i=0; i < NumberOfInstances; i++)
        {
            _memArray[i] = _generator();
        }
        long newSize = GC.GetTotalMemory(false);
        return (newSize - oldSize) / NumberOfInstances;
    }
}

用法：

应该使用生成 T 的新实例的 Func 创建。确保不会每次都返回相同的实例。例如。这样就好了：

    public long SizeOfSomeObject()
    {
        var measure = new MeasureSize<SomeObject>(() => new SomeObject());
        return measure.GetByteSize();
    }

Answer 6

可以间接完成，无需考虑对齐。 引用类型实例的字节数等于服务字段大小 + 类型字段大小。 服务字段（32x 占 4 个字节，64x 占 8 个字节）：

1. 系统块索引
2. 指向方法表的指针
3. +可选（仅适用于数组）数组大小

因此，对于没有任何文件的类，他的实例在 32x 机器上占用 8 个字节。如果是一个字段的类，在同一个类实例上引用，所以，这个类需要（64x）：

Sysblockindex + pMthdTable + 1234562 上的引用 = 8 + 8 + 8 = 24 字节

如果是值类型，它没有任何实例字段，因此in只取他的字段大小。例如，如果我们有一个带有一个 int 字段的结构，那么在 32x 机器上它只需要 4 个字节的内存。

Answer 7

根据受访者的需求，Marshal.SizeOf 可能会或可能不会给您想要的东西。 （在 Jon Skeet 发布他的答案后编辑）。

using System;
using System.Runtime.InteropServices;

public class MyClass
{
    public static void Main()
    {
        Int32 a = 10;
        Console.WriteLine(Marshal.SizeOf(a));
        Console.ReadLine();
    }
}

请注意，正如 jkersch 所说，可以使用 sizeof，但不幸的是只能用于值类型。如果您需要类的大小，Marshal.SizeOf 是您的最佳选择。

Jon Skeet 阐述了为什么 sizeof 和 Marshal.SizeOf 都不是完美的。我猜被问者需要决定他的问题是否可以接受。

Answer 8

你不能，基本上。它将取决于填充，这很可能基于您正在使用的 CLR 版本和处理器等。假设对象没有对其他对象的引用，更容易计算出对象的总大小：创建一个大数组，使用GC.GetTotalMemory 作为基点，用对您的类型的新实例的引用填充数组，然后再次调用GetTotalMemory。将一个值与另一个值分开，然后除以实例数。您可能应该事先创建一个实例，以确保没有新的 JITted 代码对数字有贡献。是的，它就像听起来一样 hacky - 但我以前用过它，效果很好。

就在昨天，我还在想为此编写一个小助手类是个好主意。如果您有兴趣，请告诉我。

编辑：还有另外两个建议，我想同时解决它们。

首先，sizeof 运算符：这仅显示该类型在抽象中占用了多少空间，而没有在其周围应用填充。 （它包括结构内的填充，但不包括应用于另一种类型中该类型变量的填充。）

接下来，Marshal.SizeOf：这仅显示编组后的非托管大小，而不是内存中的实际大小。正如文档明确指出的那样：

返回的大小实际上是 非托管类型的大小。这 非托管和托管大小 对象可以不同。对于性格 类型，大小受 应用于该类的 CharSet 值。

同样，填充可以产生影响。

为了澄清我所说的填充相关的含义，请考虑以下两个类：

class FourBytes { byte a, b, c, d; }
class FiveBytes { byte a, b, c, d, e; }

在我的 x86 机器上，FourBytes 的一个实例占用 12 个字节（包括开销）。 FiveBytes 的一个实例占用 16 个字节。唯一的区别是“e”变量——那么它需要 4 个字节吗？嗯，有点……有点不是。很明显，您可以从 FiveBytes 中删除任何单个变量以将大小恢复到 12 个字节，但这并不意味着变量中的 每个 占用 4 个字节（考虑删除所有变量！）。单个变量的成本在这里并不是一个很有意义的概念。

Answer 9

如果您有类型，请使用 sizeof 运算符。它将以字节为单位返回类型的大小。 例如

Console.WriteLine(sizeof(int));

将输出：

4