一道面试题

Question

     using System; 
     class A 
     { 
          public static int X; 
          static A(){ 
               X=B.Y+1; 
          } 
      } 
      class B 
      { 
           public static int Y=A.X+1; 
           static B(){} 
           static void Main(){ 
                Console.WriteLine("X={0},Y={1}",A.X,B.Y); 
           } 
       } 
产生的输出结果是什么？ 为什么会是这样的结果?

Answer 1

X=1,Y=2默认整形为0.顺序是这样的：首先 Y = A.x+1;然后因为用到X,寻找X定义。 X= B.Y+1  所以X =1Y = 1+1 = 2.

Answer 2

X=B.Y+1; 
当盗用B.Y的是此时B.y的值为0
所以X=1
 int Y=A.X+1
所以Y=2

Answer 3

这是一个类型加载顺序的问题。using System;
class A
{
    public static int X;
    static A()
    {
        X = B.Y + 1;
    } 
}
class B
{
    public static int Y = A.X + 1;
    static B() { }}
//将Main方法提到c类型中时，运行结果就不一样了。
class C
{
    static void Main()
    {
        int i = A.X;  //JIT会首先加载类型A,输出结果是:X=2,Y=1;
        //int i = B.Y;  //JIT会首先加载类型B,输出结果是:X=1,Y=2;
        Console.WriteLine("X={0},Y={1}", A.X,B.Y);
        Console.ReadLine();
    }
}

Answer 4

  using System; 
    class A 
    { 
          public static int X; 
          static A(){ 
              X=B.Y+1;     
          } 
      } 
      class B 
      { 
          public static int Y=A.X+1;   当A.X时
          static B(){} 
          static void Main(){ 
                Console.WriteLine("X={0},Y={1}",A.X,B.Y); 
          } 
      } 
首先执行A.X时：
public static int X; 初始默认为０进入static A(){ 
              X=B.Y+1;     
          }　　　　　　　　　后 A.X得出1第二：B.Y赋值后也就为2了。

Answer 5

静态构造函数是当引用静态成员时在应用作用域里执行至多一次，
如果有MAIN方法，会先执行该类的静态构造函数
静态构造函数里的静态成员会依文本顺序依次默认值using System; 
    class A 
    { 
          public static int X; 
          static A(){   //第四步
              X=B.Y+1; 
          } 
      } 
      class B 
      { 
          public static int Y=A.X+1;   //第三步
          static B(){}  //第二步 
          static void Main(){  //第一步
                Console.WriteLine("X={0},Y={1}",A.X,B.Y); 
          } 
      } 结果为 X=1，Y=2

Answer 6

X=2,Y=11. Y = A.X + 1 = 0+1=1
2. X = B.Y+1 = 1+1=2

Answer 7

Y=A.X+1  
先执行类A的构造函数,这个时候Y还是0,所以X=B.Y+1 X为1
Y=1+1=2
输出x=1,y=2
你把程序输进去,设断点就知道他的执行顺序了..
  

Answer 8

线执行public static int Y=A.X+1;
当系统检索到A.X是会自动调用A的静态构造函数
此时的X=1,再返回语句public static int Y=A.X+1;
便得到Y=2,Mian()是最后执行的

Answer 9

X=1,Y=2.先走A,得到X=1,再走B，得到Y=2

Answer 10

程序在编译器执行顺序如下：    using System; 
    class A 
    { 
          public static int X;         //第二步，声明静态变量X, 默认值为0.
          static A(){ 
              X=B.Y+1;                //第三步，虽然检测到B.Y，但Y是静态变量，至今只声明，还没有完成赋值，默认值为0,所以X=1;
          } 
      } 
      class B 
      { 
          public static int Y=A.X+1;    //第一步， 检测到A.X,跳转到A类.     //第四步，执行完A类使得Y=1+1=2. 
          static B(){}                  //第五步，没有任何操作。
          static void Main(){ 
                Console.WriteLine("X={0},Y={1}",A.X,B.Y);    //第六步
          } 
      } 
分析：
1,声明为static的变量或构造函数只加载一次，而且首先执行。如果把变量不声明为static会是另一种结果。
2,public static int Y=A.X+1;这条语句在编译器里解析其实是分为两步，第一步是声明，第二步是赋值。
3,如果把Main函数拿出来放在另一类，执行又是另一种结果。可以单步调试执行。第一步执行的是Main函数了。

Answer 11

以下经查阅相关书籍得出，不敢妄下结论：首先，从Ｂ类进入．
如果静态字段有默认值（初始值），它就在调用静态构造函数之前指定．引用自《C#高级编程》第四版。另外，在这个问题里面我们讨论的是静态构造函数的执行顺序。而无参的静态构造函数是给默认实例构造函数不冲突的。所以要执行，public static int Y=A.X+1; 
此时引用A类里的静态字段了。这时A.X静态字段没有默认值（初始值），下一步执行静态构造函数，A.X的值被赋值为1。此时又回到了public static int Y=A.X+1;计算出B.Y的值是2. 所以X=1,Y=2.过程就是这样的。