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

从概念上看，值类型直接存储其值，而引用类型存储对其值的引用。这两种类型存储在内存的不同地方。在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. 通用类型系统

c#中，变量是值还是引用仅取决于其数据类型。
c#的基本数据类型都以平台无关的方式来定义。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字段将是一个空引用。我们应该通过一个属性来将_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"