.NET 中的结构和类有什么区别？
Keith
问问题
450746 次
19 回答
1188
在 .NET 中，有两类类型，引用类型和值类型。
结构是值类型，类是引用类型。
一般的区别是引用类型存在于堆上，而值类型存在于内联，也就是说，无论它是你的变量或字段的定义。
包含值类型的变量包含整个值类型值。对于结构，这意味着变量包含整个结构及其所有字段。
包含引用类型的变量包含一个指针，或对内存中实际值所在的其他位置的引用。
这有一个好处，首先是：
- 值类型总是包含一个值
- 引用类型可以包含一个null引用，这意味着它们现在根本不引用任何东西
在内部，引用类型被实现为指针，并且知道这一点并知道变量赋值是如何工作的，还有其他行为模式：
- 将值类型变量的内容复制到另一个变量中，将整个内容复制到新变量中，使两者不同。换句话说，在复制之后，对一个的更改不会影响另一个
- 将引用类型变量的内容复制到另一个变量中，复制引用，这意味着您现在有两个对相同的引用在其他地方存储实际数据。换句话说，在复制之后，更改一个引用中的数据似乎也会影响另一个引用，但这只是因为您实际上只是在两个地方查看相同的数据
当您声明变量或字段时，这两种类型的区别如下：
- 变量：值类型存在于堆栈中，引用类型存在于堆栈中，作为指向实际内存所在的堆内存中某处的指针（尽管请注意Eric Lipperts 文章系列：堆栈是一个实现细节。）
- class/struct-field：值类型完全存在于类型内部，引用类型存在于类型内部，作为指向实际内存所在的堆内存中某处的指针。
于 2008-08-16T18:41:38.037 回答
247
每个的简短摘要：
仅限课程：
- 可以支持继承
- 是引用（指针）类型
- 引用可以为空
- 每个新实例都有内存开销
仅结构：
- 不支持继承
- 是值类型
- 按值传递（如整数）
- 不能有空引用（除非使用 Nullable）
- 每个新实例都没有内存开销 - 除非“装箱”
类和结构：
- 复合数据类型通常用于包含一些具有某种逻辑关系的变量吗
- 可以包含方法和事件
- 可支持接口
于 2008-10-04T22:07:32.267 回答
57
结构和类之间的区别：
- 结构是值类型，而类是引用类型。
- 结构存储在堆栈上，而类存储在堆上。
- 值类型将它们的值保存在声明它们的内存中，但引用类型保存对内存中对象的引用。
- 值类型在范围丢失后立即销毁，而引用类型仅在范围丢失后销毁变量。该对象稍后被垃圾收集器销毁。
- 当您将一个结构复制到另一个结构中时，会创建该结构的一个新副本。修改后的结构不会影响另一个结构的值。
- 当您将一个类复制到另一个类时，它只复制引用变量。
- 两个引用变量都指向堆上的同一个对象。对一个变量所做的更改将影响另一个参考变量。
- 结构不能有析构函数，但类可以有析构函数。
- 结构不能有显式的无参数构造函数，而类可以。结构不支持继承，但类支持。两者都支持从接口继承。
- 结构为密封型。
于 2018-01-05T01:58:43.920 回答
54
在 .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.
类可以什么都不是——引用可以指向一个空值。
结构是实际值——它们可以为空，但不能为空。出于这个原因，结构总是有一个没有参数的默认构造函数——它们需要一个“起始值”。
于 2008-08-16T08:30:38.083 回答
33
于 2017-05-14T19:58:36.697 回答
29
我 ♥ 可视化，在这里我创建了一个来展示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 之间进行选择（官方文档）。
于 2020-06-18T16:38:10.040 回答
24
除了其他答案中描述的所有差异之外：
- 结构不能有显式的无参数构造函数，而类可以
- 结构不能有析构函数，而类可以
- 结构不能从另一个结构或类继承，而一个类可以从另一个类继承。（结构和类都可以从接口实现。）
如果您正在观看解释所有差异的视频，您可以查看第 29 部分 - C# 教程 - C# 中类和结构之间的差异。
于 2012-06-14T16:57:23.073 回答
21
| 结构 | 班级 | |
|---|---|---|
| 类型 | 值类型 | 参考型 |
| 在哪里 | 在包含类型的堆栈/内联 | 堆上 |
| 重新分配 | 堆栈展开/包含类型被释放 | 垃圾收集 |
| 数组 | 内联，元素是值类型的实际实例 | 不合时宜，元素只是对驻留在堆上的引用类型的实例的引用 |
| 德尔成本 | 廉价分配-解除分配 | 昂贵的分配-解除分配 |
| 内存使用情况 | 转换为引用类型或它们实现的接口之一 时装箱，转换回值类型时取消 装箱（负面影响，因为框是在堆上分配并被垃圾回收的对象） |
没有装箱-拆箱 |
| 作业 | 复制整个数据 | 复制参考 |
| 更改为实例 | 不影响其任何副本 | 影响所有指向实例的引用 |
| 可变性 | 应该是不可变的 | 可变的 |
| 人口 | 在某些情况下 | 框架中的大多数类型应该是类 |
| 寿命 | 昙花一现 | 长寿 |
| 析构函数 | 不能有 | 可以有 |
| 遗产 | 仅来自一个界面 | 全力支持 |
| 多态性 | 不 | 是的 |
| 密封 | 是的 | 何时有sealed关键字 (C#) 或Sealed属性 (F#) |
| 构造函数 | 不能有显式的无参数构造函数 | 任何构造函数 |
| 空赋值 | 标有可空问号时 | 是（在 C# 8+ 和 F# 5+ 1中标有可为空的问号时） |
| 抽象的 | 不 | 何时有abstract关键字 (C#) 或AbstractClass属性 (F#) |
| 成员访问修饰符 | public, private,internal |
public, protected, internal, protected internal,private protected |
1null F# 中不鼓励使用，请改用Option类型。
于 2018-07-26T10:43:00.110 回答
18
类的实例存储在托管堆上。所有“包含”实例的变量都只是对堆上实例的引用。将对象传递给方法会导致传递引用的副本，而不是对象本身。
结构（技术上是值类型）存储在任何使用它们的地方，就像原始类型一样。运行时可以随时复制内容，而无需调用自定义的复制构造函数。将值类型传递给方法涉及复制整个值，同样无需调用任何可定制的代码。
通过 C++/CLI 名称可以更好地区分：“ref class”是第一个描述的类，“value class”是第二个描述的类。C# 使用的关键字“class”和“struct”只是必须学习的东西。
于 2008-08-16T12:16:50.450 回答
14
结构与类
结构是值类型，因此它存储在堆栈中，而类是引用类型并存储在堆中。
结构不支持继承和多态，但类支持两者。
默认情况下，所有结构成员都是公共的，但类成员默认情况下是私有的。
由于结构是值类型，我们不能将 null 分配给结构对象，但对于类则不是这样。
于 2009-11-06T08:02:48.280 回答
14
为了补充其他答案，有一个值得注意的根本区别，那就是数据如何存储在数组中，因为这会对性能产生重大影响。
- 使用结构，数组包含结构的实例
- 对于类，数组包含指向内存中其他位置的类实例的指针
所以一个结构数组在内存中看起来像这样
[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}");
}
于 2015-08-25T13:00:07.357 回答
9
好吧，对于初学者来说，结构是通过值而不是通过引用传递的。结构适用于相对简单的数据结构，而从架构的角度来看，类通过多态性和继承具有更大的灵活性。
其他人可能会给你比我更多的细节，但是当我想要的结构很简单时，我会使用结构。
于 2008-08-16T08:27:14.457 回答
8
只是为了让它完整，使用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 坐标）。课程适合其他人。即使两个人的名字、身高、体重……相同，他们仍然是两个人。
于 2017-08-02T13:34:43.583 回答
6
在类中声明的事件通过 lock(this) 自动锁定其 += 和 -= 访问，以使它们成为线程安全的（静态事件被锁定在类的类型上）。在结构中声明的事件不会自动锁定其 += 和 -= 访问权限。结构的 lock(this) 不起作用，因为您只能锁定引用类型表达式。
创建结构实例不会导致垃圾回收（除非构造函数直接或间接创建引用类型实例），而创建引用类型实例会导致垃圾回收。
结构始终具有内置的公共默认构造函数。
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 { } }结构不能有析构函数。析构函数只是 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结构是隐式密封的，类不是。
结构不能是抽象的，类可以。
结构不能在其构造函数中调用 : base() 而没有显式基类的类可以。
一个结构不能扩展另一个类，一个类可以。
结构不能声明类可以声明的受保护成员（例如，字段、嵌套类型）。
结构不能声明抽象函数成员，抽象类可以。
结构不能声明虚函数成员，类可以。
结构不能声明密封函数成员，类可以。
结构不能声明覆盖函数成员，类可以。
此规则的一个例外是结构可以覆盖 System.Object 的虚拟方法，即 Equals()、GetHashCode() 和 ToString()。
于 2011-07-25T05:24:46.203 回答
5
如前所述：类是引用类型，而结构是具有所有后果的值类型。
作为规则框架设计指南建议在以下情况下使用结构而不是类：
- 它的实例大小小于 16 字节
- 它在逻辑上表示单个值，类似于原始类型（int、double 等）
- 它是不可变的
- 不必经常装箱
于 2015-09-23T11:32:37.447 回答
4
除了访问说明符的基本区别，以及上面提到的几个，我想补充一些主要的区别，包括上面提到的几个和输出的代码示例，这将使参考和价值更加清晰
结构：
- 是值类型，不需要堆分配。
- 内存分配不同，存放在栈中
- 适用于小型数据结构
- 影响性能，当我们将值传递给方法时，我们将整个数据结构传递给堆栈。
- 构造函数只返回结构值本身（通常在堆栈上的临时位置），然后根据需要复制该值
- 每个变量都有自己的数据副本，对一个变量的操作不可能影响另一个变量。
- 不支持用户指定的继承，它们隐式继承自类型对象
班级：
- 引用类型值
- 存储在堆中
- 存储对动态分配对象的引用
- 使用 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 Inside Method Struct Object 的值为：20
结构对象的方法调用后值为：10
类对象的初始值为：10
类对象内部方法的内部方法值为：20
类对象的方法调用后值为：20
在这里您可以清楚地看到按值调用和按引用调用之间的区别。
于 2014-05-29T09:45:03.117 回答
3
有一个有趣的“类 vs 结构”难题的案例 - 当您需要从方法返回多个结果时：选择使用哪个。如果你知道 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;
}
}
}
}
于 2017-12-18T08:21:36.527 回答
2
结构是实际值 - 它们可以为空但绝不为空
这是真的，但也请注意，从 .NET 2 开始，结构支持 Nullable 版本，并且 C# 提供了一些语法糖以使其更易于使用。
int? value = null;
value = 1;
于 2008-08-16T14:03:02.873 回答
1
原始值类型或结构类型的每个变量或字段都包含该类型的唯一实例，包括其所有字段（公共和私有）。相比之下，引用类型的变量或字段可能为空，或者可能引用存储在其他地方的对象，也可能存在任何数量的其他引用。结构的字段将与该结构类型的变量或字段存储在同一位置，这些变量或字段可能位于堆栈上，也可能是另一个堆对象的一部分。
创建原始值类型的变量或字段将使用默认值创建它；创建结构类型的变量或字段将创建一个新实例，并以默认方式创建其中的所有字段。创建引用类型的新实例将首先以默认方式创建其中的所有字段，然后根据类型运行可选的附加代码。
将原始类型的一个变量或字段复制到另一个将复制该值。将结构类型的一个变量或字段复制到另一个会将前一个实例的所有字段（公共和私有）复制到后一个实例。将引用类型的一个变量或字段复制到另一个将导致后者引用与前者相同的实例（如果有）。
需要注意的是，在某些语言（如 C++）中，类型的语义行为与其存储方式无关，但对于 .NET 而言并非如此。如果一个类型实现了可变值语义，则将该类型的一个变量复制到另一个变量会将第一个变量的属性复制到另一个实例，由第二个实例引用，并使用第二个实例的成员对其进行变异将导致第二个实例被更改，但不是第一个。如果一个类型实现了可变引用语义，将一个变量复制到另一个变量并使用第二个变量的成员来改变对象将影响第一个变量引用的对象；具有不可变语义的类型不允许突变，因此复制是否创建新实例或创建对第一个实例的另一个引用在语义上并不重要。
在 .NET 中，值类型可以实现上述任何语义，前提是它们的所有字段都可以这样做。然而，引用类型只能实现可变引用语义或不可变语义；具有可变引用类型字段的值类型仅限于实现可变引用语义或奇怪的混合语义。
于 2011-12-02T00:10:15.807 回答