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

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

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

我用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;
        }
    }

除了“它是一个值”的答案之外，使用结构的一个特定场景是当您知道有一组数据会导致垃圾收集问题，并且您有很多对象时。例如，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，只有当你知道自己在做什么和为什么时，才应该尝试。这里的默认值是类。

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

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

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

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

Eg.

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

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

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

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