C# 静态构造函数，静态变量执行顺序（精华版）(规正版)

一、成员初始化整体顺序

1.成员赋值初始化先于构造函数；

2.成员赋值初始先从子类再到基类；

3.构造函数初始化先从基类再到子类；

4.静态成员初始化优先于实例成员初始化；

二、对类型静态成员构造的大致过程

1.分配静态成员的内存空间，此时空间存储数据为0；

2.执行类的静态成员的初始化语句；

3.执行类的静态构造函数。

三、对类型实例成员构造的大致过程

1.分配实例成员的内存空间，此时空间存储数据为0；

2.执行子类实例成员初始化语句；

3.执行基类实例化成员初始化语句；

4.执行基类构造函数；

5.执行子类构造函数；

四、同时有静态成员和实例成员的大致构造过程

1.执行子类静态成员初始化语句；

2.执行子类静态构造函数；

3.执行子类实例成员初始化语句；

4.执行基类静态成员初始化语句；

5.执行基类静态构造函数；

6.执行基类实例成员初始化语句；

7.执行基类实例构造函数；

8.执行子类实例构造函数。

五、说明

1.C#中静态构造函数都是私有的，不能为其添加访问修饰符；

2.只有创建类的实例或调用任何静态成员时才能激发静态构造函数；

3.调用一个未初始化类的静态成员时，他会先去初始化这个类的静态成员和静态构造函数。

总结

派生类构造函数，作为一般规则派生类构造函数应该不能直接向一个基类数据成员赋值而是把值传递给适当的基类构造函数，

否则两个类的实现变成紧耦合（tightly coupled）将更加难于正确地修改或扩展基类的实现（基类设计者的责任是提供一组适当的基类构造函数）

C#没有java的静态代码块和匿名代码块，

C#静态成员和实例成员是从子类到父类，构造函数是从父类到子类的

而java都静态成员和静态代码块是从父类到子类的，实例成员和构造函数是从父类到子类

C#静态代码块：static Parent() 不能有任何修饰符

C# 子类会把静态，静态构造函数，实例执行完毕，再执行父类，再构造函数

java 先父类静态，再子类静态，然后父类实例，子类实例，最后一样



class Class1
      {
       public static int Count = 0;
        static Class1()
        {
            Count++;
         }
       public Class1()
        {
            Count++;
         }
  }
  Class1 c = new Class1();
  Class1 cc = new Class1();
  Console.WriteLine(Class1.Count.ToString());
Console.Read();

当第一次实例化时, Count值变成2, 当第二次实例化时, 则不会执行静态构造函数与静态变量. 此时Count的值变成3. 所以,最后结果Count值为3


class Program
    {
        static void Main(string[] args)
        {
            father test = new son();
            test.print();
            Console.WriteLine("输入任意字符结束...");
            Console.ReadKey();
        }
        class father 
        {
            public static string staticstr = "静态字符串 ";
            public string fatherstr = "父类字符串 ";
            public father() 
            {
                Console.WriteLine("{0}",staticstr);
                staticstr = "静态字符串在父类中改变";
                print();
            }
            public virtual void print() { }
        }
        class son : father 
        {
            string sonstr = "子类字符串 ";
            string changestr = "暂时还未改变 ";
            public son()
            {
                staticstr = "静态字符串在子类中改变";
                changestr = "字符串改变";
            }        
            public override void print() 
            {
                Console.WriteLine("{0},{1},{2},{3}",staticstr,fatherstr,sonstr,changestr);
            }
        }
       
    }
}

代码执行：

加载类

初始化子类静态成员无

初始化子类静态构造函数无

初始化子类实例成员 string sonstr = "子类字符串 "; string changestr = "暂时还未改变 ";

初始化父类静态成员 staticstr = "静态字符串 ";

初始化子类静态构造函数没有

初始化父类实例成员 fatherstr = "父类字符串 ";

初始化父类静态成员

初始化父类构造函数

Console.WriteLine("{0}",staticstr);

staticstr = "静态字符串在父类中改变";

print();

Console.WriteLine("{0},{1},{2},{3}",staticstr,fatherstr,sonstr,changestr);

初始化子类构造函数

staticstr = "静态字符串在子类中改变";

changestr = "字符串改变";

结果：静态字符串静态字符串在父类中改变, 父类字符串, 子类字符串，暂时还未改变

静态字符串在子类中改变, 父类字符串, 子类字符串，字符串改变


class Program
    {
        static void Main(string[] args)
        {
            Parent obj1 = new Child();
            Parent obj2 = new Child();
 		  Console.ReadKey();
        }
    }
 
 
    public class Print
    {
        public Print(String s)
        {
            Console.WriteLine(s);
        }
 
    }
 
    public class Parent
    {
        public static Print obj1 = new Print("1");
        public Print obj2 = new Print("2");
        public static Print obj3 = new Print("3");
        static Parent()
        {
            new Print("4");
        }
        public static Print obj4 = new Print("5");
        public Print obj5 = new Print("6");
        public Parent()
        {
            new Print("7");
        }
 
    }
    public class Child : Parent
    {
        static Child()
        {
            new Print("a");
        }
        public static Print obj1 = new Print("b");
        public Print obj2 = new Print("c");
        public Child()
        {
            new Print("d");
        }
        public static Print obj3 = new Print("e");
        public Print obj4 = new Print("f");
}

先加载子类静态成员 b e

在加载子类静态构造函数 a

初始化子类实例成员 c f

先加载父类静态成员 1 3 5

在加载父类静态构造函数 4

初始化父类实例成员 2 6

父类构造函数 7

子类构造函数 d