O que é um singleton em C#?

Pediste 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 classe para a qual há apenas uma instância persistente ao longo da vida de uma aplicação. Ver Padrão Singleton .

Quando deve usá-lo: o mínimo possível. Só quando tens a certeza absoluta de que precisas dele. Estou relutante em dizer" nunca", mas geralmente há uma alternativa melhor, como a injeção de dependência ou simplesmente uma classe estática.

public class Singleton
    {
        private static Singleton instance;

        private Singleton() { }

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

        //instance methods
    }

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<string> _servers = new List<string>();
    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 tirei o código de dofactory.com além disso, o livro de Judith Bishop sobre padrões de Design C# 3.0 tem exemplo sobre a aplicação activa no Mac dock.

Se você olhar para o código nós estamos realmente construindo novos objetos empara loop, de modo que cria um novo objeto, mas reutiliza instância como resultado de que o oldbalancer e newbalancer tem a mesma instância, como? devido a static palavra-chave usada na função GetLoadBalancer(), apesar de ter servidor diferente do valor que é lista aleatória, estática, GetLoadBalancer() pertence ao próprio tipo, em vez de um objeto específico.

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

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

Desde MSDN

A palavra-chave de bloqueio garante que um tópico não entra numa secção crítica de código enquanto outro tópico está no crítico seccao. Se outro tópico tentar introduzir um código bloqueado, ele vai esperar, bloquear, até que o objeto seja liberado.

Em Engenharia de software, os singleton padrão é um padrão de design que é usado para restringir a instanciação de um Classe A um objecto. Isto é útil. quando exatamente um objeto é necessário coordenar ações em todo o sistema. O conceito é por vezes generalizado para sistemas que operam mais eficientemente quando apenas um objecto existe, ou que restringem o instanciação a um certo número de objetos (digamos, cinco). Alguns consideram-no um anti-padrão, julgando que é excesso de uso, introduz desnecessário limitações em situações em que o linguado instância de uma classe não é realmente necessário, e introduz o estado global para uma aplicação.

Deve usá-lo se quiser uma aula que só possa ser instanciada uma vez.

public sealed class APILookup
    {
        private static readonly APILookup _instance = new APILookup();
        private Dictionary<string, int> _lookup;

        private APILookup()
        {
            try
            {
                _lookup = Utility.GetLookup();
            }
            catch { }
        }

        static APILookup()
        {            
        }

        public static APILookup Instance
        {
            get
            {
                return _instance;
            }
        }
        public Dictionary<string, int> GetLookup()
        {
            return _lookup;
        }

    }

O que é um singleton :
É uma classe que só permite que uma instância de si mesma seja criada, e geralmente dá acesso simples a essa instância.

Quando Deve utilizar :
Depende da situação.

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

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<T> para criar o seu Singleton.

Veja aqui para um exemplo mais detalhado usando Lazy<T>

Eu não sei C#, mas na verdade é a mesma coisa em todas as línguas, só que a implementação difere.

Desculpa pelo meu Inglês;)

A classe Singleton é usada para criar uma única instância para todo o domínio de Aplicação.

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; }            
    }
}

Em este artigo é descrito Como podemos criar thread safe singleton class usando readonly variable e seu uso prático em aplicações.