|
|
引言
本文之初的目的是講述設計模式中的 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
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
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#中的對象判等。最后，我們討論了淺度復制和 深度復制，并比較了它們之間不同。
希望這篇文章能給你帶來幫助！
鄭重聲明：本文版權歸原作者所有，轉載文章僅為傳播更多信息之目的，如作者信息標記有誤，請第一時間聯系我們修改或刪除，多謝。
