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"
上面的代码不仅存在性能的问题,还容易导致错误发生。
在这种情况下,更好的做法是使用泛型集合:
List<Employee> employees = new List<Employee>();
由于List<T>是强类型的集合,employees.Add()方法不进行类型转换,所以不存在装箱/拆箱的问题。
6. 总结
数组的元素,不管是引用类型还是值类型,都存储在托管堆上。
引用类型在栈中存储一个引用,其实际的存储位置位于托管堆。为了方便,本文简称引用类型部署在托管推上。
值类型总是分配在它声明的地方:作为字段时,跟随其所属的变量(实例)存储;作为局部变量时,存储在栈上。
应该尽可能地减少装箱和拆箱。