.NET支持值类型和引用类型（在Java中，只能定义引用类型）。引用类型的实例在托管堆中分配，并且在没有未完成的引用时被垃圾收集。另一方面，值类型的实例是在堆栈中分配的，因此一旦其作用域结束，分配的内存就会被回收。当然，值类型通过值传递，引用类型通过引用传递。除了System.String之外，所有C#原语数据类型都是值类型。

何时在类上使用结构，

在C#中，结构是值类型，类是引用类型。您可以使用enum关键字和struct关键字在C#中创建值类型。使用值类型而不是引用类型将导致托管堆上的对象减少，从而减少垃圾收集器（GC）的负载，减少GC周期，从而提高性能。然而，价值类型也有其缺点。传递一个大结构肯定比传递一个引用成本更高，这是一个明显的问题。另一个问题是与装箱/拆箱相关的开销。如果您想知道装箱/拆箱是什么意思，请按照以下链接了解装箱和拆箱的详细说明。除了性能之外，有时您只需要类型具有值语义，如果引用类型是您的全部，那么这将很难实现（或者很难看）。当您需要复制语义或需要自动初始化时（通常在这些类型的数组中），您应该只使用值类型。

OP引用的消息来源有一定的可信度。。。但微软呢？对结构使用的立场是什么？我向微软寻求了一些额外的学习，以下是我的发现：

如果类型很小，通常寿命很短，或者通常嵌入其他对象。除非类型具有以下所有特征，否则不要定义结构：它在逻辑上表示单个值，类似于基本类型（整数、双精度等）。它的实例大小小于16字节。它是不可变的。它不必经常装箱。

Microsoft一贯违反这些规则

好吧，无论如何，第二和第三。我们喜爱的字典有两个内部结构：

[StructLayout(LayoutKind.Sequential)]  // default for structs
private struct Entry  //<Tkey, TValue>
{
    //  View code at *Reference Source
}

[Serializable, StructLayout(LayoutKind.Sequential)]
public struct Enumerator : 
    IEnumerator<KeyValuePair<TKey, TValue>>, IDisposable, 
    IDictionaryEnumerator, IEnumerator
{
    //  View code at *Reference Source
}

*参考源

“JonnyCantCode.com”的消息源得到了4分之3的结果，这是可以原谅的，因为第4名可能不会成为问题。如果您发现自己正在装箱一个结构，请重新思考您的体系结构。

让我们来看看为什么微软会使用这些结构：

每个结构Entry和Enumerator表示单个值。速度条目永远不会作为Dictionary类之外的参数传递。进一步的调查表明，为了满足IEnumerable的实现，Dictionary使用了每次请求枚举器时都会复制的枚举器结构。。。有道理。Dictionary类的内部。枚举器是公共的，因为Dictionary是可枚举的，并且必须对IEnumerator接口实现（例如IEnumeratorgetter）具有同等的可访问性。

更新-此外，请注意，当一个结构实现了一个接口（如Enumerator）并被强制转换为该实现的类型时，该结构将成为一个引用类型并被移动到堆中。在Dictionary类内部，Enumerator仍然是值类型。然而，一旦方法调用GetEnumerator（），就会返回一个引用类型IEnumerator。

我们在这里没有看到任何保持结构不可变或保持实例大小仅为16字节或更少的尝试或证明：

上面的结构中没有任何内容声明为只读-不是不可变的这些结构的大小可能远远超过16字节条目具有未确定的生存期（从Add（）到Remove（）、Clear（）或垃圾收集）；

和4.两个结构都存储TKey和TValue，我们都知道它们非常适合作为引用类型（添加了额外的信息）

尽管有哈希键，但字典速度很快，部分原因是实例化结构比引用类型更快。这里，我有一个Dictionary＜int，int＞，它存储了300000个随机整数和顺序递增的键。

容量：312874内存大小：2660827字节完成调整大小：5ms填充总时间：889ms

容量：必须调整内部数组大小之前可用的元素数。

MemSize：通过将字典序列化为MemoryStream并获得字节长度（对于我们的目的来说足够精确）来确定。

完成调整大小：将内部数组从150862个元素调整为312874个元素所需的时间。如果您认为每个元素都是通过Array.CopyTo（）顺序复制的，那就不太糟糕了。

填充总时间：由于日志记录和我添加到源中的OnResize事件，确实存在偏差；然而，在操作期间填充300k个整数并调整大小15次仍然令人印象深刻。只是出于好奇，如果我已经知道容量，那么总的填充时间是多少？13毫秒

那么，现在，如果Entry是一个类呢？这些时间或指标真的会有那么大的不同吗？

容量：312874内存大小：2660827字节完成调整大小：26ms填充总时间：964ms

显然，最大的区别在于调整大小。如果字典是用容量初始化的，有什么区别吗？不够关心。。。12毫秒。

所发生的是，由于Entry是一个结构，它不需要像引用类型那样进行初始化。这既是价值类型的美，也是价值类型的祸根。为了使用Entry作为引用类型，我必须插入以下代码：

/*
 *  Added to satisfy initialization of entry elements --
 *  this is where the extra time is spent resizing the Entry array
 * **/
for (int i = 0 ; i < prime ; i++)
{
    destinationArray[i] = new Entry( );
}
/*  *********************************************** */  

我必须将Entry的每个数组元素初始化为引用类型的原因可以在MSDN：Structure Design中找到。简而言之：

不要为结构提供默认构造函数。如果结构定义了默认构造函数结构，公共语言运行时自动对每个数组元素执行默认构造函数。某些编译器（如C#编译器）不允许结构具有默认构造函数。

这其实很简单，我们可以借用阿西莫夫的《机器人三定律》：

结构必须安全才能使用结构必须有效地执行其功能，除非这会违反规则#1结构在使用过程中必须保持完整，除非需要对其进行销毁以满足规则#1

…我们从中得到了什么：简而言之，对价值类型的使用负责。它们快速高效，但如果维护不当（即无意复制），则能够导致许多意外行为。

根据C#语言规范：

1.7结构与类一样，结构是可以包含数据成员和函数成员的数据结构，但与类不同，结构是值类型，不需要堆分配。结构的变量类型直接存储结构的数据，而类类型存储对动态分配对象的引用。结构类型不支持用户指定的继承，并且所有结构类型隐式继承自类型对象。结构对于具有值语义。复数、坐标系中的点或字典中的键值对都是结构的好例子。这个对小数据结构使用结构而不是类可以应用程序内存分配数量的巨大差异执行。例如，以下程序创建并初始化100个点的阵列。将Point实现为类，101单独的对象被实例化，一个用于数组，另一个用于100个元素。

class Point
{
   public int x, y;

   public Point(int x, int y) {
      this.x = x;
      this.y = y;
   }
}

class Test
{
   static void Main() {
      Point[] points = new Point[100];
      for (int i = 0; i < 100; i++) points[i] = new Point(i, i);
   }
}

另一种方法是使Point成为结构。

struct Point
{
   public int x, y;

   public Point(int x, int y) {
      this.x = x;
      this.y = y;
   }
}

现在，只实例化了一个对象，即数组的对象，Point实例存储在数组中。

结构构造函数是用新运算符调用的，但这并不意味着正在分配内存。结构构造函数不是动态分配对象并返回对它的引用，而是简单地返回结构值本身（通常在堆栈上的临时位置），然后根据需要复制该值。

使用类，两个变量可以引用同一个对象，因此对一个变量的操作可能会影响另一个变量引用的对象。对于结构，每个变量都有自己的数据副本，对其中一个变量的操作不可能影响另一个变量。例如，以下代码片段产生的输出取决于Point是类还是结构。

Point a = new Point(10, 10);
Point b = a;
a.x = 20;
Console.WriteLine(b.x);

如果Point是一个类，则输出为20，因为a和b引用相同的对象。如果Point是一个结构，则输出为10，因为将a赋值给b会创建一个值的副本，并且该副本不受后续对a.x赋值的影响。

上一个示例突出了结构的两个限制。首先，复制整个结构通常比复制对象引用效率低，因此与引用类型相比，结构的赋值和值参数传递可能更昂贵。第二，除了ref和out参数之外，不可能创建对结构的引用，这在许多情况下排除了它们的使用。

以下是在Microsoft网站上定义的规则：

✔️ 如果类型的实例很小且通常很短，或者通常嵌入在其他对象中，请考虑定义结构而不是类。

❌ 避免定义结构，除非该类型具有以下所有特征：

它在逻辑上表示单个值，类似于原始类型（int、double等）。

它的实例大小小于16字节。

它是不可变的。

它不必经常装箱。

供进一步阅读

C#或其他.net语言中的结构类型通常用于保存应该表现为固定大小的值组的内容。结构类型的一个有用方面是，可以通过修改保存结构类型实例的存储位置来修改该实例的字段，而不是以其他方式。可以以这样的方式对结构进行编码，即变异任何字段的唯一方法是构造一个完整的新实例，然后使用结构赋值通过用新实例中的值覆盖目标的所有字段来对其进行变异，但除非结构不提供创建其字段具有非默认值的实例的方法，如果结构本身存储在可变位置，则其所有字段都是可变的。

请注意，如果结构包含一个私有类类型字段，那么可以设计一个结构类型，使其基本上表现为类类型，并将其自身成员重定向到包装的类对象的成员。例如，PersonCollection可能提供财产SortedByName和SortedById，这两个属性都持有对PersonCollection的“不可变”引用（在其构造函数中设置），并通过调用creator.GetNameSortedEnumerator或creator.GetIdSortedEnumerator来实现GetEnumerater。此类结构的行为与对PersonCollection的引用非常相似，除了它们的GetEnumerator方法将绑定到PersonCollection中的不同方法。也可以有一个结构来包裹数组的一部分（例如，可以定义一个ArrayRange＜T＞结构，该结构将保存一个称为Arr的T[]、一个int Offset和一个int Length，以及一个索引属性，对于范围0到Length-1的索引idx，该属性将访问Arr[idx+Offset]）。不幸的是，如果foo是这种结构的只读实例，当前的编译器版本将不允许像foo[3]+=4这样的操作；因为它们无法确定这些操作是否会尝试写入foo的字段。

也可以设计一个结构，使其行为类似于一个值类型，该值类型包含一个可变大小的集合（无论何时该结构都会被复制），但唯一可行的方法是确保该结构包含引用的对象不会暴露于任何可能使其发生变异的对象。例如，可以有一个类似数组的结构，它保存一个私有数组，其索引的“put”方法创建一个新数组，其内容与原始数组的内容相似，只有一个元素发生了更改。不幸的是，要使这种结构有效地执行可能有些困难。虽然有时结构语义可能很方便（例如，能够将类似数组的集合传递给例程，调用方和被调用方都知道外部代码不会修改集合，这可能比要求调用方和受调用方防御性地复制它们所提供的任何数据要好），类引用指向永远不会变异的对象的要求通常是一个相当严格的约束。

我刚刚在处理Windows Communication Foundation[WCF]命名管道，我注意到使用Structs确实有意义，以确保数据交换是值类型而不是引用类型。