快捷導(dǎo)航

C#值類型和引用類型的深入理解

更新時間：2014年01月22日 09:10:45 作者：

本篇文章主要是對C#中值類型和引用類型進行了詳細的分析介紹，需要的朋友可以過來參考下，希望對大家有所幫助

從概念上看，值類型直接存儲其值，而引用類型存儲對其值的引用。這兩種類型存儲在內(nèi)存的不同地方。在C#中，我們必須在設(shè)計類型的時候就決定類型實例的行為。這種決定非常重要，用《CLR via C#》作者Jeffrey Richter的話來說，“不理解引用類型和值類型區(qū)別的程序員將會給代碼引入詭異的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. 通用類型系統(tǒng)

C#中，變量是值還是引用僅取決于其數(shù)據(jù)類型。
C#的基本數(shù)據(jù)類型都以平臺無關(guān)的方式來定義。C#的預(yù)定義類型并沒有內(nèi)置于語言中，而是內(nèi)置于.NET Framework中。.NET使用通用類型系統(tǒng)（CTS）定義了可以在中間語言（IL）中使用的預(yù)定義數(shù)據(jù)類型，所有面向.NET的語言都最終被編譯為 IL，即編譯為基于CTS類型的代碼。

例如，在C#中聲明一個int變量時，聲明的實際上是CTS中System.Int32的一個實例。這具有重要的意義：
確保IL上的強制類型安全；
實現(xiàn)了不同.NET語言的互操作性；
所有的數(shù)據(jù)類型都是對象。它們可以有方法，屬性，等。例如：
int i;
i = 1;
string s;
s = i.ToString();

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

2. 值類型

C#的所有值類型均隱式派生自System.ValueType：
結(jié)構(gòu)體：struct（直接派生于System.ValueType）；

數(shù)值類型：
整型：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）；
用于財務(wù)計算的高精度decimal型：decimal（System.Decimal）。
bool型：bool（System.Boolean的別名）；
用戶定義的結(jié)構(gòu)體（派生于System.ValueType）。
枚舉：enum（派生于System.Enum）；
可空類型（派生于System.Nullable<T>泛型結(jié)構(gòu)體，T?實際上是System.Nullable<T>的別名）。

每種值類型均有一個隱式的默認構(gòu)造函數(shù)來初始化該類型的默認值。例如：
int i = new int();

等價于：
Int32 i = new Int32();

等價于：
int i = 0;

等價于：
Int32 i = 0;

使用new運算符時，將調(diào)用特定類型的默認構(gòu)造函數(shù)并對變量賦以默認值。在上例中，默認構(gòu)造函數(shù)將值0賦給了i。MSDN上有完整的默認值表。

關(guān)于int和Int32的細節(jié)，在我的另一篇文章中有詳細解釋：《理解C#中的System.Int32和int》。

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

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

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

復(fù)制代碼代碼如下:

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

3. 引用類型

C#有以下一些引用類型：
數(shù)組（派生于System.Array）
用戶用定義的以下類型：
類：class（派生于System.Object）；
接口：interface（接口不是一個“東西”，所以不存在派生于何處的問題。Anders在《C# Programming Language》中說，接口只是表示一種約定[contract]）；
委托：delegate（派生于System.Delegate）。
object（System.Object的別名）；
字符串：string（System.String的別名）。

可以看出：
引用類型與值類型相同的是，結(jié)構(gòu)體也可以實現(xiàn)接口；
引用類型可以派生出新的類型，而值類型不能；
引用類型可以包含null值，值類型不能（可空類型功能允許將 null 賦給值類型）；
引用類型變量的賦值只復(fù)制對對象的引用，而不復(fù)制對象本身。而將一個值類型變量賦給另一個值類型變量時，將復(fù)制包含的值。

對于最后一條，經(jīng)?；煜氖莝tring。我曾經(jīng)在一本書的一個早期版本上看到String變量比string變量效率高；我還經(jīng)常聽說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看起來像值類型。實際上，這是運算符重載的結(jié)果，當s1被改變時，.NET在托管堆上為s1重新分配了內(nèi)存。這樣的目的，是為了將做為引用類型的string實現(xiàn)為通常語義下的字符串。

4. 值類型和引用類型在內(nèi)存中的部署

經(jīng)常聽說，并且經(jīng)常在書上看到：值類型部署在棧上，引用類型部署在托管堆上。實際上并沒有這么簡單。

MSDN上說：托管堆上部署了所有引用類型。這很容易理解。當創(chuàng)建一個應(yīng)用類型變量時：
object reference = new object();

關(guān)鍵字new將在托管堆上分配內(nèi)存空間，并返回一個該內(nèi)存空間的地址。左邊的reference位于棧上，是一個引用，存儲著一個內(nèi)存地址；而這個地址指向的內(nèi)存（位于托管堆）里存儲著其內(nèi)容（一個System.Object的實例）。下面為了方便，簡稱引用類型部署在托管推上。

再來看值類型?！禖#語言規(guī)范》上的措辭是“結(jié)構(gòu)體不要求在堆上分配內(nèi)存（However, unlike classes, structs are value types and do not require heap allocation）”而不是“結(jié)構(gòu)體在棧上分配內(nèi)存”。這不免容易讓人感到困惑：值類型究竟部署在什么地方？
4.1 數(shù)組

考慮數(shù)組：
int[] reference = new int[100];

根據(jù)定義，數(shù)組都是引用類型，所以int數(shù)組當然是引用類型（即reference.GetType().IsValueType為false）。

而int數(shù)組的元素都是int，根據(jù)定義，int是值類型（即reference[i].GetType().IsValueType為true）。那么引用類型數(shù)組中的值類型元素究竟位于棧還是堆？

如果用WinDbg去看reference[i]在內(nèi)存中的具體位置，就會發(fā)現(xiàn)它們并不在棧上，而是在托管堆上。

實際上，對于數(shù)組：
TestType[] testTypes = new TestType[100];

如果TestType是值類型，則會一次在托管堆上為100個值類型的元素分配存儲空間，并自動初始化這100個元素，將這100個元素存儲到這塊內(nèi)存里。

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

4.2 類型嵌套

更容易讓人困惑的是引用類型包含值類型，以及值類型包含引用類型的情況：

復(fù)制代碼代碼如下:

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，這是一個結(jié)構(gòu)體實例，感覺似乎是整塊扔到棧上的。但是字段_referenceTypeField是引用類型，局部變量referenceTypeLocalVarible也是引用類型。

referenceTypeClassInstance也有同樣的問題，referenceTypeClassInstance本身是引用類型，似乎應(yīng)該整塊部署在托管堆上。但字段_valueTypeField是值類型，局部變量valueTypeLocalVariable也是值類型，它們究竟是在棧上還是在托管堆上？

規(guī)律是：
引用類型部署在托管堆上；
值類型總是分配在它聲明的地方：作為字段時，跟隨其所屬的變量（實例）存儲；作為局部變量時，存儲在棧上。

我們來分析一下上面的代碼。對于引用類型實例，即referenceTypeClassInstance：
從上下文看，referenceTypeClassInstance是一個局部變量，所以部署在托管堆上，并被棧上的一個引用所持有；
值類型字段_valueTypeField屬于引用類型實例referenceTypeClassInstance的一部分，所以跟隨引用類型實例referenceTypeClassInstance部署在托管堆上（有點類似于數(shù)組的情形）；
valueTypeLocalVariable是值類型局部變量，所以部署在棧上。

而對于值類型實例，即valueTypeStruct：
根據(jù)上下文，值類型實例valueTypeStructInstance本身是一個局部變量而不是字段，所以位于棧上；
其引用類型字段_referenceTypeField不存在跟隨的問題，必然部署在托管堆上，并被一個引用所持有（該引用是valueTypeStruct的一部分，位于棧）；
其引用類型局部變量referenceTypeLocalVariable顯然部署在托管堆上，并被一個位于棧的引用所持有。

所以，簡單地說“值類型存儲在棧上，引用類型存儲在托管堆上”是不對的。必須具體情況具體分析。

5. 正確使用值類型和引用類型

這一部分主要參考《Effective C#》，并非本人原創(chuàng)，希望能讓你加深對值類型和引用類型的理解。
5.1 辨明值類型和引用類型的使用場合

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

考慮下面的例子：
TestType[] testTypes = new TestType[100];

如果TestTye是值類型，則只需要一次分配，大小為TestTye的100倍。而如果TestTye是引用類型，剛開始需要100次分配，分配后數(shù)組的各元素值為null，然后再初始化100個元素，結(jié)果總共需要進行101次分配。這將消耗更多的時間，造成更多的內(nèi)存碎片。所以，如果類型的職責(zé) 主要是存儲數(shù)據(jù)，值類型比較合適。

一般來說，值類型（不支持多態(tài)）適合存儲供 C#應(yīng)用程序操作的數(shù)據(jù)，而引用類型（支持多態(tài)）應(yīng)該用于定義應(yīng)用程序的行為。

通常我們創(chuàng)建的引用類型總是多于值類型。如果以下問題的回答都為yes，那么我們就應(yīng)該創(chuàng)建為值類型：
該類型的主要職責(zé)是否用于數(shù)據(jù)存儲？
該類型的共有借口是否完全由一些數(shù)據(jù)成員存取屬性定義？
是否確信該類型永遠不可能有子類？
是否確信該類型永遠不可能具有多態(tài)行為？

5.2 將值類型盡可能實現(xiàn)為具有常量性和原子性的類型

具有常量性的類型很簡單：
如果構(gòu)造的時候驗證了參數(shù)的有效性，之后就一直有效；
省去了許多錯誤檢查，因為禁止更改；
確保線程安全，因為多個reader訪問到同樣的內(nèi)容；
可以安全地暴露給外界，因為調(diào)用者不能更改對象的內(nèi)部狀態(tài)。

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

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

復(fù)制代碼代碼如下:

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

下面創(chuàng)建一個實例：
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";

可見，內(nèi)部狀態(tài)的改變意味著可能違反對象的不變式（invariant），至少是臨時的違反。如果上面是一個多線程的程序，那么在 City更改的過程中，另一個線程可能看到不一致的數(shù)據(jù)視圖。如果不是多線程的程序，也有問題：
當ZipCode的值無效而拋出異常時，對象僅作了一部分改變，因此處于無效的狀態(tài)，為了修復(fù)這個問題，需要在Address中添加相當多的內(nèi)部校驗代碼；
為了實現(xiàn)異常安全，我們需要在所有改變多個字段的客戶代碼處放上防御性的代碼；
線程安全也要求我們在每一個屬性的訪問器上添加線程同步檢查。

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

復(fù)制代碼代碼如下:

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，不能修改現(xiàn)有的實例，只能創(chuàng)建一個新的實例：
Address address = new Address("Chengdu", "Sichuan", 610000);//create a instance
address = new Address("Nanjing", "Jiangsu", 210000);//modify the instance

address將不存在任何無效的臨時狀態(tài)。那些臨時狀態(tài)只存在于Address的構(gòu)造函數(shù)執(zhí)行過程中。這樣一來，Address是異常安全的，也是線程安全的。

5.3 確保0為值類型的有效狀態(tài)

.NET的默認初始化機制會將引用類型設(shè)置為二進制意義上的0，即null。而對于值類型，不論我們是否提供構(gòu)造函數(shù)，都會有一個默認的構(gòu)造函數(shù)，將其設(shè)置為0。

一種典型的情況是枚舉：

復(fù)制代碼代碼如下:

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

然后用做值類型的成員：

復(fù)制代碼代碼如下:

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

創(chuàng)建Employee結(jié)構(gòu)體將得到一個無效的Sex字段：
Employee employee = new Employee ();

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

復(fù)制代碼代碼如下:

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

如果值類型中包含引用類型，會出現(xiàn)另一種初始化問題：

復(fù)制代碼代碼如下:

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

然后創(chuàng)建一個ErrorLog：
ErrorLog errorLog = new ErrorLog ();

errorLog的_message字段將是一個空引用。我們應(yīng)該通過一個屬性來將_message暴露給客戶代碼，從而使該問題限定在ErrorLog 的內(nèi)部：

復(fù)制代碼代碼如下:

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，我們應(yīng)當避免裝箱和拆箱。

裝箱和拆箱最大的問題是會自動發(fā)生。比如：
Console.WriteLine("A few numbers: {0}, {1}.", 25, 32);

其中，Console.WriteLine()接收的參數(shù)類型是(string，object，object)。因此，實際上會執(zhí)行以下操作：
int i = 25;
obeject o = i;//boxing

然后把o傳給WriteLine()方法。在WriteLine()方法的內(nèi)部，為了調(diào)用i上的ToString()方法，又會執(zhí)行：
int i = (int)o;//unboxing
string output = i,ToString();

所以正確的做法應(yīng)該是：
Console.WriteLine("A few numbers: {0}, {1}.", 25.ToString(), 32.ToString());

25.ToString()只是執(zhí)行一個方法并返回一個引用類型，不存在裝箱/拆箱的問題。

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

復(fù)制代碼代碼如下:

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"