programacion - Diferencia al inicializar variable estática en línea o en constructor estático en C#

variables static c#

Question

Me gustaría saber cuál es la diferencia entre inicializar un miembro estático en línea como en:

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

o inicializándolo dentro del constructor estático como en:

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

Answer 1

En este caso, no creo que haya ninguna diferencia práctica. Si necesita algo de lógica para inicializar las variables estáticas, como si quisiera usar diferentes tipos concretos de una interfaz dadas las diferentes condiciones, debería usar el constructor estático. De lo contrario, la inicialización en línea está bien en mi libro.

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

Answer 2

Respuesta de la zona crepuscular: Hay una diferencia en el orden de ejecución entre los inicializadores en línea y la asignación de ctor ... cuando se mezcla en instancia y miembros estáticos y herencia para arrancar.

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.

Ejemplo :)

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();

Salida:

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 

Answer 3

Si tiene un constructor estático en su tipo, altera la inicialización de tipo debido a que el indicador beforefieldinit ya no se aplica.

También afecta el orden de inicialización: los inicializadores de variables se ejecutan antes que el constructor estático.

Aunque eso es todo lo que sé.