const和readonly你真的懂吗？

第二遍文章我打算把const和readonly的区别拿出来说下，由于写代码这么久我都还没搞清楚这二者的区别，实在有点惭愧，因此这一次我打算搞清楚它。

定义

来看看MSDN的解释：

readonly:readonly关键字是能够在字段上使用的修饰符。当字段声明包括readonly修饰符时，该声明引入的字段赋值只能做为声明的一部分，或者出如今同一类的构造函数中。

const：使用 const 关键字来声明某个常量字段或常量局部变量。 常量字段和常量局部变量不是变量而且不能修改。

太多理论的讲解有些人可能看了更犯晕，因此直接写些代码我以为可能比较直观好理解。

 

举例

咱们先来看下const

public class ConstTest
{
        class SampleClass
        {
            public int x;
            public int y;
            public const int c1 = 5;
            public const int c2 = c1 + 5;
            public static const int z=8;    //这个写法错误，由于const是静态常量，可看下面提供c1的IL语言图片。

            //变量能够在这里初始化值，可是若是把const放在这里初始化，编译会出错（赋值号左边必须为变量、属性或索引器）
            public SampleClass(int p1, int p2)
            {
                x = p1;
                y = p2;
            }
        }
        static void Main()
        {
            SampleClass mC = new SampleClass(11, 22);
            Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);
            Console.WriteLine("c1 = {0}, c2 = {1}",SampleClass.c1, SampleClass.c2);  //类型引用
        }
 }

/* Output
    x = 11, y = 22
    c1 = 5, c2 = 10
 */

来看下IL语言：

c2和y省略在这里省略，从上面的图咱们得出了一个结论：

那就是静态常量，那什么是静态常量呢？静态常量是指编译器在编译时候会对常量进行解析，并将常量的值替换成初始化的那个值。即图中里面的c1和c2，它们都是在编译的时候值就肯定下来(c1=5，c2=10),这个相信你们也比较好理解。

咱们再来看readonly：

public class ReadOnlyTest
{
        class SampleClass
        {
            public readonly int x;
            public  readonly int y = 25;
            public  static readonly int z=12;
       

            //无参构造函数初始化readonly常量
            public SampleClass()
            {
                y = 24;
            }

            //静态无参构造函数内初始化static readonly常量      
            static SampleClass()
            {
                z = 23;
            }

            //有参构造函数初始化readonly常量
            public SampleClass(int p1, int p2)
            {
                x = p1;
                y = p2;
            }
        }

        static void Main()
        {
            //访问静态成员
            Console.WriteLine(SampleClass.z);

            //访问非静态成员
            SampleClass p1 = new SampleClass(11, 21);   // OK
            Console.WriteLine("p1: x={0}, y={1}", p1.x, p1.y);
            SampleClass p2 = new SampleClass();
            Console.WriteLine("p2: x={0}, y={1}", p2.x, p2.y);

            Console.ReadKey();
        }
}

 /*
 Output:
 23

 p1: x=11, y=21

 p2: x=0, y=24

    */

一样的，来看IL语言：

咱们先看下什么是动态常量：

动态常量，是指值在运行的那一刻才得到的，编译器编译期间将其标示为只读常量，而不用常量的值代替，这样动态常量没必要在声明的时候就初始化，而能够延迟到构造函数中初始化。

经过const和readonly的代码咱们能够得出如下结论：

1.readonly和static readonly定义的常量，指定初始值后(包括在构造函数内指定初始值)将不可更改，可读不可写。

2.static readonly常量，若是在构造函数内指定初始值，则必须是静态无参构造函数，例如z参数的初始化过程。

3.const和static readonly定义的常量是静态的，只能由类型直接访问；而readonly定义的常量是非静态的，只能由实例对象访问。

const和readonly比较

1.const默认是静态的，只能由类型访问，不能和static同时使用，不然编译错误；readonly默认是非静态，由实例对象来访问，能够显式使用static定义为静态成员。

2.const只能引用在值类型和string类型上，其余引用类型常量必须声明为null，不然以new为const引用类型常量赋值，编译器会提示错误，缘由是构造函数初始化在运行时，而非编译时；readonly只读字段能够是任意类型，可是对于引用类型字段来讲，readonly不能限制对该对象实例成员的读写控制。

3.const必须在字段声明时初始化；而readonly能够在声明时，或者构造函数中进行初始化，不一样的构造函数能够为readonly常量实现不一样的初始值

4.const能够定义字段和局部变量；而readonly则只能定义字段

5.const因为是静态常量因此在编译时会对常量进行解析，而readonly是动态常量在编译期间编译器将其标示为只读常量，而不用常量的值代替，这样就没必要在声明的时候就初始化，而能够延迟到构造函数中初始化

6.从应用角度来看，对于恒定不变且单独使用的量来讲，应该考虑声明为const常量，例如性能比，百分比等；而对于可能随实际运行发生变化的量，应该考虑声明readonly常量，例如日期或时间，数据库中的主键id等

 

以上内容但愿对一些朋友带来帮助~~~