今日查询.net中string属哪种类型时找到这篇文章,写得很清楚,转过来大家看。
从概念上看,值类型直接存储其值,而引用类型存储对其值的引用。这两种类型存储在内存的不同地方。在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语言的互操作性;
- 所有的数据类型都是对象。它们可以有方法,属性,等。例如:
i = 1 ;
string s;
s = i.ToString();
MSDN的这张图说明了CTS中各个类型是如何相关的。注意,类型的实例可以只是值类型或自描述类型,即使这些类型有子类别也是如此。
![](https://i-blog.csdnimg.cn/blog_migrate/33d995f8a2c92caac7ddfc7d35f8f0c1.gif)
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>的别名)。
每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。例如:
等价于:
等价于:
等价于:
使用new运算符时,将调用特定类型的默认构造函数并对变量赋以默认值。在上例中,默认构造函数将值0赋给了i。MSDN上有完整的默认值表。
关于int和Int32的细节,在我的另一篇文章中有详细解释:《理解C#中的System.Int32和int》。
所有的值类型都是密封(seal)的,所以无法派生出新的值类型。
值得注意的是,System.ValueType直接派生于System.Object。即System.ValueType本身是一个类类型,而不是值类型。其关键在于ValueType重写了Equals()方法,从而对值类型按照实例的值来比较,而不是引用地址来比较。
可以用Type.IsValueType属性来判断一个类型是否为值类型:
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 s2 = " world! " ;
string s3 = s1 + s2; // s3 is "Hello, world!"
这确实看起来像一个值类型的赋值。再如:
string s2 = s1 ;
s1 = "b " ; // s2 is still "a"
改变s1的值对s2没有影响。这更使string看起来像值类型。实际上,这是运算符重载的结果,当s1被改变时,.NET在托管堆上为s1重新分配了内存。这样的目的,是为了将做为引用类型的string实现为通常语义下的字符串。
4. 值类型和引用类型在内存中的部署
经常听说,并且经常在书上看到:值类型部署在栈上,引用类型部署在托管堆上。实际上并没有这么简单。
MSDN上说:托管堆上部署了所有引用类型。这很容易理解。当创建一个应用类型变量时:
关键字new将在托管堆上分配内存空间,并返回一个该内存空间的地址。左边的reference位于栈上,是一个引用,存储着一个内存地址;而这个地址指向的内存(位于托管堆)里存储着其内容(一个System.Object的实例)。下面为了方便,简称引用类型部署在托管推上。
再来看值类型。《C#语言规范》上的措辞是“结构体不要求在堆上分配内存(However, unlike classes, structs are value types and do not require heap allocation)”而不是“结构体在栈上分配内存”。这不免容易让人感到困惑:值类型究竟部署在什么地方?
4.1 数组
考虑数组:
根据定义,数组都是引用类型,所以int数组当然是引用类型(即reference.GetType().IsValueType为false)。
而int数组的元素都是int,根据定义,int是值类型(即reference[i].GetType().IsValueType为true)。那么引用类型数组中的值类型元素究竟位于栈还是堆?
如果用WinDbg去看reference[i]在内存中的具体位置,就会发现它们并不在栈上,而是在托管堆上。
实际上,对于数组:
如果TestType是值类型,则会一次在托管堆上为100个值类型的元素分配存储空间,并自动初始化这100个元素,将这100个元素存储到这块内存里。
如果TestType是引用类型,则会先在托管堆为testTypes分配一次空间,并且这时不会自动初始化任何元素(即testTypes[i]均为null)。等到以后有代码初始化某个元素的时候,这个引用类型元素的存储空间才会被分配在托管堆上。
4.2 类型嵌套
更容易让人困惑的是引用类型包含值类型,以及值类型包含引用类型的情况:
{
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来声明一个类型为值类型/引用类型。
考虑下面的例子:
如果TestTye是值类型,则只需要一次分配,大小为TestTye的100倍。而如果TestTye是引用类型,刚开始需要100次分配,分配后数组的各元素值为null,然后再初始化100个元素,结果总共需要进行101次分配。这将消耗更多的时间,造成更多的内存碎片。所以,如果类型的职责主要是存储数据,值类型比较合适。
一般来说,值类型(不支持多态)适合存储供 C#应用程序操作的数据,而引用类型(支持多态)应该用于定义应用程序的行为。
通常我们创建的引用类型总是多于值类型。如果以下问题的回答都为yes,那么我们就应该创建为值类型:
- 该类型的主要职责是否用于数据存储?
- 该类型的共有借口是否完全由一些数据成员存取属性定义?
- 是否确信该类型永远不可能有子类?
- 是否确信该类型永远不可能具有多态行为?
5.2 将值类型尽可能实现为具有常量性和原子性的类型
具有常量性的类型很简单:
- 如果构造的时候验证了参数的有效性,之后就一直有效;
- 省去了许多错误检查,因为禁止更改;
- 确保线程安全,因为多个reader访问到同样的内容;
- 可以安全地暴露给外界,因为调用者不能更改对象的内部状态。
具有原子性的类型都是单一的实体,我们通常会直接替换一个原子类型的整个内容。
下面是一个典型的可变类型:
{
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.City = "Chengdu " ;
address.Province = "Sichuan " ;
address.ZipCode = 610000 ;
然后更改这个实例:
address.ZipCode = 210000 ; // Now Province is still invalid
address.Province = "Jiangsu " ;
可见,内部状态的改变意味着可能违反对象的不变式(invariant),至少是临时的违反。如果上面是一个多线程的程序,那么在 City更改的过程中,另一个线程可能看到不一致的数据视图。如果不是多线程的程序,也有问题:
- 当ZipCode的值无效而抛出异常时,对象仅作了一部分改变,因此处于无效的状态,为了修复这个问题,需要在Address中添加相当多的内部校验代码;
- 为了实现异常安全,我们需要在所有改变多个字段的客户代码处放上防御性的代码;
- 线程安全也要求我们在每一个属性的访问器上添加线程同步检查。
显然,这是一个相当可观的工作量。下面我们把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 = new Address( "Nanjing " , "Jiangsu " , 210000 ); // modify the instance
address将不存在任何无效的临时状态。那些临时状态只存在于Address的构造函数执行过程中。这样一来,Address是异常安全的,也是线程安全的。
5.3 确保0为值类型的有效状态
.NET的默认初始化机制会将引用类型设置为二进制意义上的0,即null。而对于值类型,不论我们是否提供构造函数,都会有一个默认的构造函数,将其设置为0。
一种典型的情况是枚举:
{
Male = 1 ;
Female = 2 ;
}
然后用做值类型的成员:
{
private Sex _sex;
// other
}
创建Employee结构体将得到一个无效的Sex字段:
employee的_sex是无效的,因为其为0。我们应该将0作为一个为初始化的值明确表示出来:
{
None = 0 ;
Male = 1 ;
Female = 2 ;
}
如果值类型中包含引用类型,会出现另一种初始化问题:
{
private string _message;
// other
}
然后创建一个ErrorLog:
errorLog的_message字段将是一个空引用。我们应该通过一个属性来将_message暴露给客户代码,从而使该问题限定在ErrorLog 的内部:
{
private string _message;
public string Message
{
get
{
return (_message ! = null ) ? _message : string .Empty;
}
set { _message = value; }
}
// other
}
5.4 尽量减少装箱和拆箱
装箱指把一个值类型放入一个未具名类型的引用类型中,比如:
object referenceType = i; // boxing
拆箱则是从前面的装箱对象中取出值类型:
int valueType = ( int )referenceType; // unboxing
装箱和拆箱是比较耗费性能的,还会引入一些诡异的bug,我们应当避免装箱和拆箱。
装箱和拆箱最大的问题是会自动发生。比如:
其中,Console.WriteLine()接收的参数类型是(string,object,object)。因此,实际上会执行以下操作:
obeject o = i; // boxing
然后把o传给WriteLine()方法。在WriteLine()方法的内部,为了调用i上的ToString()方法,又会执行:
string output = i,ToString();
所以正确的做法应该是:
25.ToString()只是执行一个方法并返回一个引用类型,不存在装箱/拆箱的问题。
另一个典型的例子是ArryList的使用:
{
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<T>是强类型的集合,employees.Add()方法不进行类型转换,所以不存在装箱/拆箱的问题。
6. 总结
C#中,变量是值还是引用仅取决于其数据类型。
C#的值类型包括:结构体(数值类型,bool型,用户定义的结构体),枚举,可空类型。
C#的引用类型包括:数组,用户定义的类、接口、委托,object,字符串。
数组的元素,不管是引用类型还是值类型,都存储在托管堆上。
引用类型在栈中存储一个引用,其实际的存储位置位于托管堆。为了方便,本文简称引用类型部署在托管推上。
值类型总是分配在它声明的地方:作为字段时,跟随其所属的变量(实例)存储;作为局部变量时,存储在栈上。
值类型在内存管理方面具有更好的效率,并且不支持多态,适合用作存储数据的载体;引用类型支持多态,适合用于定义应用程序的行为。
应该尽可能地将值类型实现为具有常量性和原子性的类型。
应该尽可能地确保0为值类型的有效状态。
应该尽可能地减少装箱和拆箱。
7. 参考