当您需要值语义而不是引用语义时，请使用结构。

如果需要引用语义，则需要类而不是结构。

无论何时：

不需要多态性，want值语义，以及希望避免堆分配和相关的垃圾收集开销。

然而，需要注意的是，结构（任意大）传递比类引用（通常是一个机器字）更昂贵，因此类在实践中可能会更快。

我认为一个好的第一近似值是“从不”。

我认为一个好的二次近似是“从不”。

如果你渴望表现，那么考虑一下，但始终要衡量。

结构适合于数据的原子表示，其中所述数据可以被代码复制多次。克隆对象通常比复制结构更昂贵，因为它涉及分配内存、运行构造函数以及在完成时释放/垃圾回收。

在需要使用StructLayoutAttribute显式指定内存布局（通常用于PInvoke）的情况下，需要使用“结构”。

编辑：注释指出，可以将类或结构与StructLayoutAttribute一起使用，这当然是正确的。在实践中，您通常会使用一个结构——它是在堆栈上分配的，而不是在堆上分配的——如果您只是向非托管方法调用传递一个参数，这是有意义的。

第一：互操作场景或需要指定内存布局时

第二：当数据大小与引用指针几乎相同时。

除了运行时直接使用的值类型和其他用于PInvoke的值类型之外，您只能在两种情况下使用值类型。

当您需要复制语义时。当您需要自动初始化时，通常在这些类型的数组中。

我使用结构来打包或解包任何类型的二进制通信格式。这包括读取或写入磁盘、DirectX顶点列表、网络协议或处理加密/压缩数据。

在这方面，你列出的三条准则对我来说并不有用。当我需要以特殊顺序写出400字节的内容时，我将定义一个400字节的结构，并用它应该具有的任何不相关的值填充它，我将以当时最合理的方式设置它。（好吧，四百字节会很奇怪——但当我以写Excel文件为生的时候，我处理的是多达四十字节的结构，因为这就是一些BIFF记录的大小。）

不，我不完全同意这些规则。它们是考虑性能和标准化的良好指南，但不是根据可能性。

正如你在回答中看到的，有很多创造性的方法来使用它们。因此，这些指导原则需要做到这一点，始终是为了性能和效率。

在本例中，我使用类以更大的形式表示真实世界的对象，使用结构来表示具有更精确用途的较小对象。你说的是，“一个更具凝聚力的整体”。类将是更多面向对象的元素，而结构可以具有这些特性，尽管规模较小。IMO。

我在Treeview和Listview标签中经常使用它们，在这些标签中可以非常快速地访问常见的静态属性。我一直在努力以另一种方式获取这些信息。例如，在我的数据库应用程序中，我使用Treeview，其中包含表、SP、函数或任何其他对象。我创建并填充我的结构，将其放入标记中，将其拉出，获取所选内容的数据等等。我不会在课堂上这样做！

我确实会尽量缩小它们，在单实例情况下使用它们，并防止它们发生变化。注意内存、分配和性能是明智的。测试是非常必要的。

我很少对事物使用结构。但这只是我，这取决于我是否需要对象为空。

如其他答案所述，我对真实世界的对象使用类。我也有结构用于存储少量数据的想法。

我不同意原帖子中给出的规则。以下是我的规则：

当存储在数组中时，可以使用结构来提高性能。（另请参见结构何时是答案？）在向C/C传递结构化数据的代码中需要它们++除非需要，否则不要使用结构：它们的行为与赋值下的“正常对象”（引用类型）不同当作为参数传递时，这可能导致意外行为；如果查看代码的人不知道他们正在处理一个结构。它们不能被继承。将结构作为参数传递比类更昂贵。

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

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

除了“它是一个值”的答案之外，使用结构的一个特定场景是当您知道有一组数据会导致垃圾收集问题，并且您有很多对象时。例如，Person实例的大列表/数组。这里的自然隐喻是一个类，但如果您有大量长寿的Person实例，它们可能会阻塞GEN-2并导致GC暂停。如果场景允许，这里的一种潜在方法是使用Person结构的数组（而不是列表），即Person[]。现在，在GEN-2中没有数百万个对象，而是在LOH上有一个块（我假设这里没有字符串等-即没有任何引用的纯值）。这对GC的影响很小。

处理这些数据是很困难的，因为数据对于一个结构来说可能太大了，而且您不想一直复制胖值。然而，直接在数组中访问它不会复制结构-它是在适当的位置（与列表索引器不同，它会复制）。这意味着大量的索引工作：

int index = ...
int id = peopleArray[index].Id;

请注意，保持值本身不可变将有助于此。对于更复杂的逻辑，请使用带有by-ref参数的方法：

void Foo(ref Person person) {...}
...
Foo(ref peopleArray[index]);

同样，这是正确的-我们没有复制值。

在非常具体的情况下，这种策略可能非常成功；然而，这是一个相当先进的scernario，只有当你知道自己在做什么和为什么时，才应该尝试。这里的默认值是类。

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”方法创建一个新数组，其内容与原始数组的内容相似，只有一个元素发生了更改。不幸的是，要使这种结构有效地执行可能有些困难。虽然有时结构语义可能很方便（例如，能够将类似数组的集合传递给例程，调用方和被调用方都知道外部代码不会修改集合，这可能比要求调用方和受调用方防御性地复制它们所提供的任何数据要好），类引用指向永远不会变异的对象的要求通常是一个相当严格的约束。

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

何时在类上使用结构，

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

根据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参数之外，不可能创建对结构的引用，这在许多情况下排除了它们的使用。

Struct可用于提高垃圾收集性能。虽然您通常不必担心GC性能，但在某些情况下，它可能是一个杀手。就像低延迟应用程序中的大型缓存。请参阅本帖中的示例：

http://00sharp.wordpress.com/2013/07/03/a-case-for-the-struct/

我的规则是

1、始终使用类；

如果有任何性能问题，我会根据@IAbstract提到的规则将一些类更改为结构，然后进行测试，看看这些更改是否可以提高性能。

这是一条基本规则。

如果所有成员字段都是值类型，则创建一个结构。如果任何一个成员字段是引用类型，请创建一个类。这是因为引用类型字段无论如何都需要堆分配。

Exmaples公司

public struct MyPoint 
{
    public int X; // Value Type
    public int Y; // Value Type
}

public class MyPointWithName 
{
    public int X; // Value Type
    public int Y; // Value Type
    public string Name; // Reference Type
}

类是引用类型。创建类的对象时，分配给该对象的变量只保留对该内存的引用。将对象引用指定给新变量时，新变量将引用原始对象。通过一个变量所做的更改反映在另一个变量中，因为它们都引用了相同的数据。结构是值类型。创建结构时，分配给该结构的变量保存该结构的实际数据。当将结构分配给新变量时，将复制该结构。因此，新变量和原始变量包含相同数据的两个单独副本。对一个副本所做的更改不会影响另一个副本。通常，类用于建模更复杂的行为，或在创建类对象后要修改的数据。结构最适合于主要包含在创建结构后不打算修改的数据的小型数据结构。

类和结构（C#编程指南）

结构在大多数方面类似于类/对象。结构可以包含函数、成员，并且可以继承。但C#中的结构仅用于数据保存。结构比类占用更少的RAM，并且垃圾收集器更容易收集。但当您在结构中使用函数时，编译器实际上采用的结构与类/对象非常相似，所以如果您想要使用函数，请使用类/对象。

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

简单地说，如果：

您的对象财产/字段不需要更改。我的意思是你只想给它们一个初始值，然后读它们。对象中的财产和字段是值类型，它们并没有那么大。

如果是这种情况，您可以利用结构来获得更好的性能和优化的内存分配，因为它们只使用堆栈，而不是同时使用堆栈和堆（在类中）

结构是值类型。如果将结构分配给新变量，则新变量将包含原始变量的副本。

public struct IntStruct {
    public int Value {get; set;}
}

执行以下操作将导致存储在内存中的结构的5个实例：

var struct1 = new IntStruct() { Value = 0 }; // original
var struct2 = struct1;  // A copy is made
var struct3 = struct2;  // A copy is made
var struct4 = struct3;  // A copy is made
var struct5 = struct4;  // A copy is made

// NOTE: A "copy" will occur when you pass a struct into a method parameter.
// To avoid the "copy", use the ref keyword.

// Although structs are designed to use less system resources
// than classes.  If used incorrectly, they could use significantly more.

类是引用类型。将类分配给新变量时，该变量包含对原始类对象的引用。

public class IntClass {
    public int Value {get; set;}
}

执行以下操作只会导致内存中类对象的一个实例。

var class1 = new IntClass() { Value = 0 };
var class2 = class1;  // A reference is made to class1
var class3 = class2;  // A reference is made to class1
var class4 = class3;  // A reference is made to class1
var class5 = class4;  // A reference is made to class1  

结构可能会增加代码错误的可能性。如果将值对象视为可变引用对象，那么当所做的更改意外丢失时，开发人员可能会感到惊讶。

var struct1 = new IntStruct() { Value = 0 };
var struct2 = struct1;
struct2.Value = 1;
// At this point, a developer may be surprised when 
// struct1.Value is 0 and not 1

我用BenchmarkDotNet做了一个小的基准测试，以更好地理解数字中的“结构”好处。我正在测试遍历结构（或类）数组（或列表）的循环。创建这些数组或列表超出了基准测试的范围——很明显，“类”更重会占用更多内存，并且会涉及GC。

因此，结论是：小心LINQ和隐藏结构装箱/拆箱，并使用结构进行微优化严格遵守数组。

P.S.关于通过调用堆栈传递结构/类的另一个基准是https://stackoverflow.com/a/47864451/506147

BenchmarkDotNet=v0.10.8, OS=Windows 10 Redstone 2 (10.0.15063)
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233542 Hz, Resolution=309.2584 ns, Timer=TSC
  [Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.7.2101.1
  Clr    : Clr 4.0.30319.42000, 64bit RyuJIT-v4.7.2101.1
  Core   : .NET Core 4.6.25211.01, 64bit RyuJIT


          Method |  Job | Runtime |      Mean |     Error |    StdDev |       Min |       Max |    Median | Rank |  Gen 0 | Allocated |
---------------- |----- |-------- |----------:|----------:|----------:|----------:|----------:|----------:|-----:|-------:|----------:|
   TestListClass |  Clr |     Clr |  5.599 us | 0.0408 us | 0.0382 us |  5.561 us |  5.689 us |  5.583 us |    3 |      - |       0 B |
  TestArrayClass |  Clr |     Clr |  2.024 us | 0.0102 us | 0.0096 us |  2.011 us |  2.043 us |  2.022 us |    2 |      - |       0 B |
  TestListStruct |  Clr |     Clr |  8.427 us | 0.1983 us | 0.2204 us |  8.101 us |  9.007 us |  8.374 us |    5 |      - |       0 B |
 TestArrayStruct |  Clr |     Clr |  1.539 us | 0.0295 us | 0.0276 us |  1.502 us |  1.577 us |  1.537 us |    1 |      - |       0 B |
   TestLinqClass |  Clr |     Clr | 13.117 us | 0.1007 us | 0.0892 us | 13.007 us | 13.301 us | 13.089 us |    7 | 0.0153 |      80 B |
  TestLinqStruct |  Clr |     Clr | 28.676 us | 0.1837 us | 0.1534 us | 28.441 us | 28.957 us | 28.660 us |    9 |      - |      96 B |
   TestListClass | Core |    Core |  5.747 us | 0.1147 us | 0.1275 us |  5.567 us |  5.945 us |  5.756 us |    4 |      - |       0 B |
  TestArrayClass | Core |    Core |  2.023 us | 0.0299 us | 0.0279 us |  1.990 us |  2.069 us |  2.013 us |    2 |      - |       0 B |
  TestListStruct | Core |    Core |  8.753 us | 0.1659 us | 0.1910 us |  8.498 us |  9.110 us |  8.670 us |    6 |      - |       0 B |
 TestArrayStruct | Core |    Core |  1.552 us | 0.0307 us | 0.0377 us |  1.496 us |  1.618 us |  1.552 us |    1 |      - |       0 B |
   TestLinqClass | Core |    Core | 14.286 us | 0.2430 us | 0.2273 us | 13.956 us | 14.678 us | 14.313 us |    8 | 0.0153 |      72 B |
  TestLinqStruct | Core |    Core | 30.121 us | 0.5941 us | 0.5835 us | 28.928 us | 30.909 us | 30.153 us |   10 |      - |      88 B |

代码：

[RankColumn, MinColumn, MaxColumn, StdDevColumn, MedianColumn]
    [ClrJob, CoreJob]
    [HtmlExporter, MarkdownExporter]
    [MemoryDiagnoser]
    public class BenchmarkRef
    {
        public class C1
        {
            public string Text1;
            public string Text2;
            public string Text3;
        }

        public struct S1
        {
            public string Text1;
            public string Text2;
            public string Text3;
        }

        List<C1> testListClass = new List<C1>();
        List<S1> testListStruct = new List<S1>();
        C1[] testArrayClass;
        S1[] testArrayStruct;
        public BenchmarkRef()
        {
            for(int i=0;i<1000;i++)
            {
                testListClass.Add(new C1  { Text1= i.ToString(), Text2=null, Text3= i.ToString() });
                testListStruct.Add(new S1 { Text1 = i.ToString(), Text2 = null, Text3 = i.ToString() });
            }
            testArrayClass = testListClass.ToArray();
            testArrayStruct = testListStruct.ToArray();
        }

        [Benchmark]
        public int TestListClass()
        {
            var x = 0;
            foreach(var i in testListClass)
            {
                x += i.Text1.Length + i.Text3.Length;
            }
            return x;
        }

        [Benchmark]
        public int TestArrayClass()
        {
            var x = 0;
            foreach (var i in testArrayClass)
            {
                x += i.Text1.Length + i.Text3.Length;
            }
            return x;
        }

        [Benchmark]
        public int TestListStruct()
        {
            var x = 0;
            foreach (var i in testListStruct)
            {
                x += i.Text1.Length + i.Text3.Length;
            }
            return x;
        }

        [Benchmark]
        public int TestArrayStruct()
        {
            var x = 0;
            foreach (var i in testArrayStruct)
            {
                x += i.Text1.Length + i.Text3.Length;
            }
            return x;
        }

        [Benchmark]
        public int TestLinqClass()
        {
            var x = testListClass.Select(i=> i.Text1.Length + i.Text3.Length).Sum();
            return x;
        }

        [Benchmark]
        public int TestLinqStruct()
        {
            var x = testListStruct.Select(i => i.Text1.Length + i.Text3.Length).Sum();
            return x;
        }
    }

C#结构是类的轻量级替代。它可以做的几乎与类相同，但使用结构而不是类的“成本”更低。这样做的原因有点技术性，但总而言之，类的新实例放在堆上，新实例化的结构放在堆栈上。此外，您不是像处理类那样处理对结构的引用，而是直接处理结构实例。这也意味着，当您将结构传递给函数时，它是按值传递的，而不是作为引用。在关于函数参数的章节中有更多关于这一点的内容。

因此，当您希望表示更简单的数据结构时，尤其是如果您知道要实例化大量数据结构，那么应该使用结构。在.NET框架中有很多示例，其中Microsoft使用了结构而不是类，例如Point、Rectangle和Color结构。

神话1：结构是轻量级类

这个神话有多种形式。有些人认为价值类型不能或不应该有方法或其他重要的行为，它们应该简单地使用数据传输类型，只有公共字段或简单的财产。DateTime类型是这是一个很好的反例：就存在而言，它是一种价值类型是有意义的一个基本单位，如数字或字符能够基于其值执行计算。从另一个角度看问题方向，数据传输类型通常应该是引用类型应该基于期望的值或引用类型语义，而不是类型。其他人认为价值类型比参考类型“更轻”性能。事实是，在某些情况下，价值类型更有表现力-它们不需要垃圾收集，除非它们是盒装的，没有类型例如，识别开销，并且不需要取消引用。但在其他方面方法，引用类型是性能更高的参数传递，将值分配给变量、返回值和类似操作只需要4或8个字节即可复制（取决于您运行的是32位还是64位CLR），而不是复制所有数据。想象一下，如果ArrayList是一个“纯”值类型，并且将ArrayList表达式传递给涉及复制其所有数据的方法！在几乎无论如何，性能并不是由这种决定决定的。瓶颈几乎永远不会出现在你认为会出现的地方，在你根据性能做出设计决策之前，你应该衡量不同的选择。值得注意的是，这两种信念的结合也不起作用。它不管一个类型有多少个方法（无论是类还是结构）-每个实例占用的内存不受影响。（内存方面有成本为代码本身占用，但这只发生一次，而不是每个实例。）

神话#2：引用类型存在于堆中；堆栈上存在值类型

这通常是由于重复的人的懒惰造成的部分是正确的，引用类型的实例总是在堆上创建的。这是导致问题的第二部分。正如我已经注意到的，变量的值存在于声明的任何地方，因此，如果您有一个类的实例变量类型为int，那么任何给定对象的变量值将始终位于该对象的其余数据的位置在堆上。仅局部变量（方法中声明的变量）和方法参数存在于堆栈中。在C#2和更高版本中，即使是一些局部变量在堆栈上生存，正如我们在第5章中研究匿名方法时所看到的那样。这些概念现在是否相关？如果您正在编写托管代码，那么应该让运行时考虑内存的最佳使用方式，这是有争议的。事实上，语言规范并不能保证哪里未来的运行时可能能够在堆栈上创建一些对象，如果或者C#编译器可以生成几乎不使用堆栈。下一个神话通常只是一个术语问题。

神话#3：默认情况下，对象在C中通过引用传递

这可能是流传最广的神话。再一次，制造这个的人声明经常（虽然不总是）知道C#的实际行为，但他们不知道“通过引用传递”的真正含义。不幸的是，对于那些知道这意味着什么。引用传递的形式定义相对复杂，涉及l值和类似的计算机科学术语，但重要的是，如果你通过了变量，您调用的方法可以通过更改其参数值来更改调用者变量的值。现在，请记住引用的值类型变量是引用，而不是对象本身。您可以更改参数引用的对象，而不通过引用传递参数本身。例如，以下方法更改StringBuilder的内容对象，但调用方的表达式仍将引用与之前：

void AppendHello(StringBuilder builder)
{
    builder.Append("hello");
}

调用此方法时，参数值（对StringBuilder的引用）为通过值传递。如果要在方法，其中语句builder=null-改变不会是与神话相反。有趣的是，不仅神话中的“引用”部分不准确，而且“对象被传递”部分也不准确。对象本身也不会被传递通过引用或通过值。当涉及引用类型时通过引用传递，或者参数（引用）的值通过值传递。除此之外，这回答了当null为如果正在传递对象，则用作by-value参数，这将导致问题，因为不会有对象要通过！相反，空引用由传递值的方式与任何其他引用相同。如果这个简短的解释让您感到困惑，那么您可能想看看我的文章“在C#中传递参数”(http://mng.bz/otVt)，其中包含更多内容细节这些神话并不是唯一的神话。拳击和拆箱是他们的我会努力澄清这一误解。

参考：Jon Skeet的C#深度第三版

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

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

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

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

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

它是不可变的。

它不必经常装箱。

供进一步阅读

✔️ 考虑结构使用

创建一个对象或不需要创建该对象（您可以直接赋值，它创建对象）需要提高速度或性能无需施工人员和拆卸人员（静态承包商可用）不需要类继承，但可以接受接口工作负载小的对象工作，如果工作负载高，内存问题将增加不能为变量设置默认值。结构还可以使用方法、事件、静态构造函数、变量等GC中的工作量更少不需要引用类型，只需要值类型（每次创建新对象时）无不可变对象（字符串是不可变对象，因为任何操作都不会在不更改原始字符串的情况下每次返回新字符串）

除了常见的性能差异之外，让我再补充一个方面，那就是默认值的使用意图。

如果其字段的默认值不表示建模概念的合理默认值，请不要使用结构。

Eg.

即使所有字段都设置为默认值，“颜色”或“点”也有意义。RGB 0,0,0是一种非常好的颜色，（0,0）作为2D中的点也是如此。但是Address或PersonName没有合理的默认值。我的意思是，你能理解FirstName=null和LastName=null的PersonName吗？

如果你用一个类实现了一个概念，那么你可以强制执行某些不变量，例如一个人必须有名字和姓氏。但对于结构，总是可以创建一个实例，将其所有字段设置为默认值。

因此，当对没有合理默认值的概念进行建模时，更喜欢类。类的用户会明白null意味着没有指定PersonName，但如果您给他们一个PersonName结构实例，并将其所有财产设置为null，他们会感到困惑。

（通常的免责声明：性能考虑可能会凌驾于此建议之上。如果您有性能问题，请在决定解决方案之前进行衡量。试试BenchmarkDotNet，这很好！）

类最适合将复杂的操作和数据分组在一起这将在整个项目中发生变化；结构是更好的选择大多数情况下保持不变的简单对象和数据。除了它们的用途之外，它们在一个键上有根本的不同即变量之间传递或分配的方式。类是引用类型，这意味着它们由参考结构是值类型，这意味着它们是由价值

小心使用类。如果您有一些引用相同内存的游戏对象，修改其中一个将修改其他对象。

创建结构对象时，其所有数据都存储在没有引用或连接到其内存的对应变量地方这使得结构对于创建需要快速高效地复制，同时保留独立的身份。

ExampleStruct struct1= new ExampleStruct()
ExampleStruct struct2= struct1

修改结构2不会影响结构1。

基本上，创建结构是为了提高性能。但是，由于涉及到所有的复制，有时结构可能会更慢。如果结构有很多需要复制的变量，那么将其转换为类并传递引用可能会更快如果您有一个结构数组，那么数组本身就是堆上的一个对象，结构值包含在数组中。所以垃圾收集器只有一个对象需要考虑。如果数组超出范围，垃圾收集器可以在一个步骤中释放数组中的所有结构。如果代码的任何其他部分正在使用此数组中的结构，由于结构被复制，因此我们可以安全地释放数组本身及其内容。如果您有一个对象数组，那么数组本身和数组中的每个对象都是堆上的独立对象。每个对象都可以存储在堆的完全不同的部分，而代码的另一部分可能会引用这些对象。因此，当我们的数组超出范围时，我们无法立即释放数组。因为垃圾收集器必须单独考虑每个对象，并确保在取消分配之前没有对每个对象的引用。