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.

 1//Classe Singleton sem Thread-Safe
 2public sealed class Singleton
 3{
 4    //Construtor Privado
 5    private Singleton() { }
 6 
 7    //Propriedade que será acessada. Inicializada como null.
 8    private static Singleton instance = null;
 9    
10    //Forma de acesso público...
11    public static Singleton Instance
12    {
13        //Getter publico.
14        get
15        {
16            //Se a variável "instance" for nula, instancia ela.
17            if (instance == null)
18                instance = new Singleton();
19
20            //Retorna a variável "instance"
21            return instance;
22        }
23    }
24}

• 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.

 1public sealed class Singleton
 2{
 3    Singleton() { }
 4 
 5    private static readonly object verificador = new object();
 6 
 7    private static Singleton instance = null;
 8
 9    public static Singleton Instance
10    {
11        get
12        {
13            lock (verificador)
14            {
15                if (instance == null)                
16                    instance = new Singleton();
17                
18                return instance;
19            }
20        }
21    }
22}

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