引言

本文之初的目的是講述設(shè)計模式中的 Prototype(原型)模式，但是如果想較清楚地弄明白這個模式，需要了解對象克隆(Object Clone)，Clone其實也就是對象復(fù)制。復(fù)制又分為了淺度復(fù)制(Shallow Copy)和深度復(fù)制(Deep Copy)，淺度復(fù)制 和 深度復(fù)制又是以 如何復(fù)制引用類型成員來劃分的。由此又引出了 引用類型和 值類型，以及相關(guān)的對象判等、裝箱、拆箱等基礎(chǔ)知識。

于是我干脆新起一篇，從最基礎(chǔ)的類型開始自底向上寫起了。我僅僅想將對于這個主題的理解表述出來，一是總結(jié)和復(fù)習(xí)，二是交流經(jīng)驗，或許有地方我理解的有偏差，希望指正。如果前面基礎(chǔ)的內(nèi)容對你來說過于簡單，可以跳躍閱讀。

值類型和引用類型

我們先簡單回顧一下C#中的類型系統(tǒng)。C# 中的類型一共分為兩類，一類是值類型(Value Type)，一類是引用類型(Reference Type)。值類型 和 引用類型是以它們在計算機內(nèi)存中是如何被分配的來劃分的。值類型包括 結(jié)構(gòu)和枚舉，引用類型包括類、接口、委托 等。還有一種特殊的值類型，稱為簡單類型(Simple Type)，比如 byte，int等，這些簡單類型實際上是FCL類庫類型的別名，比如聲明一個int類型，實際上是聲明一個System.Int32結(jié)構(gòu)類型。因此，在Int32類型中定義的操作，都可以應(yīng)用在int類型上，比如 “123.Equals(2)”。

所有的 值類型 都隱式地繼承自 System.ValueType類型(注意System.ValueType本身是一個類類型)，System.ValueType和所有的引用類型都繼承自 System.Object基類。你不能顯示地讓結(jié)構(gòu)繼承一個類，因為C#不支持多重繼承，而結(jié)構(gòu)已經(jīng)隱式繼承自ValueType。

NOTE：堆棧(stack)是一種后進先出的數(shù)據(jù)結(jié)構(gòu)，在內(nèi)存中，變量會被分配在堆棧上來進行操作。堆(heap)是用于為類型實例(對象)分配空間的內(nèi)存區(qū)域，在堆上創(chuàng)建一個對象，會將對象的地址傳給堆棧上的變量(反過來叫變量指向此對象，或者變量引用此對象)。

1.值類型

當(dāng)聲明一個值類型的變量(Variable)的時候，變量本身包含了值類型的全部字段，該變量會被分配在線程堆棧(Thread Stack)上。

假如我們有這樣一個值類型，它代表了直線上的一點：

public struct ValPoint {
    public int x;

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

當(dāng)我們在程序中寫下這樣的一條變量的聲明語句時：

ValPoint vPoint1;

實際產(chǎn)生的效果是聲明了vPoint1變量，變量本身包含了值類型的所有字段(即你想要的所有數(shù)據(jù))。

NOTE：如果觀察MSIL代碼，會發(fā)現(xiàn)此時變量還沒有被壓到棧上，因為.maxstack(最高棧數(shù)) 為0。并且沒有看到入棧的指令，這說明只有對變量進行操作，才會進行入棧。

因為變量已經(jīng)包含了值類型的所有字段，所以，此時你已經(jīng)可以對它進行操作了(對變量進行操作，實際上是一系列的入棧、出棧操作)。

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

NOTE：如果vPoint1是一個引用類型(比如class)，在運行時會拋出NullReferenceException異常。因為vPoint是一個值類型，不存在引用，所以永遠也不會拋出NullReferenceException。

如果你不對vPoint.x進行賦值，直接寫Console.WriteLine(vPoint.x)，則會出現(xiàn)編譯錯誤：使用了未賦值的局部變量。產(chǎn)生這個錯誤是因為.NET的一個約束：所有的元素使用前都必須初始化。比如這樣的語句也會引發(fā)這個錯誤：

int i;
Console.WriteLine(i);

解決這個問題我們可以通過這樣一種方式：編譯器隱式地會為結(jié)構(gòu)類型創(chuàng)建了無參數(shù)構(gòu)造函數(shù)。在這個構(gòu)造函數(shù)中會對結(jié)構(gòu)成員進行初始化，所有的值類型成員被賦予0或相當(dāng)于0的值(針對Char類型)，所有的引用類型被賦予null值。(因此，Struct類型不可以自行聲明無參數(shù)的構(gòu)造函數(shù))。所以，我們可以通過隱式聲明的構(gòu)造函數(shù)去創(chuàng)建一個ValPoint類型變量：

ValPoint vPoint1 = new ValPoint();
Console.WriteLine(vPoint.x); // 輸出為0

我們將上面代碼第一句的表達式由“=”分隔拆成兩部分來看：

• 左邊 ValPoint vPoint1，在堆棧上創(chuàng)建一個ValPoint類型的變量vPoint，結(jié)構(gòu)的所有成員均未賦值。在進行new ValPoint()之前，將vPoint壓到棧上。
• 右邊new ValPoint()，new 操作符不會分配內(nèi)存，它僅僅調(diào)用ValPoint結(jié)構(gòu)的默認(rèn)構(gòu)造函數(shù)，根據(jù)構(gòu)造函數(shù)去初始化vPoint結(jié)構(gòu)的所有字段。

注意上面這句，new 操作符不會分配內(nèi)存，僅僅調(diào)用ValPoint結(jié)構(gòu)的默認(rèn)構(gòu)造函數(shù)去初始化vPoint的所有字段。那如果我這樣做，又如何解釋呢？

Console.WriteLine((new ValPoint()).x);     // 正常，輸出為0

在這種情況下，會創(chuàng)建一個臨時變量，然后使用結(jié)構(gòu)的默認(rèn)構(gòu)造函數(shù)對此臨時變量進行初始化。我知道我這樣很沒有說服力，所以我們來看下MS IL代碼，為了節(jié)省篇幅，我只節(jié)選了部分：

.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初始化此變量

那么當(dāng)我們使用自定義的構(gòu)造函數(shù)時，ValPoint vPoint = new ValPoint(10)，又會怎么樣呢？通過下面的代碼我們可以看出，實際上會使用call指令(instruction)調(diào)用我們自定義的構(gòu)造函數(shù)，并傳遞10到參數(shù)列表中。

.locals init ([0] valuetype Prototype.ValPoint vPoint)
IL_0000:  nop
IL_0001:  ldloca.s   vPoint      // 將 vPoint 壓棧
IL_0003:  ldc.i4.s   10          // 將 10 壓棧
// 調(diào)用構(gòu)造函數(shù)，傳遞參數(shù)
IL_0005:  call       instance void Prototype.ValPoint::.ctor(int32)  

對于上面的MSIL代碼不清楚不要緊，有的時候知道結(jié)果就已經(jīng)夠用了。關(guān)于MSIL代碼，有空了我會為大家翻譯一些好的文章。

2.引用類型

當(dāng)聲明一個引用類型變量的時候，該引用類型的變量會被分配到堆棧上，這個變量將用于保存位于堆上的該引用類型的實例的內(nèi)存地址，變量本身不包含對象的數(shù)據(jù)。此時，如果僅僅聲明這樣一個變量，由于在堆上還沒有創(chuàng)建類型的實例，因此，變量值為null，意思是不指向任何類型實例(堆上的對象)。對于變量的類型聲明，用于限制此變量可以保存的類型。

如果我們有一個這樣的類，它依然代表直線上的一點：

public class RefPoint {
    public int x;

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

當(dāng)我們僅僅寫下一條聲明語句：

RefPoint rPoint1;

它的效果就向下圖一樣，僅僅在堆棧上創(chuàng)建一個不包含任何數(shù)據(jù)，也不指向任何對象(不包含創(chuàng)建再堆上的對象的地址)的變量。

而當(dāng)我們使用new操作符時：

rPoint1= new RefPoint(1);

會發(fā)生這樣的事：

1. 在應(yīng)用程序堆(Heap)上創(chuàng)建一個引用類型(Type)的實例(Instance)或者叫對象(Object)，并為它分配內(nèi)存地址。
2. 自動傳遞該實例的引用給構(gòu)造函數(shù)。(正因為如此，你才可以在構(gòu)造函數(shù)中使用this來訪問這個實例。)
3. 調(diào)用該類型的構(gòu)造函數(shù)。
4. 返回該實例的引用(內(nèi)存地址)，賦值給rPoint變量。

3.關(guān)于簡單類型

很多文章和書籍中在講述這類問題的時候，總是喜歡用一個int類型作為值類型 和一個Object類型 作為引用類型來作說明。本文中將采用自定義的一個 結(jié)構(gòu) 和 類 分別作值類型和引用類型的說明。這是因為簡單類型(比如int)有一些CLR實現(xiàn)了的行為，這些行為會讓我們對一些操作產(chǎn)生誤解。

舉個例子，如果我們想比較兩個int類型是否相等，我們會通常這樣：

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

但是，對于自定義的值類型，比如結(jié)構(gòu)，就不能用 “==”來判斷它們是否相等，而需要在變量上使用Equals()方法來完成。

再舉個例子，大家知道string是一個引用類型，而我們比較它們是否相等，通常會這樣做：

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

實際上，在后面我們就會看到，當(dāng)使用“==”對引用類型變量進行比較的時候，比較的是它們是否指向的堆上同一個對象。而上面a、b指向的顯然是不同的對象，只是對象包含的值相同，所以可見，對于string類型，CLR對它們的比較實際上比較的是值，而不是引用。

為了避免上面這些引起的混淆，在對象判等部分將采用自定義的結(jié)構(gòu)和類來分別說明。

裝箱和拆箱

這部分內(nèi)容可深可淺，本文只簡要地作一個回顧。簡單來說，裝箱 就是 將一個值類型轉(zhuǎn)換成等值的引用類型。它的過程分為這樣幾步：

1. 在堆上為新生成的對象(該對象包含數(shù)據(jù)，對象本身沒有名稱)分配內(nèi)存。
2. 將 堆棧上 值類型變量的值拷貝到 堆上的對象 中。
3. 將堆上創(chuàng)建的對象的地址返回給引用類型變量(從程序員角度看，這個變量的名稱就好像堆上對象的名稱一樣)。

當(dāng)我們運行這樣的代碼時：

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                   // 最高棧數(shù)是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裝箱(復(fù)制值到堆，返回地址)
  IL_000a:  stloc.1           //#5 將返回值賦給變量 boxed
  IL_000b:  ldloc.1           // 將 boxed 壓棧
// 調(diào)用WriteLine()方法
  IL_000c:  call       void [mscorlib]System.Console::WriteLine(object)
  IL_0011:  nop
  IL_0012:  ret
} // end of method Program::Main

而拆箱則是將一個 已裝箱的引用類型 轉(zhuǎn)換為值類型：

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

需要注意的是：UnBox 操作需要顯示聲明拆箱后轉(zhuǎn)換的類型。它分為兩步來完成：

1. 獲取已裝箱的對象的地址。
2. 將值從堆上的對象中拷貝到堆棧上的值變量中。

對象判等

因為我們要提到對象克隆(復(fù)制)，那么，我們應(yīng)該有辦法知道復(fù)制前后的兩個對象是否相等。所以，在進行下面的章節(jié)前，我們有必要先了解如何進行對象判等。

NOTE：有機會較深入地研究這部分內(nèi)容，需要感謝 微軟的開源 以及 VS2008 的FCL調(diào)試功能。關(guān)于如何調(diào)試 FCL 代碼，請參考 Configuring Visual Studio to Debug .NET Framework Source Code。

我們先定義用作范例的兩個類型，它們代表直線上的一點，唯一區(qū)別是一個是引用類型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)，靜態(tài)方法 Equals(object objA, object objB)，靜態(tài)方法 ReferenceEquals(object objA, object objB) 來進行對象的判等。

我們先看看這三個方法，注意我在代碼中用 #number 標(biāo)識的地方，后文中我會直接引用：

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，所以，在后文中，除非必要，我們統(tǒng)一使用 objA == objB(省去了 ReferenceEquals 方法)。另外，為了范例簡單，我們不考慮對象為null的情況。

我們來看第一段代碼：

// 復(fù)制對象引用
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);

在閱讀本文中，應(yīng)該時刻在腦子里構(gòu)思一個堆棧，一個堆，并思考著每條語句會在這兩種結(jié)構(gòu)上產(chǎn)生怎么樣的效果。在這段代碼中，產(chǎn)生的效果是：在堆上創(chuàng)建了一個新的RefPoint類型的實例(對象)，并將它的x字段初始化為1；在堆棧上創(chuàng)建變量rPoint1，rPoint1保存堆上這個對象的地址；將rPoint1 賦值給 rPoint2時，此時并沒有在堆上創(chuàng)建一個新的對象，而是將之前創(chuàng)建的對象的地址復(fù)制到了rPoint2。此時，rPoint1和rPoint2指向了堆上同一個對象。

從 ReferenceEquals()這個方法名就可以看出，它判斷兩個引用變量是不是指向了同一個變量，如果是，那么就返回true。這種相等叫做 引用相等(rPoint1 == rPoint2 等效于 ReferenceEquals)。因為它們指向的是同一個對象，所以對rPoint1的操作將會影響rPoint2：

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

我們再看引用類型的第二種情況：

//創(chuàng)建新引用類型的對象，其成員的值相等
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

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

2.簡單值類型判等

注意本節(jié)的標(biāo)題：簡單值類型判等，這個簡單是如何定義的呢？如果值類型的成員僅包含值類型，那么我們暫且管它叫 簡單值類型，如果值類型的成員包含引用類型，我們管它叫復(fù)雜值類型。(注意，這只是本文中為了說明我個人作的定義。)

應(yīng)該還記得我們之前提過，值類型都會隱式地繼承自 System.ValueType類型，而ValueType類型覆蓋了基類System.Object類型的Equals()方法，在值類型上調(diào)用Equals()方法，會調(diào)用ValueType的Equals()。所以，我們看看這個方法是什么樣的，依然用 #number 標(biāo)識后面會引用的地方。

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;
}

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

// 復(fù)制結(jié)構(gòu)變量
ValPoint vPoint1 = new ValPoint(1);
ValPoint vPoint2 = vPoint1;

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

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

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

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

而裝箱的過程，我們在前面已經(jīng)講述過，上面的操作等于是在堆上創(chuàng)建了兩個對象，對象包含的內(nèi)容相同(地址不同)，然后將對象地址分別返回給堆棧上的 boxPoint1和boxPoint2，再去比較boxPoint1和boxPoint2是否指向同一個對象，顯然不是，所以返回false。

我們繼續(xù)，添加下面這段代碼：

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

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

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

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

3. 復(fù)雜值類型判等

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

/* 結(jié)構(gòu)類型 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);   // 此時已經(jīng)存在一個裝箱操作，調(diào)用ValueType.Equals()
Console.WriteLine(result);      // 返回True

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

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

好了，我們現(xiàn)在看看實際的過程，是不是如同我們料想的那樣，為了避免頻繁的拖動滾動條查看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;
}

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

對象復(fù)制

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

1.淺度復(fù)制

淺度復(fù)制 和 深度復(fù)制 是以如何復(fù)制對象的成員(member)來劃分的。一個對象的成員有可能是值類型，有可能是引用類型。當(dāng)我們對對象進行一個淺度復(fù)制的時候，對于值類型成員，會復(fù)制其本身(值類型變量本身包含了所有數(shù)據(jù)，復(fù)制時進行按位拷貝)；對于引用類型成員(注意它會引用另一個對象)，僅僅復(fù)制引用，而不創(chuàng)建其引用的對象。結(jié)果就是：新對象的引用成員和 復(fù)制對象的引用成員 指向了同一個對象。

繼續(xù)我們上面的例子，如果我們想要進行復(fù)制的對象(RefLine)是這樣定義的，(為了避免look up，我在這里把代碼再貼過來)：

// 將要進行 淺度復(fù)制 的對象，注意為 引用類型
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;
    }
}

我們先創(chuàng)建一個想要復(fù)制的對象：

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

它所產(chǎn)生的實際效果是(堆棧上僅考慮line部分)：

那么當(dāng)我們對它復(fù)制時，就會像這樣(newLine是指向新拷貝的對象的指針，在代碼中體現(xiàn)為一個引用類型的變量)：

按照這個定義，再回憶上面我們講到的內(nèi)容，可以推出這樣一個結(jié)論：當(dāng)復(fù)制一個結(jié)構(gòu)類型成員的時候，直接創(chuàng)建一個新的結(jié)構(gòu)類型變量，然后對它賦值，就相當(dāng)于進行了一個淺度復(fù)制，也可以認(rèn)為結(jié)構(gòu)類型隱式地實現(xiàn)了淺度復(fù)制。如果我們將上面的RefLine定義為一個結(jié)構(gòu)(Struct)，結(jié)構(gòu)類型叫ValLine，而不是一個類，那么對它進行淺度復(fù)制就可以這樣：

ValLine newLine = line;

實際的效果圖是這樣：

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

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

現(xiàn)在我們來做一個測試：

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

可見，復(fù)制后的對象和原先對象成了連體嬰，它們的引用成員字段依然引用堆上的同一個對象。

2.深度復(fù)制

其實到現(xiàn)在你可能已經(jīng)想到什么時深度復(fù)制了，深度復(fù)制就是將引用成員指向的對象也進行復(fù)制。實際的過程是創(chuàng)建新的引用成員指向的對象，然后復(fù)制對象包含的數(shù)據(jù)。

深度復(fù)制可能會變得非常復(fù)雜，因為引用成員指向的對象可能包含另一個引用類型成員，最簡單的例子就是一個線性鏈表。

如果一個對象的成員包含了對于線性鏈表結(jié)構(gòu)的一個引用，淺度復(fù)制 只復(fù)制了對頭結(jié)點的引用，深度復(fù)制 則會復(fù)制鏈表本身，并復(fù)制每個結(jié)點上的數(shù)據(jù)。

考慮我們之前的例子，如果我們期望進行一個深度復(fù)制，我們的Clone()方法應(yīng)該如何實現(xiàn)呢？

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

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

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

可見，兩個對象的引用成員已經(jīng)分離，改變原對象的引用對象的值，并不影響復(fù)制后的對象。

這里需要注意：如果想將對象進行序列化，那么對象本身，及其所有的自定義成員(類、結(jié)構(gòu))，都必須使用Serializable特性進行標(biāo)記。所以，如果想讓上面的代碼運行，我們之前定義的類都需要進行這樣的標(biāo)記：

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

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

總結(jié)

本文簡單地對C#中的類型作了一個回顧。

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

希望這篇文章能給你帶來幫助！

NET技術(shù)：C# 類型基礎(chǔ)，轉(zhuǎn)載需保留來源！

鄭重聲明：本文版權(quán)歸原作者所有，轉(zhuǎn)載文章僅為傳播更多信息之目的，如作者信息標(biāo)記有誤，請第一時間聯(lián)系我們修改或刪除，多謝。