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

结构不能具有显式无参数构造函数，而类可以结构不能有析构函数，而类可以结构不能从其他结构或类继承，而类可以从其他类继承。（结构和类都可以从接口实现。）

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

类中声明的事件通过锁（this）自动锁定其+=和-=访问，以使其线程安全（静态事件根据类的类型锁定）。结构中声明的事件没有自动锁定其+=和-=访问。结构的锁（this）无法工作，因为只能锁定引用类型表达式。创建结构实例不能导致垃圾收集（除非构造函数直接或间接创建引用类型实例），而创建引用类型的实例会导致垃圾收集。结构始终具有内置的公共默认构造函数。类DefaultConstructor{静态空隙Eg（）{直接yes=新的直接（）；//始终编译正常InDirect可能=新InDirect（）；//如果构造函数存在且可访问，则编译//...}}这意味着结构总是可实例化的，而类可能不是，因为它的所有构造函数都可以是私有的。类不可实例化{private NonInstantiable（）//确定{}}结构Direct{private Direct（）//编译时错误{}}结构不能有析构函数。析构函数只是对象的重写。伪装完成，结构作为值类型，不受垃圾收集的影响。结构Direct{~Direct（）｛｝//编译时错误}InDirect类{~InDirect（）｛｝//编译正常}~Indirect（）的CIL如下所示：.method家族hidebysig虚拟实例无效Finalize（）cil已管理{// ...}//方法结束间接：：Finalize结构是隐式密封的，类不是。结构不能是抽象的，类可以。结构不能在其构造函数中调用：base（），而没有显式基类的类可以。结构不能扩展另一个类，类可以。结构不能声明类可以声明的受保护成员（例如，字段、嵌套类型）。结构不能声明抽象函数成员，抽象类可以。结构不能声明虚函数成员，类可以。结构不能声明密封的函数成员，类可以。结构不能声明重写函数成员，类可以。此规则的一个例外是，结构可以重写System.Object的虚拟方法，即Equal（）、GetHashCode（）和ToString（）。

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

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

int? value = null;
value  = 1;

除了其他答案之外，还有一个基本的区别值得注意，那就是数据如何存储在数组中，因为这会对性能产生重大影响。

对于结构，数组包含结构的实例对于类，数组包含指向内存中其他位置的类实例的指针

因此，内存中的结构数组如下所示

[结构][结构]〔结构〕〔结构〕

而类数组看起来像这样

指针

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

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

现代CPU做的最慢的事情不是处理数字，而是从内存中提取数据，一级缓存命中速度比从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}");
    }

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

以及文本表示，以防万一；）

+--------------------------------------------------+------+----------------------------------------------+
|                      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.                              |
+--------------------------------------------------+------+----------------------------------------------+

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

类和结构（官方文档）。在类和结构之间选择（官方文档）。

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

结构不能具有显式无参数构造函数，而类可以结构不能有析构函数，而类可以结构不能从其他结构或类继承，而类可以从其他类继承。（结构和类都可以从接口实现。）

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