C# 静态构造函数，静态变量执行顺序（升华版）

上篇是基本语法基础下的执行顺序，包括继承这个维度下的执行顺序，我们可以依照的规律顺下来，下面我们看下一些摸不到头脑的情况

我们实验一个类中的方法去调用另一个非继承类的情况，我们主要看下静态构造函数和没有静态构造函数执行顺序上的差别

① 开始实验和观察

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();
        }
 
......<br>

如果对调用层做个包装呢

....
  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
 
       }
   }