C# 类型基础——你可能忽略的技术细节

引言 　　本文之初的目的是讲述设计模式中的 PRototype(原型)模式，但是如果想较清楚地弄明白这个模式，需要了解对象克隆(Object Clone)，Clone 其实也就是对象复制。复制又分为了浅度复制(Shallow Copy)和 深度复制(Deep Copy)，浅度复制 和 深度复制又是以 如何复制引用类型成员来划分的。由此又引出了 引用类型 和 值类型，以及相关的对象判等、装箱、拆箱等基础知识。

　　于是我干脆新起一篇，从最基础的类型开始自底向上写起了。我仅仅想将对于这个主题的理解表述出来，一是总结和复习，二是交流经验，或许有地方我理解的有偏差，希望指正。如果前面基础的内容对你来说过于简单，可以跳跃阅读。

值类型 和 引用类型 　　我们先简单回顾一下 C#中的类型系统。C# 中的类型一共分为两类，一类是值类型(Value Type)，一类是引用类型(Reference Type)。值类型 和 引用类型是以它们在计算机内存中是如何被分配的来划分的。值类型包括 结构和枚举，引用类型包括 类、接口、委托 等。还有一种特殊的值类型，称为简单类型(Simple Type)，比如 byte，int 等，这些简单类型实际上是 FCL类库类型的别名，比如声明一个 int 类型，实际上是声明一个 System.Int32 结构类型。因此，在 Int32 类型中定义的操作，都可以应用在 int 类型上，比如 “123.Equals(2)”。 　　所有的 值类型 都隐式地继承自 System.ValueType 类型(注意 System.ValueType 本身是一个类类型)，System.ValueType 和所有的引用类型都继承自 System.Object 基类。你不能显示地让结构继承一个类，因为 C#不支持多重继承，而结构已经隐式继承自 ValueType。

　　NOTE：堆栈(stack)是一种后进先出的数据结构，在内存中，变量会被分配在堆栈上来进行操作。堆(heap)是用于为类型实例(对象)分配空间的内存区域，在堆上创建一个对象，会将对象的地址传给堆栈上的变量(反过来叫变量指向此对象，或者变量引用此对象)。 

1.值类型 　　当声明一个值类型的变量(Variable)的时候，变量本身包含了值类型的全部字段，该变量会被分配在线程堆栈(Thread Stack)上。 　　假如我们有这样一个值类型，它代表了直线上的一点：

public struct ValPoint { 　　public int x; 　　public ValPoint(int x) 　　{ 　　　　this.x = x; 　　} } 

　　当我们在程序中写下这样的一条变量的声明语句时：

ValPoint vPoint1; 

　　实际产生的效果是声明了 vPoint1 变量，变量本身包含了值类型的所有字段(即你想要的所有数据)。 　　

　　NOTE：如果观察 MSIL 代码，会发现此时变量还没有被压到栈上，因为.maxstack(最高栈数) 为 0。并且没有看到入栈的指令，这说明只有对变量进行操作，才会进行入栈。 

　　因为变量已经包含了值类型的所有字段，所以，此时你已经可以对它进行操作了(对变量进行操作，实际上是一系列的入栈、出栈操作)。

vPoint1.x = 10; Console.WriteLine(vPoint.x); // 输出 10 

　NOTE：如果 vPoint1是一个引用类型(比如 class)，在运行时会抛出 NullReferenceException异常。因为 vPoint 是一个值类型，不存在引用，所以永远也不会抛出 NullReferenceException。 

　　如果你不对 vPoint.x 进行赋值，直接写 Console.WriteLine(vPoint.x)，则会出现编译错误：使用了未赋值的局部变量。产生这个错误是因为.Net 的一个约束：所有的元素使用前都必须初始化。比如这样的语句也会引发这个错误：

int i; Console.WriteLine(i); 

　　解决这个问题我们可以通过这样一种方式：编译器隐式地会为结构类型创建了无参数构造函数。在这个构造函数中会对结构成员进行初始化，所有的值类型成员被赋予 0 或相当于 0 的值(针对 Char 类型)，所有的引用类型被赋予 null 值。(因此，Struct 类型不可以自行声明无参数的构造函数)。所以，我们可以通过隐式声明的构造函数去创建一个 ValPoint 类型变量：

ValPoint vPoint1 = new ValPoint(); Console.WriteLine(vPoint.x); // 输出为0

　　我们将上面代码第一句的表达式由“=”分隔拆成两部分来看：

　　A左边 ValPoint vPoint1，在堆栈上创建一个 ValPoint 类型的变量 vPoint，结构的所有成员均未赋值。在进行 new ValPoint()之前，将 vPoint 压到栈上。 　　B右边 new ValPoint()，new 操作符不会分配内存，它仅仅调用 ValPoint 结构的默认构造函数，根据构造函数去初始化 vPoint 结构的所有字段。 　　注意上面这句，new 操作符不会分配内存，仅仅调用 ValPoint 结构的默认构造函数去初始化 vPoint 的所有字段。那如果我这样做，又如何解释呢？

Console.WriteLine((new ValPoint()).x); // 正常，输出为0 

　　在这种情况下，会创建一个临时变量，然后使用结构的默认构造函数对此临时变量进行初始化。我知道我这样很没有说服力，所以我们来看下 MS IL 代码，为了节省篇幅，我只节选了部分：

.locals init ([0] valuetype Prototype.ValPoint CS$0$0000) // 声明临时变量 IL_0000: nop IL_0001: ldloca.s CS$0$0000 // 将临时变量压栈 IL_0003: initobj Prototype.ValPoint // 初始化此变量 

　　而对于 ValPoint vPoint = new ValPoint(); 这种情况，其 MSIL 代码是：

.locals init ([0] valuetype Prototype.ValPoint vPoint) // 声明vPoint IL_0000: nop IL_0001: ldloca.s vPoint // 将vPoint 压栈 IL_0003: initobj Prototype.ValPoint // 使用initobj初始化此变量 

　　那么当我们使用自定义的构造函数时，ValPoint vPoint = new ValPoint(10)，又会怎么样呢？通过下面的代码我们可以看出，实际上会使用 call 指令(instruction)调用我们自定义的构造函数，并传递 10 到参数列表中。

.locals init ([0] valuetype Prototype.ValPoint vPoint) IL_0000: nop IL_0001: ldloca.s vPoint // 将 vPoint 压栈 IL_0003: ldc.i4.s 10 // 将 10 压栈 // 调用构造函数，传递参数 IL_0005: call instance void Prototype.ValPoint::.ctor(int32) 

　　对于上面的 MSIL 代码不清楚不要紧，有的时候知道结果就已经够用了。关于 MSIL 代码，有空了我会为大家翻译一些好的文章。

2.引用类型 　　当声明一个引用类型变量的时候，该引用类型的变量会被分配到堆上，这个变量将用于保存位于堆上的该引用类型的实例 的内存地址，变量本身不包含对象的数据。此时，如果仅仅声明这样一个变量，由于在堆上还没有创建类型的实例，因此，变量值为 null，意思是不指向任何类型实例(堆上的对象)。对于变量的类型声明，用于限制此变量可以保存的类型实例的地址。 　　如果我们有一个这样的类，它依然代表直线上的一点：

public class RefPoint { 　　public int x; 　　public RefPoint(int x) 　　{ 　　　　this.x = x; 　　} 　　public RefPoint() {} } 

　　当我们仅仅写下一条声明语句：

RefPoint rPoint1; 

　　它的效果就向下图一样，仅仅在堆栈上创建一个不包含任何数据，也不指向任何对象(不包含创建再堆上的对象的地址)的变量。 　　　　而当我们使用 new 操作符时：

rPoint1= new RefPoint(1); 

　　会发生这样的事： 　　　　1. 在应用程序堆 (Heap)上创建一个引用类型 (Type)的实例 (Instance)或者叫对象(Object)，并为它分配内存地址。 　　　　2. 自动传递该实例的引用给构造函数。(正因为如此，你才可以在构造函数中使用 this来访问这个实例。) 　　　　3. 调用该类型的构造函数。 　　　　4. 返回该实例的引用(内存地址)，赋值给 rPoint 变量。

3.关于简单类型 　　很多文章和书籍中在讲述这类问题的时候，总是喜欢用一个 int 类型作为 值类型 和一个Object 类型 作为引用类型来作说明。本文中将采用自定义的一个 结构 和 类 分别作值类型和引用类型的说明。这是因为简单类型(比如 int)有一些 CLR 实现了的行为，这些行为会让我们对一些操作产生误解。 举个例子，如果我们想比较两个 int 类型是否相等，我们会通常这样：

int i = 3; int j = 3; if(i==j) Console.WriteLine("i equals to j"); 

　　但是，对于自定义的值类型，比如结构，就不能用 “==”来判断它们是否相等，而需要在变量上使用 Equals()方法来完成。 　　再举个例子，大家知道 string 是一个引用类型，而我们比较它们是否相等，通常会这样做：

string a = "123456"; string b = "123456"; if(a == b) Console.WriteLine("a Equals to b"); 

　　实际上，在后面我们就会看到，当使用“==”对引用类型变量进行比较的时候，比较的是它们是否指向的堆上同一个对象。而上面 a、b 指向的显然是不同的对象，只是对象包含的值相同，所以可见，对于 string 类型，CLR 对它们的比较实际上比较的是值，而不是引用。

　　为了避免上面这些引起的混淆，在对象判等部分将采用自定义的结构和类来分别说明。

装箱 和 拆箱 　　这部分内容可深可浅，本文只简要地作一个回顾。简单来说，装箱 就是 将一个值类型转换成等值的引用类型。它的过程分为这样几步： 　　　　1. 在堆上为新生成的对象(该对象包含数据，对象本身没有名称)分配内存。 　　　　2. 将 堆栈上 值类型变量的值拷贝到 堆上的对象 中。 　　　　3. 将堆上创建的对象的地址返回给引用类型变量(从程序员角度看，这个变量的名称就好像堆上对象的名称一样)。 　　当我们运行这样的代码时：

int i = 1; Object boxed = i; Console.WriteLine("Boxed Point: " + boxed); 

　　效果图是这样的： 　　MSIL 代码是这样的：

.method private hidebysig static void Main(string[] args) cil managed { .entrypoint // 代码大小 19 (0x13) .maxstack 1 // 最高栈数是1，装箱操作后i会出栈 .locals init ([0] int32 i, // 声明变量 i(第1个变量，索引为0) [1] object boxed) // 声明变量 boxed (第2个变量，索引为1) IL_0000: nop IL_0001: ldc.i4.s 10 //#1 将10压栈 IL_0003: stloc.0 //#2 10 出栈，将值赋给 i IL_0004: ldloc.0 //#3 将i压栈 IL_0005: box [mscorlib]System.Int32 //#4 i出栈，对i装箱(复制值到堆，返回地址) IL_000a: stloc.1 //#5 将返回值赋给变量 boxed IL_000b: ldloc.1 // 将 boxed 压栈 // 调用WriteLine()方法 IL_000c: call void [mscorlib]System.Console::WriteLine(object) IL_0011: nop IL_0012: ret } // end of method Program::Main 

　　而拆箱则是将一个 已装箱的引用类型 转换为值类型：

int i = 1; Object boxed = i; int j; j = (int)boxed; // 显示声明 拆箱后的类型 Console.WriteLine("UnBoxed Point: " + j); 

　　需要注意的是：UnBox 操作需要显示声明拆箱后转换的类型。它分为两步来完成： 　　　　1. 获取已装箱的对象的地址。 　　　　2. 将值从堆上的对象中拷贝到堆栈上的值变量中。

对象判等 　　因为我们要提到对象克隆(复制)，那么，我们应该有办法知道复制前后的两个对象是否相等。所以，在进行下面的章节前，我们有必要先了解如何进行对象判等。

　　NOTE：有机会较深入地研究这部分内容，需要感谢 微软的开源 以及 VS2008 的FCL调试功能。关于如何调试 FCL 代码，请参考 Configuring Visual Studio to Debug .NET Framework Source Code。 

　　我们先定义用作范例的两个类型，它们代表直线上的一点，唯一区别是一个是引用类型class，一个是值类型 struct：

public class RefPoint{ // 定义一个引用类型 　　public int x; 　　public RefPoint(int x) { 　　this.x = x; 　　} } public struct ValPoint { // 定义一个值类型 　　public int x; 　　public ValPoint(int x)   { 　　　　this.x = x; 　　} }

1.引用类型判等 　　我们先进行引用类型对象的判等，我们知道在 System.Object 基类型中，定义了实例方法Equals(object obj) ， 静 态 方 法 Equals(object objA, object objB) ， 静 态 方 法 ReferenceEquals(object objA, object objB) 来进行对象的判等。 　　我们先看看这三个方法，注意我在代码中用 #number 标识的地方，后文中我会直接引用：

public static bool ReferenceEquals (Object objA, Object objB) { 　　return objA == objB; // #1 } public virtual bool Equals(Object obj) { 　　return InternalEquals(this, obj); // #2 } public static bool Equals(Object objA, Object objB) { 　　if (objA==objB)  // #3 　　　　return true; 　　if (objA==null || objB==null) 　　　  return false; 　　return objA.Equals(objB); // #4 } 

　　我们先看 ReferenceEquals(object objA, object objB)方法，它实际上简单地返回 objA == objB，所以，在后文中，除非必要，我们统一使用 objA == objB(省去了 ReferenceEquals 方法)。另外，为了范例简单，我们不考虑对象为 null 的情况。 　　我们来看第一段代码：

// 复制对象引用 bool result; RefPoint rPoint1 = new RefPoint(1); RefPoint rPoint2 = rPoint1; result = (rPoint1 == rPoint2); // 返回 true; Console.WriteLine(resul