Le thread constructeur statique C # est-il sûr?

En d'autres termes, ce thread d'implémentation Singleton est-il sûr:

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

    static Singleton()
    {
        instance = new Singleton();
    }

    public static Singleton Instance
    {
        get { return instance; }
    }
}

Les constructeurs statiques sont garantis pour être exécutés une seule fois par domaine d'application, avant la création de toute instance d'une classe ou l'accès à des membres statiques. https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-constructors

L'implémentation indiquée est thread-safe pour la construction initiale, c'est-à-dire qu'aucun verrouillage ou test nul n'est requis pour construire l'objet Singleton. Cependant, cela ne signifie pas que toute utilisation de l'instance sera synchronisée. Il existe différentes façons de procéder; J'en ai montré un ci-dessous.

public class Singleton
{
    private static Singleton instance;
    // Added a static mutex for synchronising use of instance.
    private static System.Threading.Mutex mutex;
    private Singleton() { }
    static Singleton()
    {
        instance = new Singleton();
        mutex = new System.Threading.Mutex();
    }

    public static Singleton Acquire()
    {
        mutex.WaitOne();
        return instance;
    }

    // Each call to Acquire() requires a call to Release()
    public static void Release()
    {
        mutex.ReleaseMutex();
    }
}

Bien que toutes ces réponses donnent la même réponse générale, il y a une mise en garde.

N'oubliez pas que toutes les dérivations potentielles d'une classe générique sont compilées en tant que types individuels. Soyez donc prudent lorsque vous implémentez des constructeurs statiques pour les types génériques.

class MyObject<T>
{
    static MyObject() 
    {
       //this code will get executed for each T.
    }
}

ÉDITER:

Voici la démonstration:

static void Main(string[] args)
{
    var obj = new Foo<object>();
    var obj2 = new Foo<string>();
}

public class Foo<T>
{
    static Foo()
    {
         System.Diagnostics.Debug.WriteLine(String.Format("Hit {0}", typeof(T).ToString()));        
    }
}

Dans la console:

Hit System.Object
Hit System.String

L'utilisation d'un constructeur statique est en fait threadsafe. Le constructeur statique ne peut être exécuté qu'une seule fois.

De la spécification du langage C # :

Le constructeur statique d'une classe s'exécute au plus une fois dans un domaine d'application donné. L'exécution d'un constructeur statique est déclenchée par le premier des événements suivants à se produire dans un domaine d'application:

• Une instance de la classe est créée.
• Tous les membres statiques de la classe sont référencés.

Alors oui, vous pouvez être sûr que votre singleton sera correctement instancié.

Zooba a fait valoir un excellent point (et 15 secondes avant moi aussi!) Que le constructeur statique ne garantira pas un accès partagé thread-safe au singleton. Cela devra être traité d'une autre manière.

Voici la version Cliffnotes de la page MSDN ci-dessus sur c # singleton:

Utilisez toujours le modèle suivant, vous ne pouvez pas vous tromper:

public sealed class Singleton
{
   private static readonly Singleton instance = new Singleton();

   private Singleton(){}

   public static Singleton Instance
   {
      get 
      {
         return instance; 
      }
   }
}

Au-delà des fonctionnalités évidentes de singleton, il vous offre ces deux choses gratuitement (en ce qui concerne singleton en c ++):

1. construction paresseuse (ou pas de construction si elle n'a jamais été appelée)
2. synchronisation

Les constructeurs statiques sont garantis de se déclencher une seule fois par domaine d'application, votre approche doit donc être correcte. Cependant, elle n'est fonctionnellement pas différente de la version en ligne plus concise:

private static readonly Singleton instance = new Singleton();

La sécurité des threads est plus un problème lorsque vous initialisez des choses paresseusement.

Le constructeur statique terminera son exécution avant qu'un thread ne soit autorisé à accéder à la classe.

    private class InitializerTest
    {
        static private int _x;
        static public string Status()
        {
            return "_x = " + _x;
        }
        static InitializerTest()
        {
            System.Diagnostics.Debug.WriteLine("InitializerTest() starting.");
            _x = 1;
            Thread.Sleep(3000);
            _x = 2;
            System.Diagnostics.Debug.WriteLine("InitializerTest() finished.");
        }
    }

    private void ClassInitializerInThread()
    {
        System.Diagnostics.Debug.WriteLine(Thread.CurrentThread.GetHashCode() + ": ClassInitializerInThread() starting.");
        string status = InitializerTest.Status();
        System.Diagnostics.Debug.WriteLine(Thread.CurrentThread.GetHashCode() + ": ClassInitializerInThread() status = " + status);
    }

    private void classInitializerButton_Click(object sender, EventArgs e)
    {
        new Thread(ClassInitializerInThread).Start();
        new Thread(ClassInitializerInThread).Start();
        new Thread(ClassInitializerInThread).Start();
    }

Le code ci-dessus a produit les résultats ci-dessous.

10: ClassInitializerInThread() starting.
11: ClassInitializerInThread() starting.
12: ClassInitializerInThread() starting.
InitializerTest() starting.
InitializerTest() finished.
11: ClassInitializerInThread() status = _x = 2
The thread 0x2650 has exited with code 0 (0x0).
10: ClassInitializerInThread() status = _x = 2
The thread 0x1f50 has exited with code 0 (0x0).
12: ClassInitializerInThread() status = _x = 2
The thread 0x73c has exited with code 0 (0x0).

Même si l'exécution du constructeur statique a pris du temps, les autres threads se sont arrêtés et ont attendu. Tous les threads lisent la valeur de _x définie en bas du constructeur statique.

La spécification Common Language Infrastructure garantit qu '"un initialiseur de type doit s'exécuter exactement une fois pour tout type donné, sauf s'il est explicitement appelé par le code utilisateur". (Section 9.5.3.1.) Donc, à moins que vous ayez un IL fou sur l'appel libre Singleton ::. Cctor directement (peu probable), votre constructeur statique s'exécutera exactement une fois avant l'utilisation du type Singleton, une seule instance de Singleton sera créée, et votre propriété d'instance est thread-safe.

Notez que si le constructeur de Singleton accède à la propriété Instance (même indirectement), la propriété Instance sera null. Le mieux que vous puissiez faire est de détecter quand cela se produit et de lever une exception, en vérifiant que l'instance n'est pas nulle dans l'accesseur de propriété. Une fois votre constructeur statique terminé, la propriété Instance sera non nulle.

Comme le souligne la réponse de Zoomba, vous devrez sécuriser Singleton pour accéder à partir de plusieurs threads, ou implémenter un mécanisme de verrouillage autour de l'utilisation de l'instance singleton.

Juste pour être pédant, mais il n'y a pas de constructeur statique, mais plutôt des initialiseurs de type statique, voici une petite démonstration de la dépendance cyclique du constructeur statique qui illustre ce point.

Le constructeur statique est garanti pour être thread-safe. Consultez également la discussion sur Singleton sur DeveloperZen: http://web.archive.org/web/20160404231134/http://www.developerzen.com/2007/07/15/whats-wrong-with-this-code -1-discussion /

Bien que d'autres réponses soient pour la plupart correctes, il y a encore une autre mise en garde avec les constructeurs statiques.

Conformément à la section II.10.5.3.3 Courses et blocages de l' infrastructure linguistique commune ECMA-335

L'initialisation de type à elle seule ne doit pas créer un blocage sauf si un code appelé depuis un initialiseur de type (directement ou indirectement) appelle explicitement des opérations de blocage.

Le code suivant entraîne un blocage

using System.Threading;
class MyClass
{
    static void Main() { /* Won’t run... the static constructor deadlocks */  }

    static MyClass()
    {
        Thread thread = new Thread(arg => { });
        thread.Start();
        thread.Join();
    }
}

L'auteur original est Igor Ostrovsky, voir son article ici .