值型別與引用型別及其物件複製
引言
本文之初的目的是講述設計模式中的 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
我們將上面程式碼第一句的表示式由“=”分隔拆成兩部分來看：
- 左邊 ValPoint vPoint1，在堆疊上建立一個ValPoint型別的變數vPoint，結構的所有成員均未賦值。在進行new ValPoint()之前，將vPoint壓到棧上。
- 右邊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);
會發生這樣的事：
- 在應用程式堆(Heap)上建立一個引用型別(Type)的例項(Instance)或者叫物件(Object)，併為它分配記憶體地址。
- 自動傳遞該例項的引用給建構函式。(正因為如此，你才可以在建構函式中使用this來訪問這個例項。)
- 呼叫該型別的建構函式。
- 返回該例項的引用(記憶體地址)，賦值給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對它們的比較實際上比較的是值，而不是引用。
為了避免上面這些引起的混淆，在物件判等部分將採用自定義的結構和類來分別說明。
裝箱 和 拆箱
這部分內容可深可淺，本文只簡要地作一個回顧。簡單來說，裝箱 就是 將一個值型別轉換成等值的引用型別。它的過程分為這樣幾步：
- 在堆上為新生成的物件(該物件包含資料，物件本身沒有名稱)分配記憶體。
- 將 堆疊上 值型別變數的值拷貝到 堆上的物件 中。
- 將堆上建立的物件的地址返回給引用型別變數(從程式設計師角度看，這個變數的名稱就好像堆上物件的名稱一樣)。
當我們執行這樣的程式碼時：
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 操作需要顯示宣告拆箱後轉換的型別。它分為兩步來完成：
- 獲取已裝箱的物件的地址。
- 將值從堆上的物件中拷貝到堆疊上的值變數中。
物件判等
因為我們要提到物件克隆(複製)，那麼，我們應該有辦法知道複製前後的兩個物件是否相等。所以，在進行下面的章節前，我們有必要先了解如何進行物件判等。
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;
}
- 進入 ValueType 上的 Equals() 方法，#5 處返回了 false;
- 進入 for 迴圈，遍歷欄位。
- 第一個欄位是RefPoint引用型別，#7 處，呼叫 System.Object 的Equals()方法，到達#2，返回true。
- 第二個欄位是ValPoint值型別，#7 處，呼叫 System.ValType的Equals()方法，也就是當前方法本身。此處遞迴呼叫。
- 再次進入 ValueType 的 Equals() 方法，因為 ValPoint 為簡單值型別，所以 #5 CanCompareBits 返回了true，接著 #6 FastEqualsCheck 返回了 true。
- 裡層 Equals()方法返回 true。
- 退出 for 迴圈。
- 外層 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#中的物件判等。最後，我們討論了淺度複製和 深度複製，並比較了它們之間不同。
希望這篇文章能給你帶來幫助！
原文連結：http://www.cnblogs.com/JimmyZhang/archive/2008/01/31/1059383.html點選開啟連結