Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

C# 静态构造函数,静态变量执行顺序(升华版)

凯帝农垦 2019-01-24 23:04:00 阅读数:183 评论数:0 点赞数:0 收藏数:0

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

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

 

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

到现在为止,我们就暂且告一段落了,当然最后声明下,上面的这些测试都是一次调用的情况,我们想大家应该知道。其实,上面说了那么一大堆,这个现象的原理是什么,编译器编译后他们都有什么不同呢

来看下 下片的介绍:关于 BeforeFieldInit 的东西 : 点我
版权声明
本文为[凯帝农垦]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/wwkk/p/10317476.html

编程之旅,人生之路,不止于编程,还有诗和远方。
阅代码原理,看框架知识,学企业实践;
赏诗词,读日记,踏人生之路,观世界之行;

支付宝红包,每日可领