static 还是readonly 还是static readonly

一、   static 多对象共享一段空间,或者说没有对象概念,就是类的概念,不需要实例化,自动被创建。多用于长期共享。不会为对象的创建或销毁而消失。

  

static 还是readonly 还是static readonly
  public class C
    {

        static A a =  new A("C 创建A",1111)



        public A Ci
        {
            get
            {
                return a;
            }


        }


        public C(A b)
        {
            a = b;
            Console.WriteLine("构造" + a.Presentation);
        }

        //public static void Set()
        //{
        //    a = new A("", 11);
        //}

    }


public class A
{
     private string _presentation;
      private int _intvalue = -1;    

      public int A1
        {
            get
            {
                return _intvalue;
            }
        }

        public string Presentation
        {
            get
            {
                return _presentation;
            }
        }
   
        public A(string presentation, int intvalue)
        {
            _presentation = presentation;
            _intvalue = intvalue;
            Console.WriteLine("构造A类" + presentation + "," + intvalue);
        }
}
static 还是readonly 还是static readonly

以上代码有几点说明
1.在C类创建静态A时,虽然在字段中(实建C类会自动创建一个静态构造方法,它会把类中声明的字段初始化值全放在你定义的前面,也就是后面的值可以随时改变字  段的定义的值)

2.Static A类也就是上面a,可以随时被定义成别的对象

3.Static 是什么?就是在单个进程中仅仅保留一份。而它又可以随时被读写。

static 还是readonly 还是static readonly
 static void Main(string[] args)
        {
            A a1 = new A("a1", 11);
            A a2 = new A("a2", 12);
            C c1 = new C(a1);
            C c2 = new C(a2);
            Console.WriteLine(object.ReferenceEquals(c1.Ci, c2.Ci));
                     
            Console.ReadKey();

        }
static 还是readonly 还是static readonly

 
二、readonly人们常常与const相比,我不解释值类型readonly的问题,只说明引用类型readonly,只读,不会被改变,最直接了解。

   

static 还是readonly 还是static readonly
 public class C
    {

        readonly A a = new A("111",1111);

        public A Ci
        {
            get
            {
                return a;
            }
            //set
            //{
            //    a = value;//别试图在类内部使用时改变它的引用
            //}


        }

        public C(A b)
        {
            a = b;//仅仅是在构方法内被初始化
            Console.WriteLine("构造" + a.Presentation);
        }

        //public static void Set()
        //{
        //    a = new A("改变", 10000);
        //}
    }
static 还是readonly 还是static readonly

说明:
1.readonly仅仅可以在构造方法中初始化(字段中一样)

2.readonly不可能在静态构造方法中初始化

3.在类中的任何地方,都无法改变readonly的值(无论是值类型,还是引用类型)

4.为了保证类内部中被调用的稳定性,不会被改变,readonly吧!

5.在不同类中有不同的readonly指向不同地址。也就是多类中保留多份

然而,第三点是有条件的它不能是IEnumerable(最后说明这一点)

 

static 还是readonly 还是static readonly
 public class B
    {
        readonly IList<A> geta = new List<A>();
        public IList<A> GetA
        {
            get { return geta; }

        }

        public int B1
        {
            get;
            set;
        }

        public  B()
        {
            GetA.Add(new A("B内部创建", 111));
            Console.WriteLine(geta[0].Presentation);
        }
    }
static 还是readonly 还是static readonly
static 还是readonly 还是static readonly
static void Main(string[] args)
        {
            A a1 = new A("a1", 11);
            A a2 = new A("a2", 12);
            B b = new B();
            b.GetA[0] = a1;
            Console.WriteLine(b.GetA[0].Presentation);
            Console.ReadKey();

        }
static 还是readonly 还是static readonly

被改变了,readonly面对IEnumerable时,一,虽然IList只读,同样会被改变,二、可以从外面很容易通过属性方法改变Ilist所引用的地址。虽然我给A类重载了
Equals和GetHashCode,可依然改变了,看来IEnumerable.add不会判断这个。(这点我希望能给我指正原理性问题)

三、static readonly 根据上面的定义,做了以下假设,

1,肯定需要构造方法中定义(静态的,还是默认的?)

2 .进程中保留一份还是多份,?

3。在类中可以改变吗?

static 还是readonly 还是static readonly
  public class C
    {

       static readonly A a = new A("A1",1111);

        public A Ci
        {
            get
            {
                return a;
            }
            //set
            //{
            //    a = value;//别试图在类内部使用时改变它的引用
            //}
        }

        public C()
        {
           // a = new A("A3", 333); 也不可以这里定义
            Console.WriteLine("构造C类" + a.Presentation);
        }
        static C()
        {
            a = new A("A2", 2222);
            Console.WriteLine("构造C静态类" + a.Presentation);
        }

        //public static void Set()
        //{
        //    a = new A("改变", 10000);//也不可以这里改变
        //}
    }
static 还是readonly 还是static readonly
static 还是readonly 还是static readonly
static void Main(string[] args)
        {
            A a1 = new A("a1", 11);
            A a2 = new A("a2", 12);
            C c1 = new C();
            C c2 = new C();
            Console.WriteLine(object.ReferenceEquals(c1.Ci, c2.Ci));
        
            Console.ReadKey();

        }
static 还是readonly 还是static readonly


上面的结果

构造A类a1,11
构造A类a2,12
构造A类A1,1111
构造A类A2,2222
构造C静态类A2
构造C类A2
构造C类A2
True

说明:

1.如果一个静态构造方法与一个构造方法同时存在,首先静态构造方法执行,然后是构造方法

2在任何一个构造方法中都会把字段的值重新被定义。

以上是任一本原理书都可以找到的重点是回答上面问题

1.只有静态构造方法可以初始化static readonly

2.进程中仅保留一份

3.类中不可以改原有的值。

想想我们的单例为什么那样创建(上一篇说过http://www.cnblogs.com/shouhongxiao/p/3530091.html),我们单例就是想在一个进程中只保留一份,且不会被已经进入类中多线程改变已经创建的对象,当然是双重锁定了

static 还是readonly 还是static readonly
 if (null == instance)
                {
                    lock (threadSafeLocker)
                    {
                        if (null == instance)
                        {
                            instance = new VFactory;
                           

                        }
                    }
                }
static 还是readonly 还是static readonly

第一个null = instance 解决效率问题(如果多线程进入对象被创建,就不需lock了)
第二个就是防止已经进入多线程改变

第三个肯定是一个单线程进入了(判断对象是否被创建)

那我们就创建了一份且只有一份,而且不会被进入的多线程改变的单例。

 总结一下:static 是为了保证共性(多对象共享,一损具损),readonly是了了保持个性(每个单一对象有自己固定的特性),static readonly ?这世界上仅有我一个,有个性的我。

 

 

 

 

 

  

    

static 还是readonly 还是static readonly

上一篇:CentOS 安装 git 教程


下一篇:【FIORI系列】SAP 一文读懂SAP Fiori是什么