无论何时：

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

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

我用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#语言规范：

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

这是一条基本规则。

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

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#中的结构仅用于数据保存。结构比类占用更少的RAM，并且垃圾收集器更容易收集。但当您在结构中使用函数时，编译器实际上采用的结构与类/对象非常相似，所以如果您想要使用函数，请使用类/对象。

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

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