谈谈C#中类成员的执行顺序

1. 构造函数和静态构造函数的执行顺序。

对于单个的类，它的静态构造函数将先于构造函数执行，因为构造函数需要在实例化该类的时候执行，而静态构造函数访问该类的同时就开始执行。

而对于有继承关系的父类和子类来说，父类的构造函数先于子类的构造函数执行，简而言之就是被依赖的先构造，依赖于人的后构造。

我们来看实例。

我们为父类和子类分别定义静态构造函数和无参构造函数。

public class Parent
{
     static Parent()
     {
        Console.WriteLine("Parent Static Constructor");
     }
     public Parent()
     {
         Console.WriteLine("Parent Constructor")

     }

} 

 

定义一个子类继承于该父类。

public class Child : Parent
{
    static Child()
    {
        Console.WriteLine("Child Static Constructor");
    }
    public Child()
    {
        Console.WriteLine("Child Constructor");
    }

}

 

那么当我们实例化Child类的时候会如何输出呢？

 

 

static void Main(string[] args)
{
    Child child = new Child();
    Console.Read();
}

 

 

 

 

结果如下：

 

 

 

这个结果很好解释，我们实例化子类，所以静态构造函数在访问类的时候同时访问，所以先执行子类的静态构造函数，而Child类依赖于Parent类，所以接下来执行Parent类的构造函数。

两个类的静态构造函数执行完毕后分别执行父类的构造函数和子类的构造函数。 

 

2. 静态变量，静态构造函数以及构造函数的情况。

从上面分析的第一种情况我们知道静态构造函数是先于构造函数执行的， 而静态变量是先于静态构造函数执行的。

那如果该静态变量定义的是该类的一个实例执行顺序如何呢？

我们来看实例。

public class Child 
{
    static public Child instance = new Child();
    static Child()
    {
       Console.WriteLine("Child Static Constructor");
    }
    public Child()
    {
        Console.WriteLine("Child Constructor");
    }  

}     

 

实例化该类，显示结果如下：

 

 

 

对于这个执行结果，首先执行的是静态变量，而该静态变量是对Child类的实例化，此时先调用它的构造函数，为什么不会调用它的静态构造函数呢？因为静态构造函数的执行在静态变量之后，

所以第一步，初始化静态变量，打印 "Child Constructor" ;

第二步，执行静态构造函数，打印 "Child Static Constructor" ;

第三步，执行构造函数， 打印 "Child Constructor".

 

3. 存在继承关系的静态变量，静态构造函数，构造函数的执行顺序.

下面我们把第二种情况复杂化一点，加入父类。 

public class Parent
{
    static Parent()
    {
        Console.WriteLine("Parent Static Constructor");
    }
    public Parent()
    {
        Console.WriteLine("Parent Constructor");
    }

} 

 

子类继承于父类。

public class Child :Parent
{
    static public Child instance = new Child();

    static Child()
    {
           Console.WriteLine("Child Static Constructor");
    }
    public Child()
    {
        Console.WriteLine("Child Constructor");
    }    

} 

 

如果我们实例化Child类，会产生什么结果呢？在我给出答案之前，大家不妨先分析一下这个结果。

1. 先初始化Child类的静态变量instance。 

显然最开始执行的是Child类中的静态变量instance，instance要实例化一个Child类，那么首先要访问Child类的构造函数，而Child类又是依赖于Parent类的，所以在执行Child类的

构造函数之前，先执行的是它父类的静态构造函数和构造函数（注意此时Child类的静态构造函数不会执行）。它将打印出"Parent Static Constructor"和"Parent Constructor".

其次执行这个构造函数，（此时Child类的静态构造函数仍然不会执行）。打印出"Child Constructor". 

2. 执行Child类的静态构造函数

这次将打印出"Child Static Constructor"。

3. 执行Child类的构造函数

执行Child类的构造函数，这里会产生两个结果。首先，会执行它父类的构造函数，注意此时父类的静态构造函数不会执行了，它只会执行一次。其次才是执行Child类自己的构造函数。

因此此时应该打印出"Parent Constructor"和"Child Constructor".

实际运行的结果也证明刚才分析的正确性。

 

 

 通过上面三个例子的分析，相信大家应该知道了如何去分析这个执行顺序，那就给大家留一个作业自己思考吧。

父类：

public class Parent
{
    static public Parent instance = new Parent();

    static Parent()
    {
       Console.WriteLine("Parent Static Constructor");
    }
    public Parent()
    {
        Console.WriteLine("Parent Constructor");
    }

} 

子类：

public class Child :Parent
{
    static public Child instance = new Child();

    static Child()
    {
        Console.WriteLine("Child Static Constructor");
    }
    public Child()
    {
        Console.WriteLine("Child Constructor");
    }

}