引言
本文之初的目的是講述設計模式中的 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)上。
假如我們有這樣一個值類型，它代表了直線上的一點：
{
ValPoint( {
.x =}
當我們在程序中寫下這樣的一條變量的聲明語句時：
ValPoint vPoint1;
實際產生的效果是聲明了 vPoint1 變量，變量本身包含了值類型的所有字段(即你想要的所有數據)。
NOTE：如果觀察 MSIL 代碼，會發現此時變量還沒有被壓到棧上，因為.maxstack(最高棧數) 為 。並且沒有看到入棧的指令，這說明只有對變量進行操作，才會進行入棧。
因為變量已經包含了值類型的所有字段，所以，此時你已經可以對它進行操作了(對變量進行操作，實際上是一系列的入棧、出棧操作)。
vPoint1.x =
如果 vPoint1是一個引用類型(比如
如果你不對 vPoint.x 進行賦值，直接寫 Console.WriteLine(vPoint.x)，則會出現編譯錯誤：使用了未賦值的局部變量。產生這個錯誤是因為.Net 的一個約束：所有的元素使用前都必須初始化。比如這樣的語句也會引發這個錯誤：
解決這個問題我們可以通過這樣一種方式：編譯器隱式地會為結構類型創建了無參數構造函數。在這個構造函數中會對結構成員進行初始化，所有的值類型成員被賦予 0 或相當於 0 的值(針對 Char 類型)，所有的引用類型被賦予 null 值。(因此，Struct 類型不可以自行聲明無參數的構造函數)。所以，我們可以通過隱式聲明的構造函數去創建一個 ValPoint 類型變量：
ValPoint vPoint1 =
我們將上面代碼第一句的表達式由“=”分隔拆成兩部分來看：
A 左邊 ValPoint vPoint1，在堆棧上創建一個 ValPoint 類型的變量 vPoint，結構的所有成員均未賦值。在進行 new ValPoint()之前，將 vPoint 壓到棧上。
B 右邊 new ValPoint()，new 操作符不會分配內存，它僅僅調用 ValPoint 結構的默認構造函數，根據構造函數去初始化 vPoint 結構的所有字段。
注意上面這句，new 操作符不會分配內存，僅僅調用 ValPoint 結構的默認構造函數去初始化 vPoint 的所有字段。那如果我這樣做，又如何解釋呢？
Console.WriteLine(( ValPoint()).x);
在這種情況下，會創建一個臨時變量，然後使用結構的默認構造函數對此臨時變量進行初始化。我知道我這樣很沒有說服力，所以我們來看下 MS IL 代碼，為了節省篇幅，我只節選了部分：
.locals init ([] valuetype Prototype.ValPoint CS$$) $ IL_0003: initobj Prototype.ValPoint
而對於 ValPoint vPoint = new ValPoint(); 這種情況，其 MSIL 代碼是：
.locals init ([] valuetype Prototype.ValPoint vPoint) IL_0003: initobj Prototype.ValPoint
那麼當我們使用自定義的構造函數時，ValPoint vPoint = new ValPoint(10)，又會怎麼樣呢？通過下面的代碼我們可以看出，實際上會使用 call 指令(instruction)調用我們自定義的構造函數，並傳遞 10 到參數列表中。
.locals init ([ IL_0003: ldc.i4.s IL_0005: call instance Prototype.ValPoint::.ctor(int32)
對於上面的 MSIL 代碼不清楚不要緊，有的時候知道結果就已經夠用了。關於 MSIL 代碼，有空了我會為大家翻譯一些好的文章。
當聲明一個引用類型變量的時候，該引用類型的變量會被分配到堆上，這個變量將用於保存位於堆上的該引用類型的實例 的內存地址，變量本身不包含對象的數據。此時，如果僅僅聲明這樣一個變量，由於在堆上還沒有創建類型的實例，因此，變量值為 null，意思是不指向任何類型實例(堆上的對象)。對於變量的類型聲明，用於限制此變量可以保存的類型實例的地址。
如果我們有一個這樣的類，它依然代表直線上的一點：
{
RefPoint( {
.x =
當我們僅僅寫下一條聲明語句：
RefPoint rPoint1;
它的效果就向下圖一樣，僅僅在堆棧上創建一個不包含任何數據，也不指向任何對象(不包含創建再堆上的對象的地址)的變量。
而當我們使用 new 操作符時：
rPoint1= RefPoint();
會發生這樣的事：
1. 在應用程序堆 (Heap)上創建一個引用類型 (Type)的實例 (Instance)或者叫對象(Object)，並為它分配內存地址。
2. 自動傳遞該實例的引用給構造函數。(正因為如此，你才可以在構造函數中使用 this來訪問這個實例。)
3. 調用該類型的構造函數。
4. 返回該實例的引用(內存地址)，賦值給 rPoint 變量。
3.關於簡單類型
很多文章和書籍中在講述這類問題的時候，總是喜歡用一個 int 類型作為 值類型 和一個Object 類型 作為引用類型來作說明。本文中將采用自定義的一個 結構 和 類 分別作值類型和引用類型的說明。這是因為簡單類型(比如 int)有一些 CLR 實現了的行為，這些行為會讓我們對一些操作產生誤解。
舉個例子，如果我們想比較兩個 int 類型是否相等，我們會通常這樣：
i = j = (i==j) Console.WriteLine();
但是，對於自定義的值類型，比如結構，就不能用 “==”來判斷它們是否相等，而需要在變量上使用 Equals()方法來完成。
再舉個例子，大家知道 string 是一個引用類型，而我們比較它們是否相等，通常會這樣做：
a = ; b = (a == b) Console.WriteLine();
實際上，在後面我們就會看到，當使用“==”對引用類型變量進行比較的時候，比較的是它們是否指向的堆上同一個對象。而上面 a、b 指向的顯然是不同的對象，只是對象包含的值相同，所以可見，對於 string 類型，CLR 對它們的比較實際上比較的是值，而不是引用。
為了避免上面這些引起的混淆，在對象判等部分將采用自定義的結構和類來分別說明。
裝箱 和 拆箱
這部分內容可深可淺，本文只簡要地作一個回顧。簡單來說，裝箱 就是 將一個值類型轉換成等值的引用類型。它的過程分為這樣幾步：
1. 在堆上為新生成的對象(該對象包含數據，對象本身沒有名稱)分配內存。
2. 將 堆棧上 值類型變量的值拷貝到 堆上的對象 中。
3. 將堆上創建的對象的地址返回給引用類型變量(從程序員角度看，這個變量的名稱就好像堆上對象的名稱一樣)。
當我們運行這樣的代碼時：
i = = + boxed);
效果圖是這樣的：
MSIL 代碼是這樣的：
.method hidebysig Main( .maxstack .locals init ([] int32 i, [] boxed) IL_0003: stloc. IL_0004: ldloc. IL_0005: box [mscorlib]System.Int32 IL_000a: stloc. IL_000b: ldloc. IL_000c: call [mscorlib]System.Console::WriteLine(
而拆箱則是將一個 已裝箱的引用類型 轉換為值類型：
i = == ()boxed; Console.WriteLine( + j);
需要注意的是：UnBox 操作需要顯示聲明拆箱後轉換的類型。它分為兩步來完成：
1. 獲取已裝箱的對象的地址。
2. 將值從堆上的對象中拷貝到堆棧上的值變量中。
對象判等
因為我們要提到對象克隆(復制)，那麼，我們應該有辦法知道復制前後的兩個對象是否相等。所以，在進行下面的章節前，我們有必要先了解如何進行對象判等。
NOTE：有機會較深入地研究這部分內容，需要感謝 微軟的開源 以及 VS2008 的FCL調試功能。關於如何調試 FCL 代碼，請參考 Configuring Visual Studio to Debug .NET Framework Source Code。
我們先定義用作范例的兩個類型，它們代表直線上的一點，唯一區別是一個是引用類型class，一個是值類型 struct：
RefPoint
{ RefPoint(.x = ValPoint
{ ValPoint( { .x =
我們先進行引用類型對象的判等，我們知道在 System.Object 基類型中，定義了實例方法Equals(object obj) ， 靜 態 方 法 Equals(object objA, object objB) ， 靜 態 方 法 ReferenceEquals(object objA, object objB) 來進行對象的判等。
我們先看看這三個方法，注意我在代碼中用 #number 標識的地方，後文中我會直接引用：
objA == objB;
InternalEquals(, obj);
{
(objA==objB)
(objA== || objB== objA.Equals(objB);
}
我們先看 ReferenceEquals(object objA, object objB)方法，它實際上簡單地返回 objA == objB，所以，在後文中，除非必要，我們統一使用 objA == objB(省去了 ReferenceEquals 方法)。另外，為了范例簡單，我們不考慮對象為 null 的情況。
我們來看第一段代碼：
= RefPoint(== (rPoint1 == rPoint2); = rPoint1.Equals(rPoint2); 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 = RefPoint(= RefPoint(= (rPoint1 == =
上面的代碼在堆上創建了兩個類型實例，並用同樣的值初始化它們；然後將它們的地址分別賦值給堆上的變量 rPoint1 和 rPoint2。此時 #2 返回了 false，可以看到，對於引用類型，即使類型的實例(對象)包含的值相等，如果變量指向的是不同的對象，那麼也不相等。
2.簡單值類型判等
注意本節的標題：簡單值類型判等，這個簡單是如何定義的呢？如果值類型的成員僅包含值類型，那麼我們暫且管它叫 簡單值類型，如果值類型的成員包含引用類型，我們管它叫復雜值類型。(注意，這只是本文中為了說明我個人作的定義。)
應該還記得我們之前提過，值類型都會隱式地繼承自 System.ValueType 類型，而 ValueType類型覆蓋了基類 System.Object 類型的 Equals()方法，在值類型上調用 Equals()方法，會調用ValueType 的 Equals()。所以，我們看看這個方法是什麼樣的，依然用 #number 標識後面會引用的地方。
{
(== = (RuntimeType)= (thatType!=thisType)
Object thisObj = (Object) (CanCompareBits())
FastEqualsCheck(thisObj, obj);
FieldInfo[] thisFields = thisType.GetFields(BindingFlags.Instance ||
( i=; i<thisFields.Length; i++ {
thisResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(thisObj,= ((RtFieldInfo)thisFields[i]).InternalGetValue(obj, (thisResult == {
(thatResult != }
(!thisResult.Equals(thatResult))
}
我們先來看看第一段代碼：
ValPoint vPoint1 = ValPoint(== (vPoint1 == vPoint2); = Object.ReferenceEquals(vPoint1, vPoint2); Console.WriteLine(result);
我們先在堆棧上創建了一個變量 vPoint1，變量本身已經包含了所有字段和數據。然後在堆棧上復制了 vPoint1 的一份拷貝給了 vPoint2，從常理思維上來講，我們認為它應該是相等的。接下來我們就試著去比較它們，可以看到，我們不能用“==”直接去判斷，這樣會返回一個編譯錯誤。如果我們調用 System.Object 基類的靜態方法 ReferenceEquals()，有意思的事情發生了：它返回了 false。為什麼呢？我們看下 ReferenceEquals()方法的簽名就可以了，它接受的是Object 類型，也就是引用類型，而當我們傳遞 vPoint1 和 vPoint2 這兩個值類型的時候，會進行一個隱式的裝箱，效果相當於下面的語句：
Object boxPoint1 === (boxPoint1 == boxPoint2); Console.WriteLine(result);
而裝箱的過程，我們在前面已經講述過，上面的操作等於是在堆上創建了兩個對象，對象包含的內容相同(地址不同)，然後將對象地址分別返回給堆棧上的 boxPoint1 和 boxPoint2，再去比較 boxPoint1 和 boxPoint2 是否指向同一個對象，顯然不是，所以返回 false。
我們繼續，添加下面這段代碼：
result = vPoint1.Equals(vPoint2); Console.WriteLine(result);
因為它們均繼承自 ValueType 類型，所以此時會調用 ValueType 上的 Equals()方法，在方法體內部，#5 CanCompareBits(this) 返回了 true，CanCompareBits(this)這個方法，按微軟的注釋，意識是說：如果對象的成員中存在對於堆上的引用，那麼返回 false，如果不存在，返回 true。按照 ValPoint 的定義，它僅包含一個 int 類型的字段 x，自然不存在對堆上其他對象的引用，所以返回了 true。從#5 的名字 CanCompareBits，可以看出是判斷是否可以進行按位比較，那麼返回了 true 以後，#6 自然是進行按位比較了。
接下來，我們對 vPoint2 做點改動，看看會發生什麼：
vPoint2.x = = vPoint1.Equals(vPoint2); Console.WriteLine(result);
3. 復雜值類型判等
到現在，上面的這些方法，我們還沒有走到的位置，就是 CanCompareBits 返回 false 以後的部分了。前面我們已經推測出了 CanCompareBits返回 false 的條件(值類型的成員包含引用類型)，現在只要實現下就可以了。我們定義一個新的結構 Line，它代表直線上的線段，我們讓它的一個成員為值類型 ValPoint，一個成員為引用類型 RefPoint，然後去作比較。
= RefPoint(= ValPoint(= == line1.Equals(line2); Console.WriteLine(result);
這個例子的過程要復雜得多。在開始前，我們先思考一下，當我們寫下 line1.Equals(line2)時，已經進行了一個裝箱的操作。如果要進一步判等，顯然不能去判斷變量是否引用的堆上同一個對象，這樣的話就沒有意義了，因為總是會返回 false(裝箱後堆上創建了兩個對象)。那麼應該如何判斷呢？對 堆上對象 的成員(字段)進行一對一的比較，而成員又分為兩種類型，一種是值類型，一種是引用類型。對於引用類型，去判斷是否引用相等；對於值類型，如果是簡單值類型，那麼如同前一節講述的去判斷；如果是復雜類型，那麼當然是遞歸調用了；最終直到要麼是引用類型要麼是簡單值類型。
NOTE：進行字段對字段的一對一比較，需要用到反射，如果不了解反射，可以參看 .Net 中的反射 系列文章。
好了，我們現在看看實際的過程，是不是如同我們料想的那樣，為了避免頻繁的拖動滾動條查看 ValueType 的 Equals()方法，我拷貝了部分下來：
{
(CanCompareBits())
FastEqualsCheck(thisObj, obj);
FieldInfo[] thisFields = thisType.GetFields(BindingFlags.Instance ||
( i=; i<thisFields.Length; i++ {
thisResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(thisObj,= ((RtFieldInfo)thisFields[i]).InternalGetValue(obj, (thisResult == {
(thatResult != (!thisResult.Equals(thatResult))
{ // #
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。
對象復制
有的時候，創建一個對象可能會非常耗時，比如對象需要從遠程數據庫中獲取數據來填充，又或者創建對象需要讀取硬盤文件。此時，如果已經有了一個對象，再創建新對象時，可能會采用復制現有對象的方法，而不是重新建一個新的對象。本節就討論如何進行對象的復制。
淺度復制 和 深度復制 是以如何復制對象的成員(member)來劃分的。一個對象的成員有可能是值類型，有可能是引用類型。當我們對對象進行一個淺度復制的時候，對於值類型成員，會復制其本身(值類型變量本身包含了所有數據，復制時進行按位拷貝)；對於引用類型成員(注意它會引用另一個對象)，僅僅復制引用，而不創建其引用的對象。結果就是：新對象的引用成員 和 復制對象的引用成員 指向了同一個對象。
繼續我們上面的例子，如果我們想要進行復制的對象(RefLine)是這樣定義的，(為了避免look up，我在這裡把代碼再貼過來)：
{
{
.rPoint =.vPoint =
{
RefPoint( {
.x =
{
ValPoint( {
.x =
我們先創建一個想要復制的對象：
RefPoint rPoint = RefPoint(= ValPoint(= RefLine(rPoint, vPoint);
它所產生的實際效果是(堆棧上僅考慮 line 部分)：
那麼當我們對它復制時，就會像這樣(newLine 是指向新拷貝的對象的指針，在代碼中體現為一個引用類型的變量)：
按照這個定義，再回憶上面我們講到的內容，可以推出這樣一個結論：當復制一個結構類型成員的時候，直接創建一個新的結構類型變量，然後對它賦值，就相當於進行了一個淺度復制，也可以認為結構類型隱式地實現了淺度復制。如果我們將上面的 RefLine 定義為一個結構(Struct)，結構類型叫 ValLine，而不是一個類，那麼對它進行淺度復制就可以這樣：
ValLine newLine = line;
實際的效果圖是這樣：
現在你已經已經搞清楚了什麼是淺度復制，知道了如何對結構淺度復制。那麼如何對一個引用類型實現淺度復制呢？在.Net Framework 中，有一個 ICloneable 接口，我們可以實現這個接口來進行淺度復制(也可以是深度復制，這裡有爭議，國外一些人認為 ICloneable 應該被標識為過時(Obsolete)的，並且提供 IShallowCloneable 和 IDeepCloneble 來替代)。這個接口只要求實現一個方法 Clone()，它返回當前對象的副本。我們並不需要自己實現這個方法(當然完全可以)，在 System.Object 基類中，有一個保護的 MemeberwiseClone()方法，它便用於進行淺度復制。所以，對於引用類型，如果想要實現淺度復制時，只需要調用這個方法就可以了：
{
現在我們來做一個測試：
{
Main( {
RefPoint rPoint = RefPoint(= ValPoint(= == ;
line.vPoint.x = ;
Console.WriteLine(
輸出為：
Original: line.rPoint.x = , line.vPoint.x = = , newLine.vPoint.x = = , line.vPoint.x = = , newLine.vPoint.x =
可見，復制後的對象和原先對象成了連體嬰，它們的引用成員字段依然引用堆上的同一個對象。
其實到現在你可能已經想到什麼時深度復制了，深度復制就是將引用成員指向的對象也進行復制。實際的過程是創建新的引用成員指向的對象，然後復制對象包含的數據。
深度復制可能會變得非常復雜，因為引用成員指向的對象可能包含另一個引用類型成員，最簡單的例子就是一個線性鏈表。
如果一個對象的成員包含了對於線性鏈表結構的一個引用，淺度復制 只復制了對頭結點的引用，深度復制 則會復制鏈表本身，並復制每個結點上的數據。
考慮我們之前的例子，如果我們期望進行一個深度復制，我們的 Clone()方法應該如何實現呢？
Clone()
{ RefPoint rPoint = RefPoint(); rPoint.x = .rPoint.x; ValPoint vPoint = .vPoint; RefLine newLine =
可以看到，如果每個對象都要這樣去進行深度復制的話就太麻煩了，我們可以利用串行化/反串行化來對對象進行深度復制：先把對象串行化(Serialize)到內存中，然後再進行反串行化，通過這種方式來進行對象的深度復制：
{
BinaryFormatter bf = BinaryFormatter(); MemoryStream ms = =
我們來做一個測試：
{
Main( {
RefPoint rPoint = RefPoint(= ValPoint(= == ;
Console.WriteLine(
輸出為：
Original line.rPoint.x = = = =
可見，兩個對象的引用成員已經分離，改變原對象的引用對象的值，並不影響復制後的對象。
這裡需要注意：如果想將對象進行序列化，那麼對象本身，及其所有的自定義成員(類、結構)，都必須使用 Serializable 特性進行標記。所以，如果想讓上面的代碼運行，我們之前定義的類都需要進行這樣的標記：
RefPoint { }
關於特性(Attribute)，可以參考 .Net 中的反射(反射特性) 一文。
總結
本文簡單地對 C#中的類型作了一個回顧。
我們首先討論了 C#中的兩種類型--值類型和引用類型，隨後簡要回顧了 裝箱/拆箱 操作。接著，詳細討論了 C#中的對象判等。最後，我們討論了淺度復制 和 深度復制，並比較了它們之間不同。
記在這裡，以後學習
