Difference khởi inline biến tĩnh hoặc trong constructor tĩnh trong C#

Question

Tôi muốn biết sự khác biệt giữa khởi tạo một thành viên tĩnh inline như trong là gì:

class Foo 
{ 
    private static Bar bar_ = new Bar(); 
} 

hoặc khởi tạo nó bên trong constructor tĩnh như trong:

class Foo 
{ 
    static Foo() 
    { 
     bar_ = new Bar(); 
    } 
    private static Bar bar_; 
} 

Answer 1

Nếu bạn có một hàm tạo tĩnh trong loại của bạn, nó sẽ thay đổi loại khởi tạo do cờ beforefieldinit không còn được áp dụng nữa.

Nó cũng ảnh hưởng đến thứ tự khởi tạo - biến khởi tạo biến được thực thi trước hàm dựng tĩnh.

Đó là về nó theo như tôi biết.

Answer 2

Trong trường hợp này, tôi không tin rằng có bất kỳ sự khác biệt thực tế nào. Nếu bạn cần một số logic trong việc khởi tạo các biến tĩnh - giống như nếu bạn muốn sử dụng các loại bê tông khác nhau của một giao diện cho các điều kiện khác nhau - bạn sẽ sử dụng hàm tạo tĩnh. Khác, khởi tạo nội tuyến là tốt trong cuốn sách của tôi.

class Foo 
{ 
    private static IBar _bar; 

    static Foo() 
    { 
     if(something) 
     { 
      _bar = new BarA(); 
     } 
     else 
     { 
      _bar = new BarB(); 
     } 
    } 
} 

Answer 3

Câu trả lời vùng hoàng hôn: Có sự khác biệt trong thứ tự thực hiện giữa khởi tạo nội tuyến và gán ctor ... khi bạn kết hợp các thành viên ví dụ và tĩnh và kế thừa để khởi động.

For static members, static initializers 
Static ctors (execute bottom up) 
Base static initializer 
Base static ctor and so on 

For instance members, initializers in current class execute first 
Then initializers in base class execute (up the chain) 
Then top-most base ctor is executed (and we walk down now. Instance ctors execute top-down) 
Finally current type's ctor is executed. 

Ví dụ :)

public class CBase 
    { 
     static Talkative m_Baseob1 = new Talkative("Base Static Initializer-"); 
     static Talkative m_Baseob2; 
     Talkative m_Baseob3 = new Talkative("Base Inst Initializer"); 
     Talkative m_Baseob4; 
     static CBase() 
     { 
      Console.WriteLine("***MethodBegin: Static Base Ctor"); 
      m_Baseob2 = new Talkative("Base Static Ctor"); 
      Console.WriteLine("***MethodEnd: Static Base Ctor"); 
     } 
     public CBase() 
     { 
      Console.WriteLine("***MethodBegin: Instance Base Ctor"); 
      m_Baseob4 = new Talkative("Base Instance Ctor"); 
      Console.WriteLine("***MethodEnd: Instance Base Ctor"); 
     } 
    } 
    public class CDerived : CBase 
    { 
     static Talkative m_ob1 = new Talkative("Derived Static Initializer"); 
     static Talkative m_ob2; 
     Talkative m_ob3 = new Talkative("Derived Inst Initializer"); 
     Talkative m_ob4; 
     static CDerived() 
     { 
      Console.WriteLine("***MethodBegin: Derived Static Ctor"); 
      m_ob2 = new Talkative("Derived Static Ctor"); 
      Console.WriteLine("***MethodEnd: Derived Static Ctor"); 
     } 
     public CDerived() 
     { 
      Console.WriteLine("***MethodBegin: Derived Instance Ctor"); 
      m_ob4 = new Talkative("Derived Instance Ctor"); 
      Console.WriteLine("***MethodEnd: Derived Instance Ctor"); 
     } 
    } 
    internal class Talkative 
    { 
     public Talkative(string sID) 
     { 
      Console.WriteLine(sID + " - Talkative created"); 
     } 
    } 

    # Main function somewhere 
    CDerived s = new CDerived(); 

Output:

Derived Static Initializer - Talkative created 

***MethodBegin: Derived Static Ctor 
Derived Static Ctor - Talkative created 
***MethodEnd: Derived Static Ctor 

Derived Inst Initializer - Talkative created 

Base Static Initializer- - Talkative created 

***MethodBegin: Static Base Ctor 
Base Static Ctor - Talkative created 
***MethodEnd: Static Base Ctor 

Base Inst Initializer - Talkative created 

***MethodBegin: Instance Base Ctor 
Base Instance Ctor - Talkative created 
***MethodEnd: Instance Base Ctor 

***MethodBegin: Derived Instance Ctor 
Derived Instance Ctor - Talkative created 
***MethodEnd: Derived Instance Ctor