概念的東西不能丟－深入理解C#實值型別和參考型別

文章目錄

• 1. 一般型別系統
• 2. 實值型別
• 3. 參考型別
• 4. 實值型別和參考型別在記憶體中的部署
• 5. 正確使用實值型別和參考型別
• 6. 總結

從概念上看，實值型別直接儲存其值，而參考型別儲存對其值的引用。這兩種類型儲存在記憶體的不同地方。在C#中，我們必須在設計類型的時候就決定類型執行個體的行為。這種決定非常重要，用《CLR via C#》作者Jeffrey Richter的話來說，“不理解參考型別和實值型別區別的程式員將會給代碼引入詭異的bug和效能問題（I believe that a developer who misunderstands the difference between reference types and value types will introduce subtle bugs and performance issues into their code.）”。這就要求我們正確理解和使用實值型別和參考型別。

• 1. 一般型別系統
• 2. 實值型別
• 3. 參考型別
• 4. 實值型別和參考型別在記憶體中的部署
  • 4.1 數組在記憶體中的部署
  • 4.2 實值型別和參考型別的嵌套
• 5. 正確使用實值型別和參考型別
  • 5.1 辨明實值型別和參考型別的使用場合
  • 5.2 將實值型別儘可能實現為具有常量性和原子性的類型
  • 5.3 確保0為實值型別的有效狀態
  • 5.4 盡量減少裝箱和拆箱
• 6. 總結
• 7. 參考

1. 一般型別系統

C#中，變數是值還是引用僅取決於其資料類型。

C#的基礎資料型別 (Elementary Data Type)都以平台無關的方式來定義。C#的預定義類型並沒有內建於語言中，而是內建於.NET Framework中。.NET使用一般型別系統（CTS）定義了可以在中繼語言（IL）中使用的預定義資料類型，所有面向.NET的語言都最終被編譯為IL，即編譯為基於CTS類型的代碼。

例如，在C#中聲明一個int變數時，聲明的實際上是CTS中System.Int32的一個執行個體。這具有重要的意義：

• 確保IL上的強制型別安全；
• 實現了不同.NET語言的互通性；
• 所有的資料類型都是對象。它們可以有方法，屬性，等。例如：

int i;
i = 1;
string s;
s = i.ToString();

MSDN的這張圖說明了CTS中各個類型是如何相關的。注意，類型的執行個體可以只是實值型別或自描述類型，即使這些類型有子類別也是如此。

2. 實值型別

C#的所有實值型別均隱式派生自System.ValueType：

• 結構體：struct（直接派生於System.ValueType）；
  • 數實值型別：
    • 整型：sbyte（System.SByte的別名），short（System.Int16），int（System.Int32），long（System.Int64），byte（System.Byte），ushort（System.UInt16），uint（System.UInt32），ulong（System.UInt64），char（System.Char）；
    • 浮點型：float（System.Single），double（System.Double）；
    • 用於財務計算的高精度decimal型：decimal（System.Decimal）。
  • bool型：bool（System.Boolean的別名）；
  • 使用者定義的結構體（派生於System.ValueType）。
• 枚舉：enum（派生於System.Enum）；
• 可空類型（派生於System.Nullable<T>泛型結構體，T?實際上是System.Nullable<T>的別名）。

每種實值型別均有一個隱式的預設建構函式來初始化該類型的預設值。例如：

int i = new int();

等價於：

Int32 i = new Int32();

等價於：

int i = 0;

等價於：

Int32 i = 0;

使用new運算子時，將調用特定類型的預設建構函式並對變數賦以預設值。在上例中，預設建構函式將值0賦給了i。MSDN上有完整的預設值表。

關於int和Int32的細節，在我的另一篇文章中有詳細解釋：《理解C#中的System.Int32和int》。

所有的實值型別都是密封（seal）的，所以無法派生出新的實值型別。

值得注意的是，System.ValueType直接派生於System.Object。即System.ValueType本身是一個類類型，而不是實值型別。其關鍵在於ValueType重寫了Equals()方法，從而對實值型別按照執行個體的值來比較，而不是引用地址來比較。

可以用Type.IsValueType屬性來判斷一個類型是否為實值型別：

TestType testType = new TestType ();
if (testTypetype.GetType().IsValueType)
{
Console.WriteLine("{0} is value type.", testType.ToString());
}

3. 參考型別

C#有以下一些參考型別：

• 數組（派生於System.Array）
• 使用者用定義的以下類型：
  • 類：class（派生於System.Object）；
  • 介面：interface（介面不是一個“東西”，所以不存在派生於何處的問題。Anders在《C# Programming Language》中說，介面只是表示一種約定[contract]）；
  • 委託：delegate（派生於System.Delegate）。
• object（System.Object的別名）；
• 字串：string（System.String的別名）。

可以看出：

• 參考型別與實值型別相同的是，結構體也可以實現介面；
• 參考型別可以派生出新的類型，而實值型別不能；
• 參考型別可以包含null值，實值型別不能（可空類型功能允許將 null 賦給實值型別）；
• 參考型別變數的賦值只複製對對象的引用，而不複製對象本身。而將一個實值型別變數賦給另一個實值型別變數時，將複製包含的值。

對於最後一條，經常混淆的是string。我曾經在一本書的一個早期版本上看到String變數比string變數效率高；我還經常聽說String是參考型別，string是實值型別，等等。例如：

string s1 = "Hello, ";
string s2 = "world!";
string s3 = s1 + s2;//s3 is "Hello, world!"

這確實看起來像一個實值型別的賦值。再如：

string s1 = "a";
string s2 = s1;
s1 = "b";//s2 is still "a"

改變s1的值對s2沒有影響。這更使string看起來像實值型別。實際上，這是運算子多載的結果，當s1被改變時，.NET在託管堆上為s1重新分配了記憶體。這樣的目的，是為了將做為參考型別的string實現為通常語義下的字串。

4. 實值型別和參考型別在記憶體中的部署

經常聽說，並且經常在書上看到：實值型別部署在棧上，參考型別部署在託管堆上。實際上並沒有這麼簡單。

MSDN上說：託管堆上部署了所有參考型別。這很容易理解。當建立一個應用類型變數時：

object reference = new object();

關鍵字new將在託管堆上分配記憶體空間，並返回一個該記憶體空間的地址。左邊的reference位於棧上，是一個引用，儲存著一個記憶體位址；而這個地址指向的記憶體（位於託管堆）裡儲存著其內容（一個System.Object的執行個體）。下面為了方便，簡稱參考型別部署在託管推上。

再來看實值型別。《C#語言規範》上的措辭是“結構體不要求在堆上分配記憶體（However, unlike classes, structs are value types and do not require heap allocation）”而不是“結構體在棧上分配記憶體”。這不免容易讓人感到困惑：實值型別究竟部署在什麼地方？

4.1 數組

考慮數組：

int[] reference = new int[100];

根據定義，數組都是參考型別，所以int數組當然是參考型別（即reference.GetType().IsValueType為false）。

而int數組的元素都是int，根據定義，int是實值型別（即reference[i].GetType().IsValueType為true）。那麼參考型別數組中的實值型別元素究竟位於棧還是堆？

如果用WinDbg去看reference[i]在記憶體中的具體位置，就會發現它們並不在棧上，而是在託管堆上。

實際上，對於數組：

TestType[] testTypes = new TestType[100];

如果TestType是實值型別，則會一次在託管堆上為100個實值型別的元素分配儲存空間，並自動初始化這100個元素，將這100個元素儲存到這塊記憶體裡。

如果TestType是參考型別，則會先在託管堆為testTypes分配一次空間，並且這時不會自動初始化任何元素（即testTypes[i]均為null）。等到以後有代碼初始化某個元素的時候，這個參考型別元素的儲存空間才會被分配在託管堆上。

4.2 類型嵌套

更容易讓人困惑的是參考型別包含實值型別，以及實值型別包含參考型別的情況：

public class ReferenceTypeClass
{
private int _valueTypeField;
public ReferenceTypeClass()
{
_valueTypeField = 0;
}
public void Method()
{
int valueTypeLocalVariable = 0;
}
}
ReferenceTypeClass referenceTypeClassInstance = new ReferenceTypeClass();//Where is _valueTypeField?
referenceTypeClassInstance.Method();//Where is valueTypeLocalVariable?
public struct ValueTypeStruct
{
private object _referenceTypeField;
public ValueTypeStruct()
{
_referenceTypeField = new object();
}
public void Method()
{
object referenceTypeLocalVariable = new object();
}
}
ValueTypeStruct valueTypeStructInstance = new ValueTypeStruct();//Where is _referenceTypeField？
valueTypeStructInstance.Method();//Where is referenceTypeLocalVariable?

單看valueTypeStructInstance，這是一個結構體執行個體，感覺似乎是整塊扔到棧上的。但是欄位_referenceTypeField是參考型別，局部變數referenceTypeLocalVarible也是參考型別。

referenceTypeClassInstance也有同樣的問題，referenceTypeClassInstance本身是參考型別，似乎應該整塊部署在託管堆上。但欄位_valueTypeField是實值型別，局部變數valueTypeLocalVariable也是實值型別，它們究竟是在棧上還是在託管堆上？

規律是：

• 參考型別部署在託管堆上；
• 實值型別總是分配在它聲明的地方：作為欄位時，跟隨其所屬的變數（執行個體）儲存；作為局部變數時，儲存在棧上。

我們來分析一下上面的代碼。對於參考型別執行個體，即referenceTypeClassInstance：

• 從上下文看，referenceTypeClassInstance是一個局部變數，所以部署在託管堆上，並被棧上的一個引用所持有；
• 實值型別欄位_valueTypeField屬於參考型別執行個體referenceTypeClassInstance的一部分，所以跟隨參考型別執行個體referenceTypeClassInstance部署在託管堆上（有點類似於數組的情形）；
• valueTypeLocalVariable是實值型別局部變數，所以部署在棧上。

而對於實值型別執行個體，即valueTypeStruct：

• 根據上下文，實值型別執行個體valueTypeStructInstance本身是一個局部變數而不是欄位，所以位於棧上；
• 其參考型別欄位_referenceTypeField不存在跟隨的問題，必然部署在託管堆上，並被一個引用所持有（該引用是valueTypeStruct的一部分，位於棧）；
• 其參考型別局部變數referenceTypeLocalVariable顯然部署在託管堆上，並被一個位於棧的引用所持有。

所以，簡單地說“實值型別儲存在棧上，參考型別儲存在託管堆上”是不對的。必須具體情況具體分析。

5. 正確使用實值型別和參考型別

這一部分主要參考《Effective C#》，並非本人原創，希望能讓你加深對實值型別和參考型別的理解。

5.1 辨明實值型別和參考型別的使用場合

C#中，我們用struct/class來聲明一個類型為實值型別/參考型別。

考慮下面的例子：

TestType[] testTypes = new TestType[100];

如果TestTye是實值型別，則只需要一次分配，大小為TestTye的100倍。而如果TestTye是參考型別，剛開始需要100次分配，分配後數組的各元素值為null，然後再初始化100個元素，結果總共需要進行101次分配。這將消耗更多的時間，造成更多的記憶體片段。所以，如果類型的職責主要是儲存資料，實值型別比較合適。

一般來說，實值型別（不支援多態）適合儲存供 C#應用程式操作的資料，而參考型別（支援多態）應該用於定義應用程式的行為。

通常我們建立的參考型別總是多於實值型別。如果以下問題的回答都為yes，那麼我們就應該建立為實值型別：

• 該類型的主要職責是否用於資料存放區？
• 該類型的共有借口是否完全由一些資料成員存取屬性定義？
• 是否確信該類型永遠不可能有子類？
• 是否確信該類型永遠不可能具有多態行為？

5.2 將實值型別儘可能實現為具有常量性和原子性的類型

具有常量性的類型很簡單：

• 如果構造的時候驗證了參數的有效性，之後就一直有效；
• 省去了許多錯誤檢查，因為禁止更改；
• 確保安全執行緒，因為多個reader訪問到同樣的內容；
• 可以安全地暴露給外界，因為調用者不能更改對象的內部狀態。

具有原子性的類型都是單一的實體，我們通常會直接替換一個原子類型的整個內容。

下面是一個典型的可變類型：

public struct Address
{
private string _city;
private string _province;
private int _zipCode;
public string City
{
get { return _city; }
set { _city = value; }
}
public string Province
{
get { return _province; }
set
{
ValidateProvince(value);
_province = value;
}
}
public int ZipCode
{
get { return _zipCode; }
set
{
ValidateZipCode(value);
_zipCode = value;
}
}
}

下面建立一個執行個體：

Address address = new Address();
address.City = "Chengdu";
address.Province = "Sichuan";
address.ZipCode = 610000;

然後更改這個執行個體：

address.City = "Nanjing"; //Now Province and ZipCode are invalid
address.ZipCode = 210000; //Now Province is still invalid
address.Province = "Jiangsu";

可見，內部狀態的改變意味著可能違反對象的不變式（invariant），至少是臨時的違反。如果上面是一個多線程的程式，那麼在 City更改的過程中，另一個線程可能看到不一致的資料檢視。如果不是多線程的程式，也有問題：

• 當ZipCode的值無效而拋出異常時，對象僅作了一部分改變，因此處於無效的狀態，為了修複這個問題，需要在Address中添加相當多的內部校正代碼；
• 為了實現異常安全，我們需要在所有改變多個欄位的客戶代碼處放上防禦性的代碼；
• 安全執行緒也要求我們在每一個屬性的訪問器上添加線程同步檢查。

顯然，這是一個相當可觀的工作量。下面我們把Address實現為常量類型：

public struct Address
{
private string _city;
private string _province;
private int _zipCode;
public Address (string city, string province, int zipCode)
{
_city = city;
_province = province;
_zipCode = zipCode;
ValidateProvince(province);
ValidateZipCode(zipCode);
}
public string City
{
get { return _city; }
}
public string Province
{
get { return _province; }
}
public int ZipCode
{
get { return _zipCode; }
}
}

如果要改變Address，不能修改現有的執行個體，只能建立一個新的執行個體：

Address address = new Address("Chengdu", "Sichuan", 610000);//create a instance
address = new Address("Nanjing", "Jiangsu", 210000);//modify the instance

address將不存在任何無效的臨時狀態。那些臨時狀態只存在於Address的建構函式執行過程中。這樣一來，Address是異常安全的，也是安全執行緒的。

5.3 確保0為實值型別的有效狀態

.NET的預設初始化機制會將參考型別設定為二進位意義上的0，即null。而對於實值型別，不論我們是否提供建構函式，都會有一個預設的建構函式，將其設定為0。

一種典型的情況是枚舉：

public enum Sex
{
Male = 1;
Female = 2;
}

然後用做實值型別的成員：

public struct Employee
{
private Sex _sex;
//other
}

建立Employee結構體將得到一個無效的Sex欄位：

Employee employee = new Employee ();

employee的_sex是無效的，因為其為0。我們應該將0作為一個為初始化的值明確表示出來：

public Sex
{
None = 0;
Male = 1;
Female = 2;
}

如果實值型別中包含參考型別，會出現另一種初始化問題：

public struct ErrorLog
{
private string _message;
//other
}

然後建立一個ErrorLog：

ErrorLog errorLog = new ErrorLog ();

errorLog的_message欄位將是一個Null 參考。我們應該通過一個屬性來將_message暴露給客戶代碼，從而使該問題限定在ErrorLog 的內部：

public struct ErrorLog
{
private string _message;
public string Message
{
get
{
return (_message ! = null) ? _message : string.Empty;
}
set { _message = value; }
}
//other
}

5.4 盡量減少裝箱和拆箱

裝箱指把一個實值型別放入一個未具名類型的參考型別中，比如：

int valueType = 0;
object referenceType = i;//boxing

拆箱則是從前面的裝箱對象中取出實值型別：

object referenceType;
int valueType = (int)referenceType;//unboxing

裝箱和拆箱是比較耗費效能的，還會引入一些詭異的bug，我們應當避免裝箱和拆箱。

裝箱和拆箱最大的問題是會自動發生。比如：

Console.WriteLine("A few numbers: {0}, {1}.", 25, 32);

其中，Console.WriteLine()接收的參數類型是(string，object，object)。因此，實際上會執行以下操作：

int i = 25;
obeject o = i;//boxing

然後把o傳給WriteLine()方法。在WriteLine()方法的內部，為了調用i上的ToString()方法，又會執行：

int i = (int)o;//unboxing
string output = i,ToString();

所以正確的做法應該是：

Console.WriteLine("A few numbers: {0}, {1}.", 25.ToString(), 32.ToString());

25.ToString()只是執行一個方法並返回一個參考型別，不存在裝箱/拆箱的問題。

另一個典型的例子是ArryList的使用：

public struct Employee
{
private string _name;
public Employee(string name)
{
_name = name;
}
public string Name
{
get { return _name; }
set { _name = value; }
}
public override string ToString()
{
return _name;
}
}
ArrayList employees = new ArrayList();
employees.Add(new Employee("Old Name"));//boxing
Employee ceo = (Employee)employees[0];//unboxing
ceo.Name = "New Name";//employees[0].ToString() is still "Old Name"

上面的代碼不僅存在效能的問題，還容易導致錯誤發生。

在這種情況下，更好的做法是使用泛型集合：

List<Employee> employees = new List<Employee>();

由於List<T>是強型別的集合，employees.Add()方法不進行類型轉換，所以不存在裝箱/拆箱的問題。

6. 總結

C#中，變數是值還是引用僅取決於其資料類型。

C#的實值型別包括：結構體（數實值型別，bool型，使用者定義的結構體），枚舉，可空類型。

C#的參考型別包括：數組，使用者定義的類、介面、委託，object，字串。

數組的元素，不管是參考型別還是實值型別，都儲存在託管堆上。

參考型別在棧中儲存一個引用，其實際的儲存位置位於託管堆。為了方便，本文簡稱參考型別部署在託管推上。

實值型別總是分配在它聲明的地方：作為欄位時，跟隨其所屬的變數（執行個體）儲存；作為局部變數時，儲存在棧上。

實值型別在記憶體管理方面具有更好的效率，並且不支援多態，適合用作儲存資料的載體；參考型別支援多態，適合用於定義應用程式的行為。

應該儘可能地將實值型別實現為具有常量性和原子性的類型。

應該儘可能地確保0為實值型別的有效狀態。

應該儘可能地減少裝箱和拆箱。