C# 類型基礎——你可能忽略的技術細節 - pmars @ IT工程師數位筆記本

文章出處

引言
　　本文之初的目的是講述設計模式中的 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(result); 
result = rPoint1.Equals(rPoint2); // #2 返回true; 
Console.WriteLine(result);

　　在閱讀本文中，應該時刻在腦子里構思一個堆棧，一個堆，并思考著每條語句會在這兩種結構上產生怎么樣的效果。在這段代碼中，產生的效果是：在堆上創建了一個新的 RefPoint 類型的實例(對象)，并將它的 x 字段初始化為 1；在堆棧上創建變量 rPoint1，rPoint1 保存堆上這個對象的地址；將 rPoint1 賦值給 rPoint2 時，此時并沒有在堆上創建一個新的對象，而是將之前創建的對象的地址復制到了 rPoint2。此時，rPoint1 和 rPoint2 指向了堆上同一個對象。
　　從 ReferenceEquals()這個方法名就可以看出，它判斷兩個引用變量是不是指向了同一個變量，如果是，那么就返回 true。這種相等叫做 引用相等(rPoint1 == rPoint2 等效于 ReferenceEquals)。因為它們指向的是同一個對象，所以對 rPoint1 的操作將會影響 rPoint2：

　　
　　注意 System.Object 靜態的 Equals(Object objA, Object objB)方法，在 #3 處，如果兩個變量引用相等，那么將直接返回 true 。所以，可以預見我們上面的代碼rPoint1.Equals(rPoint2); 在 #3 就會返回 true。但是我們沒有調用靜態 Equals()，直接調用了實體方法，最后調用了#2 的 InternalEquals()，返回true。(InternalEquals()無資料可查，僅通過調試測得)。
　　我們再看引用類型的第二種情況：

//創建新引用類型的對象，其成員的值相等 
RefPoint rPoint1 = new RefPoint(1); 
RefPoint rPoint2 = new RefPoint(1); 

result = (rPoint1 == rPoint2); 
Console.WriteLine(result); // 返回 false; 

result = rPoint1.Equals(rPoint2); 
Console.WriteLine(result); // #2 返回false

　　上面的代碼在堆上創建了兩個類型實例，并用同樣的值初始化它們；然后將它們的地址分別賦值給堆上的變量 rPoint1 和 rPoint2。此時 #2 返回了 false，可以看到，對于引用類型，即使類型的實例(對象)包含的值相等，如果變量指向的是不同的對象，那么也不相等。

2.簡單值類型判等
　　注意本節的標題：簡單值類型判等，這個簡單是如何定義的呢？如果值類型的成員僅包含值類型，那么我們暫且管它叫簡單值類型，如果值類型的成員包含引用類型，我們管它叫復雜值類型。(注意，這只是本文中為了說明我個人作的定義。)
　　應該還記得我們之前提過，值類型都會隱式地繼承自 System.ValueType 類型，而 ValueType類型覆蓋了基類 System.Object 類型的 Equals()方法，在值類型上調用 Equals()方法，會調用ValueType 的 Equals()。所以，我們看看這個方法是什么樣的，依然用 #number 標識后面會引用的地方。

public override bool Equals (Object obj) 
{ 
　　if (null==obj)
　　　　return false; 
　　RuntimeType thisType = (RuntimeType)this.GetType(); 
　　RuntimeType thatType = (RuntimeType)obj.GetType(); 

　　if (thatType!=thisType) // 如果兩個對象不是一個類型，直接返回false 
　　　　return false; 
　　
　　Object thisObj = (Object)this; 
　　Object thisResult, thatResult; 

　　if (CanCompareBits(this)) // #5 
　　　　return FastEqualsCheck(thisObj, obj); // #6 

　　// 利用反射獲取值類型所有字段 
　　FieldInfo[] thisFields = thisType.GetFields(BindingFlags.Instance | 
　　BindingFlags.Public | BindingFlags.NonPublic); 
　　// 遍歷字段，進行字段對字段比較 
　　for (int i=0; i<thisFields.Length; i++) 
　　{ 
　　　　thisResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(thisObj,false); 
　　　　thatResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(obj, false); 

　　　　if (thisResult == null)
　　　　{
　　　　　　if (thatResult != null) 
　　　　　　　　return false; 
　　　　}
　　　　else if (!thisResult.Equals(thatResult)) // #7 
　　　　　　　　return false;  
　　}
　　return true; 
}

　　我們先來看看第一段代碼：

// 復制結構變量 
ValPoint vPoint1 = new ValPoint(1); 
ValPoint vPoint2 = vPoint1; 

result = (vPoint1 == vPoint2); //編譯錯誤：不能在ValPoint上應用 "==" 操作符 
Console.WriteLine(result); 

result = Object.ReferenceEquals(vPoint1, vPoint2); // 隱式裝箱，指向了堆上的不同對象 
Console.WriteLine(result); // 返回false

　　我們先在堆棧上創建了一個變量 vPoint1，變量本身已經包含了所有字段和數據。然后在堆棧上復制了 vPoint1 的一份拷貝給了 vPoint2，從常理思維上來講，我們認為它應該是相等的。接下來我們就試著去比較它們，可以看到，我們不能用“==”直接去判斷，這樣會返回一個編譯錯誤。如果我們調用 System.Object 基類的靜態方法 ReferenceEquals()，有意思的事情發生了：它返回了 false。為什么呢？我們看下 ReferenceEquals()方法的簽名就可以了，它接受的是Object 類型，也就是引用類型，而當我們傳遞 vPoint1 和 vPoint2 這兩個值類型的時候，會進行一個隱式的裝箱，效果相當于下面的語句：

Object boxPoint1 = vPoint1; 
Object boxPoint2 = vPoint2; 
result = (boxPoint1 == boxPoint2); // 返回false 
Console.WriteLine(result);

　　而裝箱的過程，我們在前面已經講述過，上面的操作等于是在堆上創建了兩個對象，對象包含的內容相同(地址不同)，然后將對象地址分別返回給堆棧上的 boxPoint1 和 boxPoint2，再去比較 boxPoint1 和 boxPoint2 是否指向同一個對象，顯然不是，所以返回 false。
　　我們繼續，添加下面這段代碼：

result = vPoint1.Equals(vPoint2); // #5 返回true; #6 返回true; 
Console.WriteLine(result); // 輸出true

　　因為它們均繼承自 ValueType 類型，所以此時會調用 ValueType 上的 Equals()方法，在方法體內部，#5 CanCompareBits(this) 返回了 true，CanCompareBits(this)這個方法，按微軟的注釋，意識是說：如果對象的成員中存在對于堆上的引用，那么返回 false，如果不存在，返回 true。按照 ValPoint 的定義，它僅包含一個 int 類型的字段 x，自然不存在對堆上其他對象的引用，所以返回了 true。從#5 的名字 CanCompareBits，可以看出是判斷是否可以進行按位比較，那么返回了 true 以后，#6 自然是進行按位比較了。

　　接下來，我們對 vPoint2 做點改動，看看會發生什么：

vPoint2.x = 2; 
result = vPoint1.Equals(vPoint2); // #5 返回true; #6 返回false; 
Console.WriteLine(result);

3. 復雜值類型判等
　　到現在，上面的這些方法，我們還沒有走到的位置，就是 CanCompareBits 返回 false 以后的部分了。前面我們已經推測出了 CanCompareBits返回 false 的條件(值類型的成員包含引用類型)，現在只要實現下就可以了。我們定義一個新的結構 Line，它代表直線上的線段，我們讓它的一個成員為值類型 ValPoint，一個成員為引用類型 RefPoint，然后去作比較。

/* 結構類型 ValLine 的定義， 
public struct ValLine { 
public RefPoint rPoint; // 引用類型成員 
public ValPoint vPoint; // 值類型成員 
public Line(RefPoint rPoint, ValPoint vPoint) { 
this.rPoint = rPoint; 
this.vPoint = vPoint; 
} 
} 
*/ 

RefPoint rPoint = new RefPoint(1); 
ValPoint vPoint = new ValPoint(1); 

ValLine line1 = new ValLine (rPoint, vPoint); 
ValLine line2 = line1; 

result = line1.Equals(line2); // 此時已經存在一個裝箱操作，調用ValueType.Equals() 
Console.WriteLine(result); // 返回True

　　這個例子的過程要復雜得多。在開始前，我們先思考一下，當我們寫下 line1.Equals(line2)時，已經進行了一個裝箱的操作。如果要進一步判等，顯然不能去判斷變量是否引用的堆上同一個對象，這樣的話就沒有意義了，因為總是會返回 false(裝箱后堆上創建了兩個對象)。那么應該如何判斷呢？對堆上對象的成員(字段)進行一對一的比較，而成員又分為兩種類型，一種是值類型，一種是引用類型。對于引用類型，去判斷是否引用相等；對于值類型，如果是簡單值類型，那么如同前一節講述的去判斷；如果是復雜類型，那么當然是遞歸調用了；最終直到要么是引用類型要么是簡單值類型。

　　NOTE：進行字段對字段的一對一比較，需要用到反射，如果不了解反射，可以參看 .Net 中的反射 系列文章。

　　好了，我們現在看看實際的過程，是不是如同我們料想的那樣，為了避免頻繁的拖動滾動條查看 ValueType 的 Equals()方法，我拷貝了部分下來：

public override bool Equals (Object obj) 
{ 
　　if (CanCompareBits(this)) // #5 
　　　　return FastEqualsCheck(thisObj, obj); // #6 
　　// 利用反射獲取類型的所有字段(或者叫類型成員) 
　　FieldInfo[] thisFields = thisType.GetFields(BindingFlags.Instance | 
　　BindingFlags.Public | BindingFlags.NonPublic); 
　　// 遍歷字段進行比較 
　　for (int i=0; i<thisFields.Length; i++) 
　　{ 
　　　　thisResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(thisObj,false); 
　　　　thatResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(obj, false); 

　　　　if (thisResult == null) 
　　　　{ 
　　　　　　if (thatResult != null) 
　　　　　　　　return false; 
　　　　} 
　　　　else if (!thisResult.Equals(thatResult)) 
　　　　{ // #7 
　　　　　　return false; 
　　　　} 
　　} 
　　return true; 
}

　　　　1. 進入 ValueType 上的 Equals() 方法，#5 處返回了 false;
　　　　2. 進入 for 循環，遍歷字段。
　　　　3. 第一個字段是 RefPoint 引用類型，#7 處，調用 System.Object 的 Equals()方法，到達#2，返回 true。
　　　　4. 第二個字段是 ValPoint 值類型，#7 處，調用 System.ValType 的 Equals()方法，也就是當前方法本身。此處遞歸調用。
　　　　5. 再次進入 ValueType 的 Equals() 方法，因為 ValPoint 為簡單值類型，所以 #5 CanCompareBits 返回了 true，接著 #6 FastEqualsCheck 返回了 true。
　　　　6. 里層 Equals()方法返回 true。
　　　　7. 退出 for 循環。
　　　　8. 外層 Equals() 方法返回 true。

對象復制
　　有的時候，創建一個對象可能會非常耗時，比如對象需要從遠程數據庫中獲取數據來填充，又或者創建對象需要讀取硬盤文件。此時，如果已經有了一個對象，再創建新對象時，可能會采用復制現有對象的方法，而不是重新建一個新的對象。本節就討論如何進行對象的復制。

1.淺度復制
　　淺度復制和深度復制是以如何復制對象的成員(member)來劃分的。一個對象的成員有可能是值類型，有可能是引用類型。當我們對對象進行一個淺度復制的時候，對于值類型成員，會復制其本身(值類型變量本身包含了所有數據，復制時進行按位拷貝)；對于引用類型成員(注意它會引用另一個對象)，僅僅復制引用，而不創建其引用的對象。結果就是：新對象的引用成員和復制對象的引用成員指向了同一個對象。
　　繼續我們上面的例子，如果我們想要進行復制的對象(RefLine)是這樣定義的，(為了避免look up，我在這里把代碼再貼過來)：

// 將要進行 淺度復制 的對象，注意為 引用類型 
public class RefLine 
{ 
　　public RefPoint rPoint; 
　　public ValPoint vPoint; 
　　public Line(RefPoint rPoint,ValPoint vPoint)
　　{ 
　　　　this.rPoint = rPoint; 
　　　　this.vPoint = vPoint; 
　　} 
} 
// 定義一個引用類型成員 
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; 
　　} 
}

　　我們先創建一個想要復制的對象：

RefPoint rPoint = new RefPoint(1); 
ValPoint vPoint = new ValPoint(1); 
RefLine line = new RefLine(rPoint, vPoint);

　　它所產生的實際效果是(堆棧上僅考慮 line 部分)：
　　
　　那么當我們對它復制時，就會像這樣(newLine 是指向新拷貝的對象的指針，在代碼中體現為一個引用類型的變量)：
　　
　　按照這個定義，再回憶上面我們講到的內容，可以推出這樣一個結論：當復制一個結構類型成員的時候，直接創建一個新的結構類型變量，然后對它賦值，就相當于進行了一個淺度復制，也可以認為結構類型隱式地實現了淺度復制。如果我們將上面的 RefLine 定義為一個結構(Struct)，結構類型叫 ValLine，而不是一個類，那么對它進行淺度復制就可以這樣：

ValLine newLine = line;

　　實際的效果圖是這樣：

　　
　　現在你已經已經搞清楚了什么是淺度復制，知道了如何對結構淺度復制。那么如何對一個引用類型實現淺度復制呢？在.Net Framework 中，有一個 ICloneable 接口，我們可以實現這個接口來進行淺度復制(也可以是深度復制，這里有爭議，國外一些人認為 ICloneable 應該被標識為過時(Obsolete)的，并且提供 IShallowCloneable 和 IDeepCloneble 來替代)。這個接口只要求實現一個方法 Clone()，它返回當前對象的副本。我們并不需要自己實現這個方法(當然完全可以)，在 System.Object 基類中，有一個保護的 MemeberwiseClone()方法，它便用于進行淺度復制。所以，對于引用類型，如果想要實現淺度復制時，只需要調用這個方法就可以了：

public object Clone() 
{ 
　　return MemberwiseClone(); 
}

　　現在我們來做一個測試：

class Program 
{ 
　　static void Main(string[] args) 
　　{ 
　　　　RefPoint rPoint = new RefPoint(1); 
　　　　ValPoint vPoint = new ValPoint(1); 
　　　　RefLine line = new RefLine(rPoint, vPoint); 

　　　　RefLine newLine = (RefLine)line.Clone(); 
　　　　Console.WriteLine("Original: line.rPoint.x = {0}, line.vPoint.x = {1}", 
　　　　line.rPoint.x, line.vPoint.x); 
　　　　Console.WriteLine("Cloned: newLine.rPoint.x = {0}, newLine.vPoint.x = {1}", 
　　　　newLine.rPoint.x, newLine.vPoint.x); 

　　　　line.rPoint.x = 10; // 修改原先的line的 引用類型成員 rPoint 
　　　　line.vPoint.x = 10; // 修改原先的line的 值類型 成員 vPoint 
　　　　Console.WriteLine("Original: line.rPoint.x = {0}, line.vPoint.x = {1}", 
　　　　line.rPoint.x, line.vPoint.x); Console.WriteLine("Cloned: newLine.rPoint.x = {0}, newLine.vPoint.x = {1}", 
　　　　newLine.rPoint.x, newLine.vPoint.x); 
　　} 
}

　　輸出為：

Original: line.rPoint.x = 1, line.vPoint.x = 1 
Cloned: newLine.rPoint.x = 1, newLine.vPoint.x = 1 
Original: line.rPoint.x = 10, line.vPoint.x = 10 
Cloned: newLine.rPoint.x = 10, newLine.vPoint.x = 1

　　可見，復制后的對象和原先對象成了連體嬰，它們的引用成員字段依然引用堆上的同一個對象。
2.深度復制
　　其實到現在你可能已經想到什么時深度復制了，深度復制就是將引用成員指向的對象也進行復制。實際的過程是創建新的引用成員指向的對象，然后復制對象包含的數據。
　　深度復制可能會變得非常復雜，因為引用成員指向的對象可能包含另一個引用類型成員，最簡單的例子就是一個線性鏈表。
　　如果一個對象的成員包含了對于線性鏈表結構的一個引用，淺度復制只復制了對頭結點的引用，深度復制則會復制鏈表本身，并復制每個結點上的數據。
　　考慮我們之前的例子，如果我們期望進行一個深度復制，我們的 Clone()方法應該如何實現呢？

public object Clone()
{ // 深度復制 
　　RefPoint rPoint = new RefPoint(); // 對于引用類型，創建新對象 
　　rPoint.x = this.rPoint.x; // 復制當前引用類型成員的值 到 新對象 
　　ValPoint vPoint = this.vPoint; // 值類型，直接賦值 
　　RefLine newLine = new RefLine(rPoint, vPoint); 
　　return newLine; 
}

　　可以看到，如果每個對象都要這樣去進行深度復制的話就太麻煩了，我們可以利用串行化/反串行化來對對象進行深度復制：先把對象串行化(Serialize)到內存中，然后再進行反串行化，通過這種方式來進行對象的深度復制：

public object Clone()
{ 
　　BinaryFormatter bf = new BinaryFormatter(); MemoryStream ms = new MemoryStream(); 
　　bf.Serialize(ms, this); 
　　ms.Position = 0; 

　　return (bf.Deserialize(ms)); ; 
}

　　我們來做一個測試：

class Program 
{ 
　　static void Main(string[] args) 
　　{ 
　　　　RefPoint rPoint = new RefPoint(1); 
　　　　ValPoint vPoint = new ValPoint(2); 

　　　　RefLine line = new RefLine(rPoint, vPoint); 
　　　　RefLine newLine = (RefLine)line.Clone(); 

　　　　Console.WriteLine("Original line.rPoint.x = {0}", line.rPoint.x); 
　　　　Console.WriteLine("Cloned newLine.rPoint.x = {0}", newLine.rPoint.x); 

　　　　line.rPoint.x = 10; // 改變原對象 引用成員 的值 
　　　　Console.WriteLine("Original line.rPoint.x = {0}", line.rPoint.x); 
　　　　Console.WriteLine("Cloned newLine.rPoint.x = {0}", newLine.rPoint.x); 
　　} 
}

　　輸出為：

Original line.rPoint.x = 1 
Cloned newLine.rPoint.x = 1 
Original line.rPoint.x = 10 
Cloned newLine.rPoint.x = 1

　　可見，兩個對象的引用成員已經分離，改變原對象的引用對象的值，并不影響復制后的對象。
　　這里需要注意：如果想將對象進行序列化，那么對象本身，及其所有的自定義成員(類、結構)，都必須使用 Serializable 特性進行標記。所以，如果想讓上面的代碼運行，我們之前定義的類都需要進行這樣的標記：

[Serializable()] 
public class RefPoint { /*略*/}

　　NOTE：關于特性(Attribute)，可以參考 .Net 中的反射(反射特性) 一文。

總結
　　本文簡單地對 C#中的類型作了一個回顧。
　　我們首先討論了 C#中的兩種類型--值類型和引用類型，隨后簡要回顧了裝箱/拆箱操作。接著，詳細討論了 C#中的對象判等。最后，我們討論了淺度復制和深度復制，并比較了它們之間不同。

　　記在這里，以后學習

文章列表

Avast 防毒軟體已檢查此封電子郵件的病毒。
www.avast.com

大師兄

IT工程師數位筆記本

大師兄發表在痞客邦留言(0) 人氣()

E-mail轉寄

IT工程師數位筆記本

If you give someone a program , you will frustrate them for a day; if you teach them how to program, you will frustrate them for a lifetime.IT 這段話的意思是，如果你交給某人一隻程式，你將折磨他一整天;如果你教會某人如何寫程式，你將折磨他一輩子。

BloggerAds

C# 類型基礎——你可能忽略的技術細節 - pmars

歷史上的今天

留言列表

參觀人氣

文章搜尋

最新文章

文章精選

誰來我家

熱門文章

文章分類

最新留言

QR Code

POWERED BY