值类型与引用类型

《CLR via C#》作者Jeffrey Richter的话来说，“不理解引用类型和值类型区别的程序员将会给代码引入诡异的bug和性能问题“。

1. 通用类型系统

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

　　C#的预定义类型并没有内置于语言中，而是内置于.NET Framework中。.NET使用通用类型系统（CTS）定义了可以在中间语言（IL）中使用的预定义数据类型，所有面向.NET的语言都最终被编译为 IL，即编译为基于CTS类型的代码。

　　例如，在C#中声明一个int变量时，声明的实际上是CTS中System.Int32的一个实例。这具有重要的意义：

　　1. 确保IL上的强制类型安全；

　　2. 实现了不同.NET语言的互操作性；

　　3. 所有的数据类型都是对象。它们可以有方法，属性，等。例如：

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 赋给值类型）；
引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。

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

4. 正确使用值类型和引用类型

4.1 辨明值类型和引用类型的使用场合：

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

TestType[] testTypes = new TestType[100];

01.如果TestTye是值类型，则只需要一次分配，大小为TestTye的100倍。

02.如果TestTye是引用类型，刚开始需要100次分配，分配后数组的各元素值为null，然后再初始化100个元素，结果总共需要进行101次分配。这将消耗更多的时间，造成更多的内存碎片。

所以，如果类型的职责是存储数据，值类型比较合适。

通常我们创建的引用类型总是多于值类型。如果以下问题的回答都为yes，那么我们就应该创建为值类型：
该类型的主要职责是否用于数据存储？
该类型的共有借口是否完全由一些数据成员存取属性定义？
是否确信该类型永远不可能有子类？
是否确信该类型永远不可能具有多态行为？

4.2 将值类型尽可能实现为具有常量性和原子性的类型

常量性：如果构造的时候验证了参数的有效性，之后就一直有效

　　01. 因为禁止更改，省去了许多错误检查；

　　02. 确保线程安全，因为多个reader访问到同样的内容；

　　03. 可以安全地暴露给外界，因为调用者不能更改对象的内部状态。

原子性：单一的实体，通常会直接替换一个原子类型的整个内容。

4.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
}
/*new出来的_message将是一个空引用*/
ErrorLog errorLog = new ErrorLog ();

/*通过一个属性来将_message暴露给客户代码，从而使该问题限定在ErrorLog 的内部：*/
public struct ErrorLog
{
	private string _message;
	
	public string Message
	{
		get	
		{
			return (_message ! = null) ? _message : string.Empty;
		}
		set 
		{
			_message = value;
		}
	}
	//other
}

4.4 尽量减少装箱和拆箱　　

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

01. 装箱和拆箱最大的问题是会自动发生

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()只是执行一个方法并返回一个引用类型，不存在装箱/拆箱的问题*/

02.　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()方法不进行类型转换，所以不存在装箱/拆箱的问题。

发表于 2016-10-04 21:59 MahoneTech 阅读(170) 评论(0) 收藏举报

公告