C#构造函数调用（有待进一步考证）

要弄清这个问题，我们可以先做个简单的测试。新建三个类：父类,子类,测试类

父类：

public class Father
     {
           public int father_a=111;
           public int father_aa=1111;
           public readonly int father_c=7777;
           public static int father_e=222;
           public static int father_ee;

         //静态构造函数
          static Father()
          {
               father_e=5555;
               father_ee=3333;
          }

         //无参构造函数
          public Father()
          {
               father_ee=4444;
          }

         //非无参构造函数
          public Father(int a)
          {
               father_a=a;
          }    
      }

子类：

public class Son:Father
    {  
       public int son_int=9999;
       public static int son_b=111;
       public static int son_c;
       public Son()
       {
            son_c=222;   
       }
       static Son()
       {
            son_c=333;
       }
       public Son(int a)
       {
            son_int=a;
       }
    }

测试一

class Program
{        
        static void Main(string[] args)
        {
            
            Son s1=new Son();

            Console.ReadKey();
        }
}

然后一路F11,进行跟踪,可以得到完整的执行顺序如下所示:
         1.子类静态变量;
         2.子类静态构造函数;
         3.子类非静态变量;
         4.父类静态变量;
         5.父类静态构造函数;
         6.父类非静态变量;
         7.父类无参构造函数;
         8.子类无参构造函数;

测试二

如果Main()方法中改为Son son1=new Son (111),顺序为;
1.子类静态变量;
2.子类静态构造函数;
3.子类非静态变量;
4.父类静态变量;
5.父类静态构造函数;
6.父类非静态变量;
7.父类无参构造函数;
8.子类有参构造函数;

如果子类的有参构造函数改为:
 public Son(int a):base(a)
 {
  son_int=a;
 }
则顺序又有所改变:

1.子类静态变量;
2.子类静态构造函数;
3.子类非静态变量;
4.父类静态变量;
5.父类静态构造函数;
6.父类非静态变量;
7.父类有参构造函数;
8.子类有参构造函数;

以上测试改为父类声明,子类实现,结果也是一样,即main()方法中改为Father son1=new Son ();

最后作一个总结: 
1.一般原理是被依赖的先构造,依赖于人的后构造,c#中是同层依赖(成员变量,其他的类变量等)优先于跨层依赖(父子关系)构造(注意java中正好相反);(子类的变量是不是可以理解为同层的依赖呢)
2.静态构造函数,静态参数都是优先于非静态构造函数,非静态参数构造或初始化;