学步园

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. 总结

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

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

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

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