C# 为什么 .NET 结构应该少于 16 个字节？

Why should a .NET struct be less than 16 bytes?

提问by Joe

I've read in a few places now that the maximum instance size for a struct should be 16 bytes.

我已经在几个地方读到了结构的最大实例大小应该是 16 字节。

But I cannot see where that number (16) comes from.

但我看不出那个数字 (16) 是从哪里来的。

Browsing around the net, I've found some who suggest that it's an approximate number for good performance but Microsoft talk like it is a hard upper limit. (e.g. MSDN)

在网上浏览，我发现有些人认为这是一个良好性能的近似数字，但微软认为这是一个硬上限。（例如MSDN）

Does anyone have a definitive answer about why it is 16 bytes?

有没有人对为什么它是 16 个字节有明确的答案？

采纳答案by jalf

It is just a performance rule of thumb.

这只是一个性能经验法则。

The point is that because value types are passed by value, the entire size of the struct has to be copied if it is passed to a function, whereas for a reference type, only the reference (4 bytes) has to be copied. A struct might save a bit of time though because you remove a layer of indirection, so even if it is larger than these 4 bytes, it might still be more efficient than passing a reference around. But at some point, it becomes so big that the cost of copying becomes noticeable. And a common rule of thumb is that this typically happens around 16 bytes. 16 is chosen because it's a nice round number, a power of two, and the alternatives are either 8 (which is too small, and would make structs almost useless), or 32 (at which point the cost of copying the struct is already problematic if you're using structs for performance reasons)

关键是因为值类型是按值传递的，如果传递给函数，则必须复制结构的整个大小，而对于引用类型，只需复制引用（4 个字节）。struct 可能会节省一些时间，因为您删除了一个间接层，因此即使它大于这 4 个字节，它仍然可能比传递引用更有效。但在某些时候，它变得如此之大，以至于复制的成本变得显而易见。一个常见的经验法则是，这通常发生在 16 个字节左右。选择 16 是因为它是一个很好的整数，是 2 的幂，而其他选择是 8（太小，会使结构几乎无用）或 32（此时复制结构的成本已经成问题）如果您出于性能原因使用结构）

But ultimately, this is performance advice. It answers the question of "which would be most efficient to use? A struct or a class?". But it doesn't answer the question of "which best maps to my problem domain".

但归根结底，这是性能建议。它回答了“使用哪个最有效？结构还是类？”的问题。但它没有回答“哪个最好地映射到我的问题域”的问题。

Structs and classes behave differently. If you need a struct's behavior, then I would say to make it a struct, no matter the size. At least until you run into performance problems, profile your code, and find that your struct is a problem.

结构和类的行为不同。如果您需要结构的行为，那么无论大小如何，我都会说使其成为结构。至少在您遇到性能问题之前，分析您的代码，并发现您的结构有问题。

your link even says that it is just a matter of performance:

您的链接甚至说这只是性能问题：

If one or more of these conditions are not met, create a reference type instead of a structure. Failure to adhere to this guideline can negatively impact performance.

如果不满足这些条件中的一个或多个，请创建引用类型而不是结构。不遵守此准则会对性能产生负面影响。

回答by Thorarin

I think the 16 bytes is just a rule of thumb from a performance point of view. An object in .NET uses at least 24 bytes of memory (IIRC), so if you made your structure much larger than that, a reference type would be preferable.

我认为从性能的角度来看，16 字节只是一个经验法则。.NET 中的对象至少使用 24 字节的内存 (IIRC)，因此如果您的结构比这大得多，则最好使用引用类型。

I can't think of any reason why they chose 16 bytes specifically.

我想不出他们特别选择 16 字节的任何原因。

回答by Marc Gravell

The size figure comes largely from the amount of time it takes to copy the struct on the stack, for example to pass to a method. Anything much larger than this and you are consuming a lot of stack space and CPU cycles just copying data - when a reference to an immutable class (even with dereferencing) could be a lot more efficient.

大小数字主要来自复制堆栈上的结构所需的时间，例如传递给方法。任何比这大得多的东西，并且仅复制数据就会消耗大量堆栈空间和 CPU 周期 - 当对不可变类的引用（即使取消引用）可能会更有效率。

回答by Guffa

If a structure is not larger than 16 bytes, it can be copied with a few simple processor instructions. If it's larger, a loop is used to copy the structure.

如果结构不大于 16 字节，则可以使用一些简单的处理器指令进行复制。如果它更大，则使用循环来复制结构。

As long as the structure is not larger than 16 bytes, the processor has to do about the same work when copying the structure as when copying a reference. If the structure is larger, you lose the performance benefit of having s structure, and you should generally make it a class instead.

只要结构不大于 16 字节，处理器在复制结构时就必须做与复制引用时相同的工作。如果结构体更大，你就失去了结构体的性能优势，你通常应该把它变成一个类。

回答by Raj Rao

Here is a scenario where structs can exhibit superior performance:

以下是结构可以表现出卓越性能的场景：

When you need to create 1000s of instances. In this case if you were to use a class, you would first need to allocate the array to hold the 1000s of instances and then in a loop allocate each instance. But instead if you were to use structs, then the 1000s of instances become available immediately after you allocate the array that is going to hold them.

当您需要创建 1000 个实例时。在这种情况下，如果您要使用一个类，您首先需要分配数组来保存 1000 个实例，然后在循环中分配每个实例。但是，如果您要使用结构体，那么在您分配将要保存它们的数组后，1000 个实例将立即可用。

In addition, structs are extremely useful when you need to do interop or want to dip into unsafe code for performance reasons.

此外，当您需要进行互操作或出于性能原因想要深入研究不安全代码时，结构非常有用。

As always there is a trade-off and one needs to analyze what they are doing to determine the best way to implement something.

与往常一样，需要权衡利弊，需要分析他们正在做什么，以确定实施某事的最佳方式。

ps: This scenario came into play when I was working with LIDAR data where there could be millions of points representing x,y,z and other attributes for ground data. This data needed to be loaded into memory for some intensive computation to output all kinds of stuff.

ps：当我使用 LIDAR 数据时，这个场景开始发挥作用，其中可能有数百万个点代表地面数据的 x、y、z 和其他属性。需要将这些数据加载到内存中进行一些密集计算以输出各种内容。

回答by supercat

As other answers have noted, the per-byte cost of copying a structure which is larger than a certain threshold (which was 16 bytes in earlier versions of .NET, but has since grown to 20-24) is significantly greater than the per-byte cost of a smaller structure. It's important to note, however, that copying a structure of anyparticular size oncewill be a fraction of the cost creating a new class object instance of that same size. If a struct would be copied many times in its lifetime, and the value-type semantics are not particularly required, a class object may be preferable. If, however, a struct would end up being copied only once or twice, such copying would likely be cheaper than the creation of a new class object. The break-even number of copies where a class object would become cheaper varies with the size of the struct/object in question, but is much higher for things that are below the "cheap copying" threshold, than for things above.

正如其他答案所指出的那样，复制大于某​​个阈值（在 .NET 的早期版本中为 16 字节，但后来增长到 20-24 字节）的结构的每字节成本明显高于每字节成本。较小结构的字节成本。然而，重要的是要注意，复制任何特定大小的结构一次将是创建相同大小的新类对象实例的成本的一小部分。如果一个结构体在其生命周期中被多次复制，并且值类型语义不是特别需要，那么类对象可能更可取。然而，如果一个结构体最终只会被复制一次或两次，那么这种复制可能比创建一个新的类对象更便宜。类对象变得更便宜的副本的盈亏平衡数随着所讨论的结构/对象的大小而变化，但对于低于“廉价复制”阈值的东西，比上面的东西要高得多。

BTW, another point worth mentioning is that the cost of passing a struct as a refparameter is independent of the size of the struct. In many cases, optimal performance may be achieved by using value types and passing them by ref. Once must be careful to avoid using properties or readonlyfields of structure types, however, since accessing either of those will create an implicit temporary copy of the struct in question.

顺便说一句，另一点值得一提的是，将结构作为ref参数传递的成本与结构的大小无关。在许多情况下，可以通过使用值类型并通过 传递它们来实现最佳性能ref。但是，Once 必须小心避免使用readonly结构类型的属性或字段，因为访问其中任何一个都会创建相关结构的隐式临时副本。