¿Qué es el patrón de diseño Singleton?

El patrón Singleton garantiza que una clase tenga solo una instancia y proporciona un punto de acceso global a ella.

Se usa cuando se requiere una única instancia de un recurso, por ejemplo:

• Gestor de configuración
• Pool de conexiones a la base de datos
• Registrador (logger)

Implementaciones:

• Inicialización perezosa (Lazy Initialization): La instancia se crea en la primera llamada a ella.

  public sealed class Singleton
  {
      private static Singleton? instance = null;
      private static readonly object lockObject = new object();
  
      private Singleton() { } // Constructor privado
  
      public static Singleton Instance
      {
          get
          {
              // La comprobación de null evita bloqueos en la mayoría de los casos
              if (instance == null)
              {
                  // Bloqueo para seguridad en hilos
                  lock (lockObject)
                  {
                      // Comprobación doble en null dentro del bloqueo
                      if (instance == null)
                      {
                          instance = new Singleton();
                      }
                  }
              }
              return instance;
          }
      }
  }
  

• Inicialización estática (Eager Initialization): La instancia se crea al cargar la clase.

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

  Ventaja: seguridad en hilos por defecto, implementación más sencilla. Desventaja: la instancia se crea incluso si no se usa.

• Usando Lazy<T>:.NET Framework ofrece soporte incorporado para inicialización perezosa.

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

  Ventaja: seguridad en hilos y inicialización perezosa lista para usar, código más limpio.

Ventajas del Singleton:

• Control sobre el número de instancias.
• Punto de acceso global.
• Inicialización perezosa (en algunas implementaciones).

Desventajas del Singleton:

• Puede violar el principio de responsabilidad única.
• Dificulta las pruebas unitarias.
• Puede conducir a una fuerte dependencia del código.