Singleton

Bem-vindos ao fascinante mundo do padrão Singleton! Nessa rápida incursão, mergulharemos nas profundezas de uma das estruturas mais singulares (sem trocadilhos) da programação orientada a objetos. Do seu conceito às implementações com e sem thread-safe em C#, passando pelas vantagens e desafios, este post será seu guia definitivo. Preparados para transformar o complexo em simples? Então, vamos lá!

O padrão Singleton garante que uma classe tenha somente uma instância e fornece um ponto global de acesso a ele. Um singleton é uma classe que permite apenas uma única instância de si mesmo para ser criado e geralmente dá acesso simples a essa instância.

Neste padrão, a classe possui apenas um Construtor, que é específico e sem parâmetros.
A classe está selada e possui uma variável estática que contém uma referência a instância criada única.
No singleton, existe um meio estático público de obter a referência à instância criada única, criando uma, se necessário.

Existe mais sobre Singleton do que vamos falar aqui. Este artigo cobre o básico.

Vantagens:

• Padrão singleton pode ser uma interface implementada;
• Pode herdar de outras classes;
  Pode implementar lazy loading;
• Tem inicialização estática;
• Ele pode ser estendido utilizando o factory pattern;
• Ajuda a esconder as dependências;
• Ele fornece um ponto único de acesso a uma instância específica, por isso é fácil de manter.

Desvantagens:

1. Testes unitários ficam mais difíceis, pois é introduzido um estado global em um aplicativo;
2. Este padrão reduz o potencial de paralelismo dentro de um programa, pois, para acessar o singleton em um sistema de várias threads, um objeto deve ser serializado (utilizando um lock).

Implementando classe Singleton.

• Singleton Simples (sem thread safe)

O código a seguir não é thread-safe. Duas threads diferentes poderiam ambos avaliaram o teste (se instância == null) e resultaria em true para ambos, então ambos criariam instâncias da classe, o que viola o padrão singleton.

//Classe Singleton sem Thread-Safe
public sealed class Singleton
{
    //Construtor Privado
    private Singleton() { }
 
    //Propriedade que será acessada. Inicializada como null.
    private static Singleton instance = null;
    
    //Forma de acesso público...
    public static Singleton Instance
    {
        //Getter publico.
        get
        {
            //Se a variável "instance" for nula, instancia ela.
            if (instance == null)
                instance = new Singleton();

            //Retorna a variável "instance"
            return instance;
        }
    }
}

• Singleton Simples (com thread safe)

Essa implementação é thread-safe. No código a seguir, a thread está em um objeto compartilhado e verifica se uma instância foi criada ou não.
Como apenas uma thread pode acessar este objeto por vez, assim que a primeira terminar de usa-lo, a instancia terá sido criada e a verificação se ela está nula ou não retornará falso. Isso resolve o problema que vimos no código anterior.
O maior problema com isto é o desempenho: como apenas uma thread poderá acessar este objeto por vez, a performance fica um pouco degradada.

public sealed class Singleton
{
    Singleton() { }
 
    private static readonly object verificador = new object();
 
    private static Singleton instance = null;

    public static Singleton Instance
    {
        get
        {
            lock (verificador)
            {
                if (instance == null)                
                    instance = new Singleton();
                
                return instance;
            }
        }
    }
}

Referência: http://csharpindepth.com/Articles/General/Singleton.aspx