学习CLR via C#(第4版)（五） - 常量和字段

常量和字段

7.1常量

常量(constant)是一个特殊的值，它是一个从不变化的值。

在定义常量时，它的值必须在编译时确定。确定之后，编译器将常量的值保存到程序集的元数据中。这就意味着只能为编译器认定的基元类型定义常量。

C#是允许定义一个非基元类型的常量变量(constant variable)，但这个值应设为null。

public sealed class SomeType {
    //SomeType不是基元类型，但C#允许定义
    //值为null的这种类型的一个常量变量
    public const SomeType Empty = null;    
}

由于常量的值从不变化，所以常量总是被视为类型定义的一部分。所以，常量是静态成员，而不是实例成员。定义常量将导致创建元数据。

代码引用一个常量符号时，编译器会在定义常量的程序集的元数据中查找该符号，提取常量的值，并将值嵌入生成的IL代码中。由于常量的值直接嵌入代码中，所以运行时不需要为常量额外分配内存。

除此之外，不能获取常量的地址，也不能以传递引用的方式传递常量。

基于上一条，假如A程序集只依赖于B程序集中的常量，那么编译后，即使删除B程序集，A程序集也不会受到影响，也是能找到B程序集中定义的常量值。

7.2字段

字段(field)是一种数据成员，其中容纳了一个值类型的实例或者对一个引用类型的引用。

下表总结了应用于字段的修饰符：

CLR术语	C#术语	说明
Static	static	这种字段是类型状态的一部分，而不是对象状态的一部分
Instance	默认	这种字段与类型的一个实例关联，而不是与类型本身关联
InitOnly	readOnly	这种字段只能由一个构造器方法中的代码写入
Volatile	volatile	看到访问这种字段的代码，编译器、CLR或硬件就不会执行一些"线程不安全"的优化措施

CLR支持类型(静态)字段和实例(非静态)字段。对于类型字段，用于容纳字段数据的动态内存是在类型对象中分配的，而类型对象是在类型加载到一个AppDomain时创建的。什么时候要将类型加载到一个AppDimain中呢？通常是在引用了该类型的任何方法首次进行JIT编译的时候。

对于实例字段，用于容纳字段数据的动态内存则是在构造类型的一个实例时分配的。

由于字段存储在动态内存中，所有它们的值在运行时才能获取。字段还解决了常量存在的版本控制的问题。此外，字段可以是任何数据类型。

CLR支持readonly字段和read/write字段。大多数字段是read/write字段，这意味着在代码执行过程中，字段可以多次改变。但是，readonly字段只能在一个构造器方法中写入(在这有人会有疑问，我可以直接定义readonly的值啊？比如private readonly int ss = 123;不必从构造器方法中写入？这问题，以后会提到)。注意，可以利用反射来修改readonly字段。

下面演示了如何定义一个与类型本身关联的readonly静态字段和读/写静态字段。另外还定义了read/wite静态字段，以及readonly和read/write实例字段。

public sealed class SomeType {
    // 这是一个静态readonly字段：在运行时对Random类进行初始化
    // 它的值会被计算并存储到内存中
    public static readonly Random s_random = new Random();
 
    // 这是一个静态read/write字段
    private static Int32 s_numberOfWrites = 0;
 
    // 这是一个实例readonly字段
    public readonly String Pathname = "Untitled";
 
    // 这是一个实例read/write字段
    private System.IO.FileStream m_fs;
 
    public SomeType(String pathname) {
        // 这行修改只读字段Pathname
        // 由于是在构造其中，所有可以进行修改
        this.Pathname = pathname;
    }
 
    public String DoSomething() {
        // 该行读写静态read/write字段
        s_numberOfWrites = s_numberOfWrites + 1;
 
        // 这行读取readonly实例字段
        return Pathname;
    }
}

在上述代码中，许多字段都是内联初始化的。C#允许使用内联初始化语法来初始化类的常量、read/write字段和readonly字段。在后面会讲到，C#实际是在构造器中对字段进行初始化的，字段的内联初始化只是一种语法上的简化而已。另外，在C#中使用内联初始化，有一些性能问题需要考虑,这些以后会着重讲解。

注意，当某个字段是引用类型，并且该字段标记为readonly时，那么不可改变的引用，而非字段引用的值。

internal static class ReadOnlyReferences {
   public sealed class AType {
      // InvalidChars总是引用同一个数组对象
      public static readonly Char[] InvalidChars = new Char[] { 'A', 'B', 'C' };
   }
 
   public sealed class AnotherType {
      public static void M() {
         // 下面三行代码是合法的，可通过编译并运行
         // 修改InvalidChars数组中的字符
         AType.InvalidChars[0] = 'X';
         AType.InvalidChars[1] = 'Y';
         AType.InvalidChars[2] = 'Z';
 
         // 下一行代码是非法的，无法通过编译
         // 因为不能让InvalidChars 引用别的什么东西
         //AType.InvalidChars = new Char[] { 'X', 'Y', 'Z' };
      }
   }
}

const和readonly的区别是什么

const: const用来声明常量。

1）它的值必须在编译时确定；

2）编译器将常量的值保存在程序集的元数据中；

3）常量的值直接嵌入代码，运行时不需要为常量分配内存空间；

4）常量总被视为静态成员；

5）用const声明的类型必须是基元类型;

6）也允许定义一个非基元类型的常量变量(constant variable)，但这个值应设为null

readonly: 用来声明只读字段。

1）只读字段只能在一个构造函数中写入；

2）可以用反射来修改readonly字段；

3）当只读字段为引用类型，不可改变的是引用，并非字段引用的对象。

举例：

using System;
class P
{
    static readonly int A=B*10;
    static readonly int B=10;
    public static void Main(string[] args)
    {
        Console.WriteLine("A is {0},B is {1} ",A,B);
    }
}

对于上述代码，输出结果是多少?很多人会认为是A is 100,B is 10吧！其实，正确的输出结果是A is 0,B is 10。

如果改成下面的话：

using System;
class P
{
    const int A=B*10;
    const int B=10;
    public static void Main(string[] args)
    {
        Console.WriteLine("A is {0},B is {1} ",A,B);
    }

}

对于上述代码，输出结果又是多少呢？难道是A is 0,B is 10？其实又错了，这次正确的输出结果是A is 100,B is 10

那么为什么是这样的呢？

其实在上面说了，const是静态常量，所以在编译的时候就将A与B的值确定下来了（即B变量时10，而A=B*10=10*10=100）,那么Main函数中的输出当然是A is 100,B is 10啦。而static readonly则是动态常量，变量的值在编译期间不予以解析，所以开始都是默认值，像A与B都是int类型，故都是0。而在程序执行到A=B10;所以A=010=0,程序接着执行到B=10这句时候，才会真正的B的初值10赋给B。

静态字段和实例字段内存空间在什么时候分配？

静态字段的内存空间在类型对象中分配，类型对象是在类型加载到一个AppDomain时创建的，换言之，通常是在引用了该类型的任何方法首次进行JIT编译的时候；

实例字段的内存空间在构造类型的一个实例时分配。