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

类可以是空的-引用可以指向空。

结构是实际值-它们可以为空，但决不能为空。因此，结构总是有一个没有参数的默认构造函数——它们需要一个“起始值”。

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

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

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

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

类可以是空的-引用可以指向空。

结构是实际值-它们可以为空，但决不能为空。因此，结构总是有一个没有参数的默认构造函数——它们需要一个“起始值”。

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

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

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

这是正确的，但是也要注意，从.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}");
    }