上篇 是基本语法基础下的执行顺序，包括继承这个维度下的执行顺序，我们可以依照的规律顺下来，下面我们看下一些摸不到头脑的情况
我们实验 一个 类中的方法 去调用另一个非继承类的情况， 我们主要看下 静态构造函数 和没有静态构造函数执行顺序上的差别
class Program
{
static void Main(string[] args)
{ //执行顺序5
var de = new People("2"); //执行顺序6
People.Instance.OutDemo(); //执行顺序8
Console.ReadKey(); //执行顺序10
}
}
public class People
{
public void OutDemo()
{ //执行顺序9
Console.WriteLine($"HaHa");
}
public static readonly People Instance = new People(); //执行顺序1
public static Action Inssstance = () => { Console.WriteLine("11"); }; //执行顺序4
private People()
{ //执行顺序2
Console.WriteLine(3); //执行顺序3
}
public People(string ss)
{ //执行顺序7
}
}
执行顺序 大致是上面十个步骤， 是不是感觉有点蒙蔽了，首先刚开始就没进Main函数，跳到 People下面了，好吧，我们暂且给自己一个说服自己的理由，如果方法中有直接调另一个类的静态成员的，先去走到另一个类中去初始化去.
ok, 接下来 执行顺序1 中赋值的时候 调的 new People()，然后到 执行顺序2 里面， 而另一个静态的 执行顺序4 在执行顺序3走完 随后 ，这个也可以理解，谁让执行顺序2 人家 赋值的时候 调的构造函数呢，然后执行顺序4走完 ok，没有静态的了，调回到原 Program里的main方法了，这个和上篇讲的静态走完再走非静态的不一样，这个也可以理解，谁让两个类不是继承的呢，到Program的Main后 继续 5 、6、7、 8、9、10，这个顺序没有异议。
ok，我们似乎给了自己一个完美的解释。先别高兴的太早，接下来，我们一步步走起，我们再做一件事情：
我们给program定义一个静态构造函数。然后再看下顺序会是什么样的：
class Program
{
static Program()
{ //然后执行
}
static void Main(string[] args)
{
var de = new People("2");
People.Instance.OutDemo();
Console.ReadKey(); //执行顺序10
}
public static string sdds = "sdds"; //最先执行
}
我们加了个静态字段，又加了个静态构造函数， 整个顺序： 最先执行 ，然后执行 ，执行顺序1，执行顺序2,......
没有问题，和上片的知识体系相符，没啥惊喜
既然Program下没什么东东，我们就整下 People类吧，我们也给People类加个静态构造函数，现在看看：
class Program
{
static Program()
{ //然后执行
}
static void Main(string[] args)
{ 执行顺序1
var de = new People("2"); 执行顺序2
People.Instance.OutDemo(); //执行顺序8
Console.ReadKey();
}
public static string sdds = "sdds"; //最先执行
}
public class People
{
static People()
{ //执行顺序7
}
public void OutDemo()
{ //执行顺序9
Console.WriteLine($"HaHa");
}
public static readonly People Instance = new People(); //执行顺序3
public static Action Inssstance = () => { Console.WriteLine("11"); }; //执行顺序6
private People()
{ //执行顺序4
Console.WriteLine(3); //执行顺序5
}
public People(string ss)
{ //执行顺序7
}
}
眼尖的你发现 给People加了个静态构造函数，现在顺序变成了： 最先执行，然后执行，执行顺序1，执行顺序2，执行顺序3，....，发现 Program静态走完后，走进去Main方法了，不是先进People了。
啊，匪夷所思，那么没关系，我们自解惑的思想继续改造。我们在先前的一个思想上再加个情况，如果一个类A中去调用另一个类B的静态成员，如果类B有定义了静态的构造函数，那么我们就按顺序走，不会先预先跑到B中初始化B的静态相关的。只到代码碰到B的地方，再去B中走静态相关的部分。
ok，好像我们的理论又成熟了一步，我们在看看，还有什么意外不
又来了一个新点子去验证下，如果我们在People中，在初始化静态成员的时候，再去调第三个类的静态成员呢：
.....
public static readonly People Instance = new People(); //执行顺序3
public static Action Inssstance = () => { Console.WriteLine("11"); }; //执行顺序7
private People()
{ //执行顺序5
var d= Money.Count //执行顺序6
Console.WriteLine(3);
}
........
public class Money
{
public static int Count= "4"; //执行顺序4
}
......
我们发现相关顺序仔细捋下来好像没有什么意外， 执行顺序 3 后 会去调 new People 调这个方法的时候，我们先有个预判断，发现这个方法里面有个调用第三个类Money的静态成员，而第Money又没有定义静态构造函数，嗯，符合跳转的条件 ，然后 到了 执行顺序4 ， 然后是执行顺序5 ，然后是执行顺序6 ，执行顺序7
接下来，迫不及待的给Money加个静态构造函数
.....
static People()
{ //执行顺序10
}
public static readonly People Instance = new People(); //执行顺序3
public static Action Inssstance = () => { Console.WriteLine("11"); }; //执行顺序9
private People()
{ //执行顺序4
var d= Money.Count //执行顺序5
Console.WriteLine(3); //执行顺序8
}
........
public class Money
{
static Money()
{ //执行顺序7
}
public static int Count= "4"; //执行顺序6
}
......
依然符合。结论依然牢固
还要继续玩吗，继续新的怀疑
如果我们把不被别的地方调的静态成员变成私有的呢，会不会影响顺序了，这个我这里就不列了，答案是：不会
继续，总觉的还有没有挖掘的东西需要一探究竟
我们突然发现，上面我们调的都是另一个类的静态字段，如果是调的另一个类的静态方法呢，会不会也是这个规律呢
改造起来
class Program
{
static Program()
{ //然后执行
}
static void Main(string[] args)
{ 执行顺序1
// var de = new People("2");
//People.Instance.OutDemo();
People.xixi(); //执行顺序2
Console.ReadKey(); //执行顺序8
}
public static string sdds = "sdds"; //最先执行
}
public class People
{
public static string xixi()
{ //执行顺序7
return "xixi";
}
public void OutDemo()
{
Console.WriteLine($"HaHa");
}
public static readonly People Instance = new People(); //执行顺序3
public static Action Inssstance = () => { Console.WriteLine("11"); }; //执行顺序6
private People()
{ //执行顺序4
Console.WriteLine(3); //执行顺序5
}
public People(string ss)
{
}
}
简单测试发现，好像直接调另一个类的静态方法没有符合上面的规律，而是符合常规的规律,不过People加不加静态构造函数，都不会有我们发现的”预先跳转“，它和调用另一个类的静态字段不一样，就调用另一类的静态字段有这个特殊性预先跳转，具体大家可以测试下
如果我们在调用的时候再加上调用People那个静态字段，那效应就会出来了：
.......
static void Main(string[] args)
{
People.xixi();
People.Instance.OutDemo(); //有这个 就会先判断People有没有静态构造函数，来决定是否在进main方法前先 预先跳转
Console.ReadKey();
}
......
如果对调用层做个包装呢
....
static void Main(string[] args)
{ //执行顺序1
dtas(); //执行顺序2
// Console.WriteLine(People.Instance.OutDemo());
Console.ReadKey();
}
public static void dtas()
{ //执行顺序4
People.Instance.OutDemo();
}
.......
//假设People没有静态构造函数
......
//public static readonly People Instance = new People(); //执行顺序3
....
结果也符合，进main方法了，在进dtas（）方法时进行了预先判断,注意，方法的包一层，我注释的：Console.WriteLine(People.Instance.OutDemo());其实和 datas()是一个效果，都是包了一层，不要反应不过来哟
然后，我们对People的静态字段再改下
......
static void Main(string[] args)
{ 执行顺序2
People.Instance().OutDemo(); 执行顺序3
Console.ReadKey(); //执行顺序7
}
.......
//假设People没有静态构造函数
......
//public static readonly People Instance = new People();
//换成下面这中
public static readonly Func Instance = () => { 执行顺序1
return new People(); 执行顺序4
};
public void OutDemo()
{ 执行顺序5
Console.WriteLine($"HaHa"); 执行顺序6
}
.......
我们发现这个调用静态字段如果用委托的方式，会到 Instance这个没错，但是 字段的赋值部分（return new People()）就在后期真正调的时候执行了，这个大家注意下这点
在最后给大家一个层次多点的例子，或许你们会吐槽哪有这么写代码的，现实情况下也不这么调啊，一点都不实际，其实还真有场景有可能这么调的，这只是一个映射现实代码的一个 简单的demo原型而已。你们能捋通下面的了吗？再试着给Middle加个静态构造函数呢？你们可以试试，我就不展示了
class Class1
{
static void Main(string[] args)
{ //执行顺序 6
var obj = People.Instance; //执行顺序 7
Console.Read(); //执行顺序 8
}
}
public class People
{
public static readonly ZIS2 Instance = Middle.mid; //执行顺序 4
public static string dsds = "sdd"; //执行顺序 5
}
public class Middle
{
public static ZIS2 mid = ZIS2.Instance; //执行顺序 3
}
public class ZIS2
{
public static ZIS2 Instance = new ZIS2(); //执行顺序 1
private ZIS2()
{ //执行顺序 2
}
}
到现在为止，我们就暂且告一段落了，当然最后声明下，上面的这些测试都是一次调用的情况，我们想大家应该知道。其实，上面说了那么一大堆，这个现象的原理是什么，编译器编译后他们都有什么不同呢