O que é o padrão de projeto Singleton?

O padrão Singleton garante que uma classe tenha apenas uma instância e fornece um ponto de acesso global a ela.

É usado quando é necessária uma única instância de um recurso, por exemplo:

• Gestor de configuração
• Pool de conexões à base de dados
• Registador (logger)

Implementações:

• Inicialização preguiçosa (Lazy Initialization): A instância é criada na primeira vez que é acessada.

  public sealed class Singleton
  {
      private static Singleton? instance = null;
      private static readonly object lockObject = new object();
  
      private Singleton() { } // Construtor privado
  
      public static Singleton Instance
      {
          get
          {
              // Verificação de null para evitar bloqueios na maioria dos casos
              if (instance == null)
              {
                  // Bloqueio para segurança de threads
                  lock (lockObject)
                  {
                      // Verificação dupla de null dentro do bloqueio
                      if (instance == null)
                      {
                          instance = new Singleton();
                      }
                  }
              }
              return instance;
          }
      }
  }
  

• Inicialização estática (Eager Initialization): A instância é criada ao carregar a classe.

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

  Vantagem: segurança de threads por padrão, implementação mais simples. Desvantagem: a instância é criada mesmo que não seja usada.

• Usando Lazy<T>:.NET Framework fornece suporte embutido para inicialização preguiçosa.

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

  Vantagem: segurança de threads e inicialização preguiçosa pronta para uso, código mais limpo.

Vantagens do Singleton:

• Controle sobre o número de instâncias.
• Ponto de acesso global.
• Inicialização preguiçosa (em algumas implementações).

Desvantagens do Singleton:

• Pode violar o princípio de responsabilidade única.
• Dificulta testes unitários.
• Pode levar a uma forte dependência do código.