C#引用类型详细剖析-c#引用类型

C#引用类型和值类型的区别——值类型和引用类型在内存中的部署

经常听说，并且经常在书上看到：值类型部署在栈上，引用类型部署在托管堆上。实际上并没有这么简单。

MSDN上说：托管堆上部署了所有引用类型。这很容易理解。当创建一个应用类型变量时：

object reference = new object(); 
1.

关键字new将在托管堆上分配内存空间，并返回一个该内存空间的地址。左边的reference位于栈上，是一个引用，存储着一个内存地址；而这个地址指向的内存（位于托管堆）里存储着其内容（一个System.Object的实例）。下面为了方便，简称引用类型部署在托管推上。

再来看值类型。《C#语言规范》上的措辞是“结构体不要求在堆上分配内存（However, unlike classes, structs are value types and do not require heap allocation）”而不是“结构体在栈上分配内存”。这不免容易让人感到困惑：值类型究竟部署在什么地方？

数组

考虑数组：

int[] reference = new int[100]; 
1.

根据定义，数组都是引用类型，所以int数组当然是引用类型（即reference.GetType().IsValueType为false）。

而int数组的元素都是int，根据定义，int是值类型（即reference[i].GetType().IsValueType为true）。那么引用类型数组中的值类型元素究竟位于栈还是堆？

如果用WinDbg去看reference[i]在内存中的具体位置，就会发现它们并不在栈上，而是在托管堆上。

实际上，对于数组：

TestType[] testTypes = new TestType[100]; 
1.

如果TestType是值类型，则会一次在托管堆上为100个值类型的元素分配存储空间，并自动初始化这100个元素，将这100个元素存储到这块内存里。

如果TestType是引用类型，则会先在托管堆为testTypes分配一次空间，并且这时不会自动初始化任何元素（即testTypes[i]均为null）。等到以后有代码初始化某个元素的时候，这个引用类型元素的存储空间才会被分配在托管堆上。

类型嵌套

更容易让人困惑的是引用类型包含值类型，以及值类型包含引用类型的情况：

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 void Method()  
     {  
         _referenceTypeField = new object();  
        object referenceTypeLocalVariable = new object();  
     }  
}  
ValueTypeStruct valueTypeStructInstance = new ValueTypeStruct();  
valueTypeStructInstance.Method();//Where is _referenceTypeField？And where is referenceTypeLocalVariable? 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

单看valueTypeStructInstance，这是一个结构体实例，感觉似乎是整块扔到栈上的。但是字段_referenceTypeField是引用类型，局部变量referenceTypeLocalVarible也是引用类型。

referenceTypeClassInstance也有同样的问题，referenceTypeClassInstance本身是引用类型，似乎应该整块部署在托管堆上。但字段_valueTypeField是值类型，局部变量valueTypeLocalVariable也是值类型，它们究竟是在栈上还是在托管堆上？

规律是：

引用类型部署在托管堆上；值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。我们来分析一下上面的代码。

对于引用类型实例，即referenceTypeClassInstance：

从上下文看，referenceTypeClassInstance是一个局部变量，所以部署在托管堆上，并被栈上的一个引用所持有；值类型字段_valueTypeField属于引用类型实例referenceTypeClassInstance的一部分，所以跟随引用类型实例referenceTypeClassInstance部署在托管堆上（有点类似于数组的情形）；

valueTypeLocalVariable是值类型局部变量，所以部署在栈上。

而对于值类型实例，即valueTypeStruct：

根据上下文，值类型实例valueTypeStructInstance本身是一个局部变量而不是字段，所以位于栈上；其引用类型字段_referenceTypeField不存在跟随的问题，必然部署在托管堆上，并被一个引用所持有（该引用是valueTypeStruct的一部分，位于栈）；其引用类型局部变量referenceTypeLocalVariable显然部署在托管堆上，并被一个位于栈的引用所持有。所以，简单地说“值类型存储在栈上，引用类型存储在托管堆上”是不对的。必须具体情况具体分析。

C#引用类型和值类型的区别——正确使用值类型和引用类型

这一部分主要参考《Effective C#》，并非本人原创，希望能让你加深对值类型和引用类型的理解。辨明值类型和引用类型的使用场合C#中，我们用struct/class来声明一个类型为值类型/引用类型。

考虑下面的例子：

TestType[] testTypes = new TestType[100]; 
1.

如果TestTye是值类型，则只需要一次分配，大小为TestTye的100倍。而如果TestTye是引用类型，刚开始需要100次分配，分配后数组的各元素值为null，然后再初始化100个元素，结果总共需要进行101次分配。这将消耗更多的时间，造成更多的内存碎片。所以，如果类型的职责主要是存储数据，值类型比较合适。

一般来说，值类型（不支持多态）适合存储供 C#应用程序操作的数据，而引用类型（支持多态）应该用于定义应用程序的行为。

通常我们创建的引用类型总是多于值类型。如果以下问题的回答都为yes，那么我们就应该创建为值类型：

该类型的主要职责是否用于数据存储？该类型的共有借口是否完全由一些数据成员存取属性定义？是否确信该类型永远不可能有子类？是否确信该类型永远不可能具有多态行为？ 将值类型尽可能实现为具有常量性和原子性的类型

具有常量性的类型很简单：

如果构造的时候验证了参数的有效性，之后就一直有效；省去了许多错误检查，因为禁止更改；确保线程安全，因为多个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;  
         }  
     }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.

下面创建一个实例：

Address address = new Address();  
address.City = "Chengdu";  
address.Province = "Sichuan";  
address.ZipCode = 610000; 
1.
2.
3.
4.

然后更改这个实例：

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

可见，内部状态的改变意味着可能违反对象的不变式（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; }  
     }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

如果要改变Address，不能修改现有的实例，只能创建一个新的实例：

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

address将不存在任何无效的临时状态。那些临时状态只存在于Address的构造函数执行过程中。这样一来，Address是异常安全的，也是线程安全的。

确保0为值类型的有效状态

.NET的默认初始化机制会将引用类型设置为二进制意义上的0，即null。而对于值类型，不论我们是否提供构造函数，都会有一个默认的构造函数，将其设置为0。

一种典型的情况是枚举：

public enum Sex  
{  
     Male = 1;  
     Female = 2;  
}  
 
1.
2.
3.
4.
5.
6.

然后用做值类型的成员：

public struct Employee  
{  
    private Sex _sex;  
    //other  
}  
 
1.
2.
3.
4.
5.
6.

创建Employee结构体将得到一个无效的Sex字段：

Employee employee = new Employee (); 
1.

employee的_sex是无效的，因为其为0。我们应该将0作为一个为初始化的值明确表示出来：

public Sex  
{  
     None = 0;  
     Male = 1;  
     Female = 2;  
} 
1.
2.
3.
4.
5.
6.

如果值类型中包含引用类型，会出现另一种初始化问题：

public struct ErrorLog  
{  
    private string _message;  
    //other  
}  
 
1.
2.
3.
4.
5.
6.

然后创建一个ErrorLog：

ErrorLog errorLog = new ErrorLog ();  
1.

errorLog的_message字段将是一个空引用。我们应该通过一个属性来将_message暴露给客户代码，从而使该问题限定在ErrorLog 的内部：

public struct ErrorLog  
{  
    private string _message;  
    public string Message  
     {  
        get 
         {  
            return (_message ! = null) ? _message : string.Empty;  
         }  
        set { _message = value; }  
     }  
    //other  
}  
 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

尽量减少装箱和拆箱

装箱指把一个值类型放入一个未具名类型的引用类型中，比如：

int valueType = 0;  
object referenceType = i;//boxing 
1.
2.

拆箱则是从前面的装箱对象中取出值类型：

object referenceType;  
int valueType = (int)referenceType;//unboxing 
1.
2.

装箱和拆箱是比较耗费性能的，还会引入一些诡异的bug，我们应当避免装箱和拆箱。

装箱和拆箱***的问题是会自动发生。比如：

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

其中，Console.WriteLine()接收的参数类型是(string，object，object)。因此，实际上会执行以下操作：

int i = 25;  
obeject o = i;//boxing 
1.
2.

然后把o传给WriteLine()方法。在WriteLine()方法的内部，为了调用i上的ToString()方法，又会执行：

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

所以正确的做法应该是：

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

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"  
 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

上面的代码不仅存在性能的问题，还容易导致错误发生。

在这种情况下，更好的做法是使用泛型集合：

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

由于List< T>是强类型的集合，employees.Add()方法不进行类型转换，所以不存在装箱/拆箱的问题。

C#引用类型和值类型的区别——总结

C#中，变量是值还是引用仅取决于其数据类型。

C#的值类型包括：结构体（数值类型，bool型，用户定义的结构体），枚举，可空类型。

C#的引用类型包括：数组，用户定义的类、接口、委托，object，字符串。

数组的元素，不管是引用类型还是值类型，都存储在托管堆上。

引用类型在栈中存储一个引用，其实际的存储位置位于托管堆。为了方便，本文简称引用类型部署在托管推上。

值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。

值类型在内存管理方面具有更好的效率，并且不支持多态，适合用作存储数据的载体；引用类型支持多态，适合用于定义应用程序的行为。

应该尽可能地将值类型实现为具有常量性和原子性的类型。

应该尽可能地确保0为值类型的有效状态。

应该尽可能地减少装箱和拆箱。

关键字new将在托管堆上分配内存空间，并返回一个该内存空间的地址。左边的reference位于栈上，是一个引用，存储着一个内存地址；而这个地址指向的内存（位于托管堆）里存储着其内容（一个System.Object的实例）。

【编辑推荐】