看看下面这段代码，你觉得它会输出什么呢？

　　class Foo
　　{
　　　　public Foo(string s)
　　　　{
　　　　　　Console.WriteLine("Foo constructor: {0}", s);
　　　　}
　　　　public void Bar(){}
　　}
　　class Base
　　{
　　　　readonly Foo baseFoo = new Foo("Base initializer");
　　　　public Base()
　　　　{
　　　　　　Console.WriteLine("Base constructor");
　　　　}
　　}
　　class Derived : Base
　　{
　　　　readonly Foo derivedFoo = new Foo("Derived initializer.");
　　　　public Derived()
　　　　{
　　　　　　Console.WriteLine("Derived constructor");
　　　　}
　　}
　　class Program
　　{
　　　　static void Main(string[] args)
　　　　{
　　　　　　new Derived();
　　　　}
　　}

　　先猜一下吧，似乎应该是“Base initializer, Base constructor, Derived initializer, Derived constructor”。

　　事实上，应当是先执行类成员的初始化，顺序是从derived到base，然后是两个构造函数，顺序是从base从derived。

　　这种方式是很有意义的，在类继承体系中层次较深的类（离System.Object较远）将依赖于较浅的类（离System.Object较近）。但是很多人会相信调用的顺序应当等价于下面的伪代码：

// 期望的顺序
BaseConstructor()
{
　　ObjectConstructor();
　　baseFoo = new Foo("Base initializer");
　　Console.WriteLine("Base constructor");
}
DerivedConstructor()
{
　　BaseConstructor();
　　derivedFoo = new Foo("Derived initializer");
　　Console.WriteLine("Derived constructor");
}

　　而实际情况则是：

// 实际的顺序
BaseConstructor()
{
　　baseFoo = new Foo("Base initializer");
　　ObjectConstructor();
　　Console.WriteLine("Base constructor");
}
DerivedConstructor()
{
　　derivedFoo = new Foo("Derived initializer");
　　BaseConstructor();
　　Console.WriteLine("Derived constructor");
}

　　那么，这样处理是为什么呢？

　　...

　　...

　　...

　　我们来看一下，如果代码按期望的顺序（第一段伪代码）执行，会产生什么问题：

class Base
{
　　public Base()
　　{
　　　　Console.WriteLine("Base constructor");
　　　　if (this is Derived) (this as Derived).DoIt();
　　　　// 如果是在创建Derived类的实例，就会遭遇null。
　　　　Blah();
　　　　// 如果是在创建MoreDerived类的实例，就会遭遇null。
　　}
　　public virtual void Blah() { }
}
class Derived : Base
{
　　readonly Foo derivedFoo = new Foo("Derived initializer");
　　public DoIt()
　　{
　　　　derivedFoo.Bar();
　　}
}
class MoreDerived : Derived
{
　　public override void Blah() { DoIt(); }
}

　　看Base类的构造函数，如果按期望的顺序执行，那么在Base方法执行时，Derived类的实例成员并没有得到初始化，此时就会有NullReference异常了。

　　而按照实际执行的顺序，所有的实例成员都能确保被完整地初始化:)

　　当然了，如果readonly字段是在构造函数中进行的，那么上面的确保机制就不复存在了。