.NET 中的 struct 和 class 有什么区别？

Question

.NET 中的 struct 和 class 有什么区别？

Answer 1

在 .NET 中，有两类类型，引用类型和值类型。

结构是值类型，类是引用类型。

一般的区别是引用类型存在于堆中，而值类型存在于内联中，也就是说，无论您在哪里定义变量或字段。

包含值类型的变量包含整个值类型值。 对于结构体，这意味着变量包含整个结构体及其所有字段。

包含引用类型的变量包含一个指针，或对实际值所在的内存中其他位置的引用。

这有一个好处，首先是：

• 值类型总是包含一个值
• 引用类型可以包含空引用，这意味着它们目前根本不引用任何内容

在内部，引用类型被实现为指针，知道这一点，并且知道变量赋值是如何工作的，还有其他行为模式：

• 将值类型变量的内容复制到另一个变量中，将整个内容复制到新变量中，使两者不同。 换句话说，复制后，对一个的更改不会影响另一个
• 将引用类型变量的内容复制到另一个变量中，复制引用，这意味着您现在有两个引用到相同的其他地方存储实际数据。 换句话说，在复制之后，更改一个引用中的数据似乎也会影响另一个引用，但这只是因为您实际上只是在两个地方查看相同的数据

当您声明变量或字段时，这两种类型的区别如下：

• 变量：值类型存在于堆栈中，引用类型作为指向实际内存所在的堆内存中某处的指针存在于堆栈中（但请注意Eric Lipperts 文章系列：堆栈是一个实现细节。）
• 类/结构字段：值类型完全位于类型内部，引用类型位于类型内部，作为指向实际内存所在的堆内存中某处的指针。

Answer 2

每个的简短摘要：

仅限课程：

• 可以支持继承
• 是引用（指针）类型
• 引用可以为空
• 每个新实例的内存开销

仅结构：

• 不能支持继承
• 是值类型
• 按值传递（如整数）
• 不能有空引用（除非使用 Nullable）
• 每个新实例没有内存开销 - 除非“装箱”

类和结构体：

• 复合数据类型通常用于包含一些具有某种逻辑关系的变量吗
• 可以包含方法和事件
• 可以支持接口

Answer 3

在 .NET 中，结构和类声明区分引用类型和值类型。

当您传递一个引用类型时，实际上只存储了一个。 所有访问实例的代码都在访问同一个。

当您传递一个值类型时，每个值类型都是一个副本。 所有代码都在自己的副本上工作。

这可以用一个例子来说明：

struct MyStruct 
{
    string MyProperty { get; set; }
}

void ChangeMyStruct(MyStruct input) 
{ 
   input.MyProperty = "new value";
}

...

// Create value type
MyStruct testStruct = new MyStruct { MyProperty = "initial value" }; 

ChangeMyStruct(testStruct);

// Value of testStruct.MyProperty is still "initial value"
// - the method changed a new copy of the structure.

对于一个班级来说，这会有所不同

class MyClass 
{
    string MyProperty { get; set; }
}

void ChangeMyClass(MyClass input) 
{ 
   input.MyProperty = "new value";
}

...

// Create reference type
MyClass testClass = new MyClass { MyProperty = "initial value" };

ChangeMyClass(testClass);

// Value of testClass.MyProperty is now "new value" 
// - the method changed the instance passed.

类可以什么都不是——引用可以指向一个空值。

结构是实际值——它们可以为空，但绝不为空。 出于这个原因，结构体总是有一个没有参数的默认构造函数——它们需要一个“起始值”。

Answer 4

结构体和类的区别：

• 结构是值类型，而类是引用类型。
• 结构存储在堆栈上，而类存储在堆上。
• 值类型在声明它们的内存中保存它们的值，但引用类型保存对对象内存的引用。
• 范围丢失后立即销毁值类型，而引用类型仅在范围丢失后销毁变量。 该对象稍后被垃圾收集器销毁。
• 当您将结构复制到另一个结构中时，会创建该结构的新副本，修改一个结构不会影响另一个结构的值。
• 当您将一个类复制到另一个类时，它只会复制引用变量。
• 两个引用变量都指向堆上的同一个对象。 更改一个变量会影响另一个参考变量。
• 结构不能有析构函数，但类可以有析构函数。
• 结构不能有显式的无参数构造函数，而类可以。 结构不支持继承，但类支持。 两者都支持从接口继承。
• 结构是密封型的。

Answer 5

从微软在类和结构之间的选择...

根据经验，框架中的大多数类型应该是类。 然而，在某些情况下，值类型的特性使其更适合使用结构体。

✓考虑一个结构而不是一个类：

• 如果该类型的实例很小且通常寿命很短，或者通常嵌入其他对象中。

X避免使用结构，除非该类型具有以下所有特征：

• 它在逻辑上表示单个值，类似于原始类型（int、double 等）。
• 它的实例大小低于 16 字节。
• 它是不可变的。 （无法更改）
• 它不必经常装箱。

Answer 6

除了其他答案中描述的所有差异之外：

1. 结构不能有显式的无参数构造函数，而类可以
2. 结构不能有析构函数，而类可以
3. 结构不能从另一个结构或类继承，而一个类可以从另一个类继承。 （结构和类都可以从接口实现。）

如果您正在观看解释所有差异的视频，您可以查看第 29 部分 - C# 教程 - C# 中的类和结构之间的差异。

Answer 7

我 ♥ 可视化，在这里我创建了一个来展示structs和classes之间的基本区别。

---

还有文字表示以防万一;)

+--------------------------------------------------+------+----------------------------------------------+
|                      Struct                      |      |                      Class                    |
+--------------------------------------------------+------+----------------------------------------------+
| - 1 per Thread.                                  |      | - 1 per application.                         |
|                                                  |      |                                              |
| - Holds value types.                             |      | - Holds reference types.                     |
|                                                  |      |                                              |
| - Types in the stack are positioned              |      | - No type ordering (data is fragmented).     |
|   using the LIFO principle.                      |      |                                              |
|                                                  |      |                                              |
| - Can't have a default constructor and/or        |      | - Can have a default constructor             |
|   finalizer(destructor).                         |      |   and/or finalizer.                          |
|                                                  |      |                                              |
| - Can be created with or without a new operator. |      | - Can be created only with a new operator.   |
|                                                  |      |                                              |
| - Can't derive from the class or struct          |  VS  | - Can have only one base class and/or        |
|   but can derive from the multiple interfaces.   |      |   derive from multiple interfaces.           |
|                                                  |      |                                              |
| - The data members can't be protected.           |      | - Data members can be protected.             |
|                                                  |      |                                              |
| - Function members can't be                      |      | - Function members can be                    |
|   virtual or abstract.                           |      |   virtual or abstract.                       |
|                                                  |      |                                              |
| - Can't have a null value.                       |      | - Can have a null value.                     |
|                                                  |      |                                              |
| - During an assignment, the contents are         |      | - Assignment is happening                    |
|   copied from one variable to another.           |      |   by reference.                              |
+--------------------------------------------------+------+----------------------------------------------+

---

有关更多信息，请查看以下内容：

• 类和结构（官方文档）。
• 在 Class 和 Struct 之间进行选择（官方文档）。

Answer 8

类的实例存储在托管堆上。 所有“包含”实例的变量只是对堆上实例的引用。 将对象传递给方法会导致传递引用的副本，而不是对象本身。

结构（从技术上讲，值类型）存储在它们使用的任何地方，很像原始类型。 运行时可以随时复制内容，而无需调用定制的复制构造函数。 将值类型传递给方法涉及复制整个值，同样无需调用任何可自定义的代码。

C++/CLI 名称可以更好地区分：“ref class”是第一个描述的类，“value class”是第二个描述的类。 C# 中使用的关键字“class”和“struct”只是必须学习的东西。

Answer 9

	结构	班级
类型	值类型	引用类型
在哪里	在包含类型中的堆栈/内联	在堆上
解除分配	堆栈展开/包含类型被释放	垃圾收集
数组	内联，元素是值类型的实际实例	出乎意料的是，元素只是对驻留在堆上的引用类型实例的引用
德尔成本	廉价的分配-解除分配	昂贵的分配-解除分配
内存使用情况	转换为引用类型或它们实现的接口之一时被装箱， 转换回值类型时取消装箱 （负面影响，因为盒子是在堆上分配并被垃圾收集的对象）	没有装箱拆箱
作业	复制整个数据	复制参考
更改为实例	不影响其任何副本	影响指向实例的所有引用
可变性	应该是不可变的	可变的
人口	在某些情况下	框架中的大多数类型应该是类
寿命	短暂的	长寿
析构函数	不能有	可以有
遗产	只能从接口	全力支持
多态性	不	是的
密封	是的	当有sealed关键字 (C#) 或Sealed属性 (F#)
构造函数	不能有显式的无参数构造函数	任何构造函数
空分配	当用可空问号标记时	是（在 C# 8+ 和 F# 5+ 1中用可空问号标记时）
抽象的	不	当有abstract关键字 (C#) 或AbstractClass属性 (F#)
成员访问修饰符	public , private , internal	public 、 protected 、 internal 、 protected internal 、 private protected

¹在 F# 中不鼓励使用null ，而是使用Option类型。

Answer 10

要添加到其他答案中，有一个值得注意的根本区别，那就是数据如何存储在数组中，因为这会对性能产生重大影响。

• 对于结构体，数组包含结构体的实例
• 对于一个类，该数组包含一个指向该类在内存中其他地方的实例的指针

所以一个结构数组在内存中看起来像这样

[struct][struct][struct][struct][struct][struct][struct][struct]

而一系列类看起来像这样

[pointer][pointer][pointer][pointer][pointer][pointer][pointer][pointer]

对于类数组，您感兴趣的值不会存储在数组中，而是存储在内存中的其他地方。

对于绝大多数应用程序，这种差异并不重要，但是，在高性能代码中，这将影响内存中数据的局部性，并对 CPU 缓存的性能产生很大影响。 当您可以/应该使用结构体时使用类将大大增加 CPU 上的缓存未命中数。

现代 CPU 所做的最慢的事情不是处理数字，而是从内存中获取数据，并且 L1 缓存命中比从 RAM 读取数据快很多倍。

这是您可以测试的一些代码。 在我的机器上，遍历类数组需要比结构数组长约 3 倍的时间。

    private struct PerformanceStruct
    {
        public int i1;
        public int i2;
    }

    private class PerformanceClass
    {
        public int i1;
        public int i2;
    }

    private static void DoTest()
    {
        var structArray = new PerformanceStruct[100000000];
        var classArray = new PerformanceClass[structArray.Length];

        for (var i = 0; i < structArray.Length; i++)
        {
            structArray[i] = new PerformanceStruct();
            classArray[i] = new PerformanceClass();
        }

        long total = 0;
        var sw = new Stopwatch();
        sw.Start();
        for (var loops = 0; loops < 100; loops++)
        for (var i = 0; i < structArray.Length; i++)
        {
            total += structArray[i].i1 + structArray[i].i2;
        }

        sw.Stop();
        Console.WriteLine($"Struct Time: {sw.ElapsedMilliseconds}");
        sw = new Stopwatch();
        sw.Start();
        for (var loops = 0; loops < 100; loops++)
        for (var i = 0; i < classArray.Length; i++)
        {
            total += classArray[i].i1 + classArray[i].i2;
        }

        Console.WriteLine($"Class Time: {sw.ElapsedMilliseconds}");
    }

Answer 11

结构与类

结构是值类型，因此存储在堆栈中，而类是引用类型，存储在堆中。

结构不支持继承和多态，但类同时支持两者。

默认情况下，所有结构成员都是公共的，但类成员本质上是私有的。

由于结构是值类型，我们不能将 null 分配给结构对象，但对于类则不是这种情况。

Answer 12

好吧，对于初学者来说，结构是按值而不是按引用传递的。 结构适用于相对简单的数据结构，而类通过多态和继承从架构的角度来看具有更大的灵活性。

其他人可能会提供比我更多的细节，但是当我想要的结构很简单时，我会使用结构。

Answer 13

只是为了使它完整，使用Equals方法时还有一个区别，该方法由所有类和结构继承。

假设我们有一个类和一个结构：

class A{
  public int a, b;
}
struct B{
  public int a, b;
}

在 Main 方法中，我们有 4 个对象。

static void Main{
  A c1 = new A(), c2 = new A();
  c1.a = c1.b = c2.a = c2.b = 1;
  B s1 = new B(), s2 = new B();
  s1.a = s1.b = s2.a = s2.b = 1;
}

然后：

s1.Equals(s2) // true
s1.Equals(c1) // false
c1.Equals(c2) // false
c1 == c2 // false

因此，结构适用于类似数字的对象，例如点（保存 x 和 y 坐标）。 课程适合其他人。 即使两个人有相同的名字、身高、体重……，他们仍然是两个人。

Answer 14

如前所述：类是引用类型，而结构是具有所有后果的值类型。

根据规则框架设计指南建议在以下情况下使用结构而不是类：

• 它的实例大小低于 16 字节
• 它在逻辑上表示单个值，类似于原始类型（int、double 等）
• 它是不可变的
• 它不必经常装箱

Answer 15

1. 在类中声明的事件通过 lock(this) 自动锁定其 += 和 -= 访问，以使其线程安全（静态事件锁定在类的类型上）。 在结构中声明的事件不会自动锁定其 += 和 -= 访问。 结构的 lock(this) 不起作用，因为您只能锁定引用类型表达式。

2. 创建结构体实例不会导致垃圾回收（除非构造函数直接或间接创建引用类型实例），而创建引用类型实例会导致垃圾回收。

3. 结构体总是有一个内置的公共默认构造函数。

    class DefaultConstructor { static void Eg() { Direct yes = new Direct(); // Always compiles OK InDirect maybe = new InDirect(); // Compiles if constructor exists and is accessible //... } }

   这意味着结构始终是可实例化的，而类可能不是，因为它的所有构造函数都可能是私有的。

    class NonInstantiable { private NonInstantiable() // OK { } } struct Direct { private Direct() // Compile-time error { } }

4. 结构不能有析构函数。 析构函数只是伪装的 object.Finalize 的覆盖，作为值类型的结构不受垃圾收集的影响。

    struct Direct { ~Direct() {} // Compile-time error } class InDirect { ~InDirect() {} // Compiles OK } And the CIL for ~Indirect() looks like this: .method family hidebysig virtual instance void Finalize() cil managed { // ... } // end of method Indirect::Finalize

5. 结构是隐式密封的，类不是。
   结构不能是抽象的，类可以。
   结构不能在其构造函数中调用 :base() 而没有显式基类的类可以。
   一个结构不能扩展另一个类，一个类可以。
   结构不能声明类可以的受保护成员（例如，字段、嵌套类型）。
   结构不能声明抽象函数成员，抽象类可以。
   结构不能声明虚函数成员，类可以。
   结构不能声明密封的函数成员，类可以。
   结构不能声明覆盖函数成员，类可以。
   此规则的一个例外是结构可以覆盖 System.Object 的虚拟方法，即 Equals()、GetHashCode() 和 ToString()。
   

Answer 16

除了访问说明符的基本区别之外，我想补充一些主要的区别，包括上面提到的几个，并带有输出的代码示例，这将使参考和价值更加清晰

结构：

• 是值类型，不需要堆分配。
• 内存分配不同，存放在栈中
• 适用于小型数据结构
• 影响性能，当我们给方法传值的时候，我们传的是整个数据结构，都传到了栈上。
• 构造函数简单地返回结构值本身（通常在堆栈上的临时位置），然后根据需要复制该值
• 每个变量都有自己的数据副本，对一个的操作不可能影响另一个。
• 不支持用户指定的继承，它们隐式继承自类型对象

班级：

• 引用类型值
• 存储在堆中
• 存储对动态分配对象的引用
• 使用 new 运算符调用构造函数，但不会在堆上分配内存
• 多个变量可能引用同一个对象
• 对一个变量的操作可能会影响另一个变量引用的对象

代码示例

    static void Main(string[] args)
    {
        //Struct
        myStruct objStruct = new myStruct();
        objStruct.x = 10;
        Console.WriteLine("Initial value of Struct Object is: " + objStruct.x);
        Console.WriteLine();
        methodStruct(objStruct);
        Console.WriteLine();
        Console.WriteLine("After Method call value of Struct Object is: " + objStruct.x);
        Console.WriteLine();

        //Class
        myClass objClass = new myClass(10);
        Console.WriteLine("Initial value of Class Object is: " + objClass.x);
        Console.WriteLine();
        methodClass(objClass);
        Console.WriteLine();
        Console.WriteLine("After Method call value of Class Object is: " + objClass.x);
        Console.Read();
    }
    static void methodStruct(myStruct newStruct)
    {
        newStruct.x = 20;
        Console.WriteLine("Inside Struct Method");
        Console.WriteLine("Inside Method value of Struct Object is: " + newStruct.x);
    }
    static void methodClass(myClass newClass)
    {
        newClass.x = 20;
        Console.WriteLine("Inside Class Method");
        Console.WriteLine("Inside Method value of Class Object is: " + newClass.x);
    }
    public struct myStruct
    {
        public int x;
        public myStruct(int xCons)
        {
            this.x = xCons;
        }
    }
    public class myClass
    {
        public int x;
        public myClass(int xCons)
        {
            this.x = xCons;
        }
    }

输出

结构对象的初始值为：10

Inside Struct Method Struct Object的Inside Method值为：20

结构对象的方法调用后值为：10

类对象的初始值为：10

Inside Class Method Class Object的Inside Method值为：20

类对象的方法调用后值为：20

在这里你可以清楚地看到按值调用和按引用调用的区别。

Answer 17

有一个“类与结构”难题的有趣案例 - 当您需要从方法返回多个结果时的情况：选择要使用的结果。 如果您知道 ValueTuple 的故事 - 您知道添加 ValueTuple (struct) 是因为它应该比 Tuple (class) 更有效。 但它在数字上意味着什么？ 两个测试：一个是具有 2 个字段的结构/类，另一个是具有 8 个字段的结构/类（维度超过 4 - 就处理器滴答而言，类应该变得比结构更有效，但当然也应该考虑 GC 负载）。

PS 特定案例“结构体或带集合的类”的另一个基准是： https ://stackoverflow.com/a/45276657/506147

BenchmarkDotNet=v0.10.10, OS=Windows 10 Redstone 2 [1703, Creators Update] (10.0.15063.726)
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233540 Hz, Resolution=309.2586 ns, Timer=TSC
.NET Core SDK=2.0.3
  [Host] : .NET Core 2.0.3 (Framework 4.6.25815.02), 64bit RyuJIT
  Clr    : .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.2115.0
  Core   : .NET Core 2.0.3 (Framework 4.6.25815.02), 64bit RyuJIT


            Method |  Job | Runtime |     Mean |     Error |    StdDev |      Min |      Max |   Median | Rank |  Gen 0 | Allocated |
------------------ |----- |-------- |---------:|----------:|----------:|---------:|---------:|---------:|-----:|-------:|----------:|
  TestStructReturn |  Clr |     Clr | 17.57 ns | 0.1960 ns | 0.1834 ns | 17.25 ns | 17.89 ns | 17.55 ns |    4 | 0.0127 |      40 B |
   TestClassReturn |  Clr |     Clr | 21.93 ns | 0.4554 ns | 0.5244 ns | 21.17 ns | 23.26 ns | 21.86 ns |    5 | 0.0229 |      72 B |
 TestStructReturn8 |  Clr |     Clr | 38.99 ns | 0.8302 ns | 1.4097 ns | 37.36 ns | 42.35 ns | 38.50 ns |    8 | 0.0127 |      40 B |
  TestClassReturn8 |  Clr |     Clr | 23.69 ns | 0.5373 ns | 0.6987 ns | 22.70 ns | 25.24 ns | 23.37 ns |    6 | 0.0305 |      96 B |
  TestStructReturn | Core |    Core | 12.28 ns | 0.1882 ns | 0.1760 ns | 11.92 ns | 12.57 ns | 12.30 ns |    1 | 0.0127 |      40 B |
   TestClassReturn | Core |    Core | 15.33 ns | 0.4343 ns | 0.4063 ns | 14.83 ns | 16.44 ns | 15.31 ns |    2 | 0.0229 |      72 B |
 TestStructReturn8 | Core |    Core | 34.11 ns | 0.7089 ns | 1.4954 ns | 31.52 ns | 36.81 ns | 34.03 ns |    7 | 0.0127 |      40 B |
  TestClassReturn8 | Core |    Core | 17.04 ns | 0.2299 ns | 0.2150 ns | 16.68 ns | 17.41 ns | 16.98 ns |    3 | 0.0305 |      96 B |

代码测试：

using System;
using System.Text;
using System.Collections.Generic;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Attributes.Columns;
using BenchmarkDotNet.Attributes.Exporters;
using BenchmarkDotNet.Attributes.Jobs;
using DashboardCode.Routines.Json;

namespace Benchmark
{
    //[Config(typeof(MyManualConfig))]
    [RankColumn, MinColumn, MaxColumn, StdDevColumn, MedianColumn]
    [ClrJob, CoreJob]
    [HtmlExporter, MarkdownExporter]
    [MemoryDiagnoser]
    public class BenchmarkStructOrClass
    {
        static TestStruct testStruct = new TestStruct();
        static TestClass testClass = new TestClass();
        static TestStruct8 testStruct8 = new TestStruct8();
        static TestClass8 testClass8 = new TestClass8();
        [Benchmark]
        public void TestStructReturn()
        {
            testStruct.TestMethod();
        }

        [Benchmark]
        public void TestClassReturn()
        {
            testClass.TestMethod();
        }


        [Benchmark]
        public void TestStructReturn8()
        {
            testStruct8.TestMethod();
        }

        [Benchmark]
        public void TestClassReturn8()
        {
            testClass8.TestMethod();
        }

        public class TestStruct
        {
            public int Number = 5;
            public struct StructType<T>
            {
                public T Instance;
                public List<string> List;
            }

            public int TestMethod()
            {
                var s = Method1(1);
                return s.Instance;
            }

            private StructType<int> Method1(int i)
            {
                return Method2(++i);
            }

            private StructType<int> Method2(int i)
            {
                return Method3(++i);
            }

            private StructType<int> Method3(int i)
            {
                return Method4(++i);
            }

            private StructType<int> Method4(int i)
            {
                var x = new StructType<int>();
                x.List = new List<string>();
                x.Instance = ++i;
                return x;
            }
        }

        public class TestClass
        {
            public int Number = 5;
            public class ClassType<T>
            {
                public T Instance;
                public List<string> List;
            }

            public int TestMethod()
            {
                var s = Method1(1);
                return s.Instance;
            }

            private ClassType<int> Method1(int i)
            {
                return Method2(++i);
            }

            private ClassType<int> Method2(int i)
            {
                return Method3(++i);
            }

            private ClassType<int> Method3(int i)
            {
                return Method4(++i);
            }

            private ClassType<int> Method4(int i)
            {
                var x = new ClassType<int>();
                x.List = new List<string>();
                x.Instance = ++i;
                return x;
            }
        }

        public class TestStruct8
        {
            public int Number = 5;
            public struct StructType<T>
            {
                public T Instance1;
                public T Instance2;
                public T Instance3;
                public T Instance4;
                public T Instance5;
                public T Instance6;
                public T Instance7;
                public List<string> List;
            }

            public int TestMethod()
            {
                var s = Method1(1);
                return s.Instance1;
            }

            private StructType<int> Method1(int i)
            {
                return Method2(++i);
            }

            private StructType<int> Method2(int i)
            {
                return Method3(++i);
            }

            private StructType<int> Method3(int i)
            {
                return Method4(++i);
            }

            private StructType<int> Method4(int i)
            {
                var x = new StructType<int>();
                x.List = new List<string>();
                x.Instance1 = ++i;
                return x;
            }
        }

        public class TestClass8
        {
            public int Number = 5;
            public class ClassType<T>
            {
                public T Instance1;
                public T Instance2;
                public T Instance3;
                public T Instance4;
                public T Instance5;
                public T Instance6;
                public T Instance7;
                public List<string> List;
            }

            public int TestMethod()
            {
                var s = Method1(1);
                return s.Instance1;
            }

            private ClassType<int> Method1(int i)
            {
                return Method2(++i);
            }

            private ClassType<int> Method2(int i)
            {
                return Method3(++i);
            }

            private ClassType<int> Method3(int i)
            {
                return Method4(++i);
            }

            private ClassType<int> Method4(int i)
            {
                var x = new ClassType<int>();
                x.List = new List<string>();
                x.Instance1 = ++i;
                return x;
            }
        }
    }
}

Answer 18

结构是实际值——它们可以为空，但不能为空

这是真的，但也要注意，从 .NET 2 开始，结构支持 Nullable 版本，C# 提供了一些语法糖以使其更易于使用。

int? value = null;
value  = 1;

Answer 19

原始值类型或结构类型的每个变量或字段都包含该类型的唯一实例，包括其所有字段（公共和私有）。 相比之下，引用类型的变量或字段可能为空，或者可能引用一个对象，存储在别处，也可能存在任意数量的其他引用。 结构体的字段将存储在与该结构体类型的变量或字段相同的位置，它可能在堆栈上，也可能是另一个堆对象的一部分。

创建原始值类型的变量或字段将使用默认值创建它； 创建结构类型的变量或字段将创建一个新实例，以默认方式创建其中的所有字段。 创建引用类型的新实例将首先以默认方式创建其中的所有字段，然后根据类型运行可选的附加代码。

将原始类型的一个变量或字段复制到另一个将复制该值。 将结构类型的一个变量或字段复制到另一个将把前一个实例的所有字段（公共和私有）复制到后一个实例。 将一个引用类型的变量或字段复制到另一个将导致后者引用与前者相同的实例（如果有）。

需要注意的是，在某些语言（如 C++）中，类型的语义行为与其存储方式无关，但在 .NET 中并非如此。 如果一个类型实现了可变值语义，将该类型的一个变量复制到另一个将第一个的属性复制到另一个实例，由第二个引用，并使用第二个的成员来改变它会导致第二个实例被更改，但不是第一个。 如果一个类型实现了可变引用语义，将一个变量复制到另一个变量并使用第二个的成员来改变对象会影响第一个变量引用的对象； 具有不可变语义的类型不允许突变，因此复制是创建一个新实例还是创建另一个对第一个实例的引用在语义上无关紧要。

在 .NET 中，值类型可以实现上述任何语义，前提是它们的所有字段都可以这样做。 但是，引用类型只能实现可变引用语义或不可变语义； 具有可变引用类型字段的值类型仅限于实现可变引用语义或奇怪的混合语义。