“C#静态变量的诡异与恶心”之我见

今天看到了一个帖子题目说是"C#静态变量的诡异与恶心 "

我也说说我的看法，看下面的C#代码

   1. using System;  
   2.   
   3. namespace StaticTest  
   4. {  
   5.     class A  
   6.     {  
   7.         public static int X;  
   8.         static A()  
   9.         {  
  10.             X = B.Y + 1;  
  11.         }  
  12.     }  
  13.     class B  
  14.     {  
  15.         public static int Y = A.X + 1;  
  16.         static B()  
  17.         {  
  18.         }  
  19.         static void Main()  
  20.         {  
  21.             Console.WriteLine("X={0}, Y={1}", A.X, B.Y);  
  22.         }  
  23.     }  
  24. }  

 打印结果为X= 1 , Y= 2

第二个例子，java代码

   1. class StaticTest  
   2. {  
   3.     public static void main(String[] args){  
   4.         System.out.println(Integer.toString(A.X) +" "+Integer.toString(B.Y));  
   5.     }  
   6. }  
   7.   
   8. class A  
   9. {  
  10.     static int X = B.Y + 1;  
  11. }  
  12.   
  13. class B  
  14. {  
  15.     static int Y = A.X + 1;  
  16. }  
打印的结果为 2 1
结果看上去挺诡异的，其实还是需要分析一下
C#与java差不多，不分开讲
对于第一个例子，
1 在运行main之前，所有的变量进行默认初始化，X=0，Y=0
2 为了运行main方法，需要对类B进行静态初始化
3 B静态初始化，需要初始化静态变量Y
4 Y的初始化需要用到A的变量X，需要初始化类A
5 A的初始化时，又需要用到了Y变量，而此时类B早已经开始初始化，故不会再对B初始化，避免循环
6 直接取Y=0，得到X=1
7 然后返回后Y再被初始化为2
对于第二个例子
1 在运行main之前，所有的变量进行默认初始化，X=0，Y=0
2 由于需要调用A.X，故需要对A进行静态初始化
3 A中使用Y，对B进行初始化
4 B中又用到X，但由于A已经开始初始化，故不循环，直接取X=0，得到Y=1
5 然后得到X=2