Cos'è il pattern Singleton?

Il pattern Singleton garantisce che una classe abbia una sola istanza e fornisce un punto di accesso globale ad essa.

Viene utilizzato quando è richiesta un'unica istanza di una risorsa, ad esempio:

• Gestore di configurazione
• Pool di connessioni al database
• Logger

Implementazioni:

• Inizializzazione pigra (Lazy Initialization): L'istanza viene creata alla prima richiesta.

  public sealed class Singleton
  {
      private static Singleton? instance = null;
      private static readonly object lockObject = new object();
  
      private Singleton() { } // Costruttore privato
  
      public static Singleton Instance
      {
          get
          {
              if (instance == null)
              {
                  lock (lockObject)
                  {
                      if (instance == null)
                      {
                          instance = new Singleton();
                      }
                  }
              }
              return instance;
          }
      }
  }
  

• Inizializzazione statica (Eager Initialization): L'istanza viene creata al caricamento della classe.

  public sealed class Singleton
  {
      private static readonly Singleton instance = new Singleton();
  
      private Singleton() { } // Costruttore privato
  
      public static Singleton Instance
      {
          get
          {
              return instance;
          }
      }
  }
  

  Vantaggio: sicurezza thread di default, implementazione più semplice. Svantaggio: l'istanza viene creata anche se non viene utilizzata.

• Utilizzo di Lazy<T>:.NET Framework fornisce supporto integrato per l'inizializzazione pigra.

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

  Vantaggio: sicurezza thread e inizializzazione pigra out-of-the-box, codice più pulito.

Vantaggi del Singleton:

• Controllo sul numero di istanze.
• Punto di accesso globale.
• Inizializzazione pigra (in alcune implementazioni).

Svantaggi del Singleton:

• Può violare il principio di responsabilità singola.
• Rende difficile il testing unitario.
• Può portare a una forte dipendenza dal codice.