O que é um singleton em c #?

Pergunta bastante direta.

O que é um Singleton e quando devo usá-lo?

Um singleton é uma class que permite que apenas uma instância de si seja criada – e fornece access fácil e simples à dita instância. A premissa do singleton é um padrão no desenvolvimento de software.

Há uma implementação em C # “Implementando o padrão Singleton em C #” cobrindo a maior parte do que você precisa saber – incluindo alguns bons conselhos sobre segurança de thread .

Para ser honesto, é muito raro que você precise implementar um singleton – na minha opinião, deve ser uma daquelas coisas que você deve estar ciente, mesmo que não seja usado com muita frequência.

Você pediu C #. Exemplo trivial:

 public class Singleton { private Singleton() { // Prevent outside instantiation } private static readonly Singleton _singleton = new Singleton(); public static Singleton GetSingleton() { return _singleton; } } 

O que é: uma class para a qual há apenas uma instância persistente durante a vida útil de um aplicativo. Veja Padrão Singleton .

Quando você deve usá-lo: o mínimo possível. Apenas quando você está absolutamente certo de que precisa. Estou relutante em dizer “nunca”, mas geralmente há uma alternativa melhor, como Injeção de Dependência ou simplesmente uma class estática.

Outra maneira de implementar singleton em c #, eu pessoalmente prefiro desta forma porque você pode acessar a instância da class singeton como uma propriedade em vez de um método.

 public class Singleton { private static Singleton instance; private Singleton() { } public static Singleton Instance { get { if (instance == null) instance = new Singleton(); return instance; } } //instance methods } 

mas bem, até onde eu sei, ambas as formas são consideradas “certas”, então é apenas uma coisa de sabor pessoal.

Um Singleton (e isso não está ligado a C #, é um padrão de design OO) é quando você deseja permitir que apenas UMA instância de uma class seja criada em todo o seu aplicativo. As utilizações normalmente incluem resources globais, embora eu possa dizer por experiência pessoal que, com muita frequência, são fonte de grande sofrimento.

Enquanto o lá só pode ser um exemplo de um singleton, não é o mesmo que uma class estática. Uma class estática só pode conter methods estáticos e nunca pode ser instanciada, enquanto a instância de um singleton pode ser usada da mesma maneira que qualquer outro object.

 using System; using System.Collections.Generic; class MainApp { static void Main() { LoadBalancer oldbalancer = null; for (int i = 0; i < 15; i++) { LoadBalancer balancerNew = LoadBalancer.GetLoadBalancer(); if (oldbalancer == balancerNew && oldbalancer != null) { Console.WriteLine("{0} SameInstance {1}", oldbalancer.Server, balancerNew.Server); } oldbalancer = balancerNew; } Console.ReadKey(); } } class LoadBalancer { private static LoadBalancer _instance; private List _servers = new List(); private Random _random = new Random(); private static object syncLock = new object(); private LoadBalancer() { _servers.Add("ServerI"); _servers.Add("ServerII"); _servers.Add("ServerIII"); _servers.Add("ServerIV"); _servers.Add("ServerV"); } public static LoadBalancer GetLoadBalancer() { if (_instance == null) { lock (syncLock) { if (_instance == null) { _instance = new LoadBalancer(); } } } return _instance; } public string Server { get { int r = _random.Next(_servers.Count); return _servers[r].ToString(); } } } 

Eu tomei código de dofactory.com , nada tão extravagante, mas acho isso muito bom do que exemplos com Foo e Bar adicionalmente livro de Judith Bishop em C # 3.0 Design Patterns tem exemplo sobre o aplicativo ativo no mac dock.

Se você olhar o código, na verdade, estamos construindo novos objects no loop for , de modo que crie um novo object, mas reutilize a instância, como resultado do qual o oldbalancer e o newbalancer têm a mesma instância, How? é devido à palavra-chave estática usada na function GetLoadBalancer () , apesar de ter um valor de servidor diferente que é lista aleatória, static em GetLoadBalancer () pertence ao próprio tipo em vez de a um object específico.

Além disso, há dupla verificação de bloqueio aqui

 if (_instance == null) { lock (syncLock) { if (_instance == null) 

desde a partir do MSDN

A palavra-chave de bloqueio garante que um segmento não insira uma seção crítica de código enquanto outro segmento estiver na seção crítica. Se outro thread tentar inserir um código bloqueado, ele aguardará, bloqueará até que o object seja liberado.

então, todo bloqueio de exclusão mútua é emitido, mesmo que não seja necessário, o que é desnecessário, portanto, temos a verificação nula.

Espero que ajude a limpar mais.

E, por favor, comente se meu entendimento está direcionando caminhos errados.

É um padrão de design e não é específico para c #. Mais sobre isso por toda a internet e, por isso, como neste artigo da wikipedia .

Na engenharia de software, o padrão singleton é um padrão de design usado para restringir a instanciação de uma class a um object. Isso é útil quando exatamente um object é necessário para coordenar ações no sistema. Às vezes, o conceito é generalizado para sistemas que operam com mais eficiência quando existe apenas um object ou que restringem a instanciação a um determinado número de objects (digamos, cinco). Alguns o consideram um antipadrão, julgando que é usado em excesso, introduz limitações desnecessárias em situações em que uma única instância de uma class não é realmente necessária e introduz o estado global em um aplicativo.

Você deve usá-lo se quiser uma class que só pode ser instanciada uma vez.

Eu uso para dados de pesquisa. Carrega uma vez do database.

 public sealed class APILookup { private static readonly APILookup _instance = new APILookup(); private Dictionary _lookup; private APILookup() { try { _lookup = Utility.GetLookup(); } catch { } } static APILookup() { } public static APILookup Instance { get { return _instance; } } public Dictionary GetLookup() { return _lookup; } } 

O que é um singleton:
É uma class que permite que apenas uma instância de si seja criada e, geralmente, fornece access simples a essa instância.

Quando você deve usar:
Depende da situação.

Nota: por favor, não use em conexão db, para uma resposta detalhada por favor consulte a resposta de @Chad Grant

Aqui está um exemplo simples de um Singleton :

 public sealed class Singleton { private static readonly Singleton instance = new Singleton(); // Explicit static constructor to tell C# compiler // not to mark type as beforefieldinit static Singleton() { } private Singleton() { } public static Singleton Instance { get { return instance; } } } 

Você também pode usar Lazy para criar seu Singleton .

Veja aqui um exemplo mais detalhado usando Lazy

Aqui está o singleton: http://en.wikipedia.org/wiki/Singleton_pattern

Eu não sei c #, mas é realmente a mesma coisa em todos os idiomas, apenas a implementação é diferente.

Você deve geralmente evitar o singleton quando é possível, mas em algumas situações é muito conveniente.

Desculpe pelo meu Inglês 😉

A class Singleton é usada para criar uma única instância para todo o domínio do aplicativo.

 public class Singleton { private static Singleton singletonInstance = CreateSingleton(); private Singleton() { } private static Singleton CreateSingleton() { if (singletonInstance == null) { singletonInstance = new Singleton(); } return singletonInstance; } public static Singleton Instance { get { return singletonInstance; } } } 

Neste artigo, é descrito como podemos criar uma class singleton segura de thread usando a variável readonly e seu uso prático em aplicativos.

Singleton é um tipo de object remoto, usado para atender a vários clientes. Esses objects mantêm estados em vez de tipos de object de chamada singel