【转摘】一道关于实例化顺序的C#面试题

public class BaseA
{
    public static MyTest a1 = new MyTest("a1");

    public MyTest a2 = new MyTest("a2");

    static BaseA()
    {
        MyTest a3 = new MyTest("a3");
    }

    public BaseA()
    {
        MyTest a4 = new MyTest("a4");
    }

    public virtual void MyFun()
    {
        MyTest a5 = new MyTest("a5");
    }
}

public class BaseB : BaseA
{
    public static MyTest b1 = new MyTest("b1");

    public MyTest b2 = new MyTest("b2");

    static BaseB()
    {
        MyTest b3 = new MyTest("b3");
    }

    public BaseB()
    {
        MyTest b4 = new MyTest("b4");
    }

    public new void MyFun()
    {
        MyTest b5 = new MyTest("b5");
    }
}

static class Program
{
    static void Main()
    {
        BaseB baseb = new BaseB();
        baseb.MyFun();
    }
}

public class MyTest
{
    public MyTest(string info)
    {
        Console.WriteLine(info);
    }
}

最后的问题是：请写出Main（）方法中，a1-a5，b1-b5这十个类实例化的顺序。（MyTest类是我自己添的，方便查看结果，原题是是实例化一个object类。）

不知道园子里有多少人能胸有成竹的写出正确答案，反正我是答错了，正确答案是：

b1
b3
b2
a1
a3
a2
a4
b4
b5

题目中涉及到的知识点

虽然题目没做对了，但要知道自己为什么会做错，这样才会有所提高，趁着端午的假期，我把这个面试题涉及到的知识点都梳理了一遍，要点如下：

1. 内联（inline）方式初始化字段。
2. 类型构造器（静态构造函数）的执行时间。
3. C#中基类和子类实例化的顺序。
4. new修饰符的作用。

内联方式初始化字段

这个知识点在《CLR via C#》书中有讲到，所谓内联方式，就是初始化字段的一种简化语法。来看示例代码：

public class SomeType
{
    public int m_x = 5;
}

这种在类中声明变量时进行赋值的方式就叫做内联，大致等效于下面的代码：

public class SomeType
{
    public int m_x;
    public SomeType()
    {
        m_x = 5;
    }
}

之所以说“大致等效”，因为两者的执行顺序上略有差异，编译器会首先生成内联方式的代码，然后再调用构造函数。

比如，下面的代码，最后m_x的结果就为10。

public class SomeType
{
    //先执行
    public int m_x=5;
    public SomeType()
    {
        //后执行
        m_x = 10;
    }
}

类型构造器的执行

所谓类型构造器也就是我们熟知的静态构造方法，在我们编写的类中，都会有一个默认的静态无参构造方法，跟无参实例构造方法一样是默认存在的。

每当我们对一个类创建第一个实例或访问静态字段前，JIT编译器就会调用该类的静态构造方法。当然，静态变量也可以使用上面说的内联方法进行赋值。

这里可以看出，当第一次实例化某个类时，会首先调用该类的静态构造方法。

C#中基类和子类实例化的顺序

这个知识点比较简单，那就是在调用子类实例构造方法之前会调用基类的实例构造方法。从面试题的结果可以看出，基类的构造方法又比子类的静态构造函数晚一些，此处因个人能力有限，我也没办法从更底层的角度去分析原理，只能暂且记住吧。

new修饰符的作用

我看过不少关于new以修饰符的形式用在方法声明中的题目，关于new的用法在MSDN上也都查的到，官方说法是“显式隐藏从基类继承的成员”。

我个人的理解比较简单：当子类中，一个方法的签名（指参数，方法名，返回值）与基类的一个方法相同，通过加入new修饰符，可以让子类不做更改的去使用该方法。

说到底，new修饰符就是让两个不相关的同名方法同时存在而已。（这里同名指相同的方法签名）

原文：http://www.cnblogs.com/hkncd/archive/2011/06/05/2073404.html

几个原则:
1.类的静态成员是在实例成员前被初始化的，涉及到类的加载和主动使用。
2.内联写法的初始化是最先的，无论是对于静态还是实例成员。
3.基类构造函数是在子类构造函数前调用的。

还有就是显式类型构造函数的影响。显示类型构造器可能包含具有副作用的代码，所以要精确拿捏调用静态构造函数的时间。精确也就是JIT编译器刚好在调用之前插入调用指令。由于BaseA的构造函数是在BaseB的构造函数调用的时候才被调用，所以调用类型构造器的指令就被插入这里了。
由于实例字段的内联写法是在调用父类构造器之前，所以b2会在a1之前。