类中声明的事件通过锁（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（）。

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

根据经验，框架中的大多数类型应该是类。然而，在某些情况下值类型的特性使其更适合使用结构。✓ 考虑结构而不是类：如果该类型的实例很小并且通常很短，或者通常嵌入在其他对象中。X避免结构，除非该类型具有以下所有属性特点：它在逻辑上表示单个值，类似于原始类型（int、double等）。它的实例大小小于16字节。它是不可变的。（无法更改）它不必经常装箱。

类中声明的事件通过锁（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（）。

结构和类别之间的差异：

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

除了访问说明符的基本区别，以及上面提到的几个区别之外，我还想添加一些主要区别，包括上面提到的一些区别，以及带有输出的代码示例，这将提供对引用和值的更清晰的了解

结构：

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

类别：

参考类型值存储在堆中存储对动态分配对象的引用构造函数是用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;
        }
    }

输出

Struct Object的初始值为：10

内部结构方法Struct对象的内部方法值为：20

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

类对象的初始值为：10

内部类方法类对象的内部方法值为：20

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

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

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

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

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

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

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