¿Cómo funciona un constructor estático?

namespace MyNameSpace
{
    static class MyClass
    {
        static MyClass()
        {
            //Authentication process.. User needs to enter password
        }

        public static void MyMethod()
        {
            //Depends on successful completion of constructor
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass.MyMethod();
        }
    }
}

Aquí está la secuencia que asumí

1. Inicio del constructor estático
2. Fin del constructor estático
3. Inicio de principal
4. Inicio de MyMethod
5. Fin de principal

Ahora, en cualquier escenario, si 4 comenzará antes de 2, estoy jodido. ¿Es posible?

Aquí solo hizo una pregunta, pero hay una docena de preguntas que debería haber hecho, así que las responderé todas.

Aquí está la secuencia que asumí

1. Inicio del constructor de clase (también conocido como cctor)
2. Fin de cctor
3. inicio de Main
4. inicio de MyMethod

¿Es esto correcto?

No. La secuencia correcta es:

1. Inicio del cctor para el programa, si lo hay. No hay.
2. Fin de cctor para el programa, si hay uno. No hay.
3. Inicio de Main
4. Inicio de cctor para MyClass
5. Fin de cctor para MyClass
6. Inicio de MyClass.MyMethod

¿Qué pasa si hay un inicializador de campo estático?

El CLR puede cambiar el orden en el que se ejecutan los inicializadores de campo estático en algunos casos. Vea la página de Jon sobre el tema para más detalles:

Las diferencias entre constructores estáticos e inicializadores de tipo

¿Es posible alguna vez MyMethodllamar a un método estático como antes de que se complete el cctor de esa clase?

Si. Si el propio cctor llama a MyMethod, obviamente se llamará a MyMethod antes de que se complete el cctor.

El cctor no llama a MyMethod. ¿Es posible MyMethodque se llame a un método estático como antes de que se complete el cctor de MyClass?

Si. Si el cctor usa otro tipo cuyo cctor llama a MyMethod, entonces se llamará a MyMethod antes de que se complete el cctor MyClass.

¡Ningún actor llama a MyMethod, directa o indirectamente! Ahora bien, ¿alguna vez es posible MyMethodque se llame a un método estático como antes de que se complete el cctor de MyClass?

No.

¿Sigue siendo cierto incluso si hay varios hilos involucrados?

Si. El cctor terminará en un hilo antes de que se pueda llamar al método estático en cualquier hilo.

¿Se puede llamar al cctor más de una vez? Suponga que dos subprocesos hacen que se ejecute el cctor.

Se garantiza que el cctor se llamará como máximo una vez, sin importar cuántos subprocesos estén involucrados. Si dos hilos llaman a MyMethod "al mismo tiempo", corren. Uno de ellos pierde la carrera y bloquea hasta que el cctor MyClass completa el hilo ganador.

¿El hilo perdedor se bloquea hasta que termina el ciclo? ¿ De verdad ?

De Verdad.

Entonces, ¿qué pasa si el cctor en el hilo ganador llama al código que bloquea en un bloqueo tomado previamente por el hilo perdedor ?

Entonces tienes una condición clásica de inversión de orden de bloqueo. Su programa se bloquea. Siempre.

Eso parece peligroso. ¿Cómo puedo evitar el estancamiento?

Si te duele cuando haces eso, deja de hacerlo . Nunca hagas algo que pueda bloquear un cctor.

¿Es una buena idea confiar en la semántica de inicialización de cctor para hacer cumplir los requisitos de seguridad complejos? ¿Y es una buena idea tener un actor que interactúe con los usuarios?

Tampoco lo son las buenas ideas. Mi consejo es que debe encontrar una manera diferente de asegurarse de que se cumplan las condiciones previas de sus métodos que afectan la seguridad.

Según MSDN , un constructor estático:

Se llama automáticamente a un constructor estático para inicializar la clase antes de que se cree la primera instancia o se haga referencia a cualquier miembro estático.

Por lo tanto, se llamará al constructor estático antes de que MyClass.MyMethod()se invoque el método estático (suponiendo que no se invoca también durante la construcción estática o la inicialización del campo estático, por supuesto).

Ahora, si está haciendo algo asincrónico en eso static constructor, entonces es su trabajo sincronizar eso.

El n. ° 3 es en realidad el n. ° 1: la inicialización estática no comienza hasta el primer uso de la clase a la que pertenece.

Es posible si MyMethodse llama desde el constructor estático o desde un bloque de inicialización estático. Si no invoca MyMethoddirecta o indirectamente desde su constructor estático, debería estar bien.

De la documentación (el énfasis es mío):

Se llama automáticamente a un constructor estático para inicializar la clase antes de que se cree la primera instancia o se haga referencia a cualquier miembro estático .

Puede garantizar que 4 siempre vendrá después de 2 (si no crea una instancia de su clase a partir de su método estático), sin embargo, no ocurre lo mismo con 1 y 3.

Se llamará al constructor estático antes de que se ejecute mymethod. Sin embargo, si está jodido si se llama 4 antes que 2, le sugiero que reconsidere su diseño. De todos modos, no debería estar haciendo cosas complicadas en un constructor estático.

CLR garantiza que el constructor estático se ejecuta antes de que se acceda a cualquier miembro estático. Sin embargo, tu diseño huele un poco mal. Sería más sencillo hacer algo como esto:

static void Main(string[] args) 
{ 
     bool userIsAuthenticated = MyClass.AuthenticateUser();
     if (userIsAuthenticated)
         MyClass.MyMethod(); 
 } 

Con su diseño, si la autenticación falla, la única forma de evitar que MyMethod se ejecute es lanzando una excepción.

Se garantiza que se haya llamado al constructor de una clase estática antes de que se ejecute cualquiera de sus métodos. Ejemplo:

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Press enter");
        Console.ReadLine();
        Boop.SayHi();
        Boop.SayHi();
        Console.ReadLine();
    }

}

static class Boop
{
    static Boop()
    {
        Console.WriteLine("Hi incoming ...");
    }

    public static void SayHi()
    {
        Console.WriteLine("Hi there!");
    }
}

Salida:

Presione enter

// después de presionar enter

Hola entrante ...

¡Hola!

¡Hola!

Aquí está el orden real en el que van las cosas:

1. Inicio de Main
2. Inicio del MyClassconstructor estático
3. Fin del MyClassconstructor estático
4. Inicio de MyMethod
5. Final de Main

O puede pasar por el depurador.