Qu'est-ce que le patron de conception Singleton?

Le modèle Singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à celle-ci.

Il est utilisé lorsque une seule instance d'une ressource est requise, par exemple :

• Gestionnaire de configuration
• Pool de connexions à la base de données
• Journaliseur (logger)

Implémentations :

• Initialisation paresseuse (Lazy Initialization) : L'instance est créée lors de la première utilisation.

  public sealed class Singleton
  {
      private static Singleton? instance = null;
      private static readonly object lockObject = new object();
  
      private Singleton() { } // Constructeur privé
  
      public static Singleton Instance
      {
          get
          {
              // Vérification de null pour éviter le verrouillage dans la plupart des cas
              if (instance == null)
              {
                  // Verrouillage pour la sécurité des threads
                  lock (lockObject)
                  {
                      // Vérification double dans le verrouillage
                      if (instance == null)
                      {
                          instance = new Singleton();
                      }
                  }
              }
              return instance;
          }
      }
  }
  

• Initialisation statique (Eager Initialization) : L'instance est créée lors du chargement de la classe.

  public sealed class Singleton
  {
      private static readonly Singleton instance = new Singleton();
  
      private Singleton() { } // Constructeur privé
  
      public static Singleton Instance
      {
          get
          {
              return instance;
          }
      }
  }
  

  Avantage : sécurité intégrée pour les threads, implémentation plus simple. Inconvénient : l'instance est créée même si elle n'est pas utilisée.

• Utilisation de Lazy<T> :.NET Framework offre un support intégré pour l'initialisation paresseuse.

  public sealed class Singleton
  {
      private static readonly Lazy<Singleton> lazyInstance = new Lazy<Singleton>(() => new Singleton());
  
      private Singleton() { } // Constructeur privé
  
      public static Singleton Instance
      {
          get
          {
              return lazyInstance.Value;
          }
      }
  }
  

  Avantage : sécurité pour les threads et initialisation paresseuse prête à l'emploi, code plus propre.

Avantages du Singleton :

• Contrôle du nombre d'instances.
• Point d'accès global.
• Initialisation paresseuse (dans certaines implémentations).

Inconvénients du Singleton :

• Peut violer le principe de responsabilité unique.
• Difficile à tester unitaire.
• Peut conduire à une forte dépendance du code.