Wat is het Singleton-ontwerppatroon?

Het Singleton-patroon zorgt ervoor dat een klasse slechts één instantie heeft en biedt een globaal toegangspunt tot die instantie.

Het wordt gebruikt wanneer slechts één exemplaar van een resource nodig is, bijvoorbeeld:

• Configuratiebeheerder
• Databaseverbindingenpool
• Logger

Implementaties:

• Lui initialisatie (Lazy Initialization): Het exemplaar wordt gemaakt bij de eerste aanroep.

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

• Statische initialisatie (Eager Initialization): Het exemplaar wordt gemaakt bij het laden van de klasse.

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

  Voordeel: standaard threadveiligheid, eenvoudigere implementatie. Nadeel: het exemplaar wordt gemaakt, zelfs als het niet wordt gebruikt.

• Met Lazy<T>:.NET Framework biedt ingebouwde ondersteuning voor lazy initialisatie.

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

  Voordeel: threadveiligheid en lazy initialisatie out-of-the-box, schonere code.

Voordelen van Singleton:

• Controle over het aantal instanties.
• Globale toegangspunt.
• Lazy initialisatie (in sommige implementaties).

Nadelen van Singleton:

• Kan de single responsibility-principe schenden.
• Moeilijk te unit-testen.
• Kan leiden tot sterke afhankelijkheid van de code.