Pattern Singleton

Il pattern singleton è uno dei pattern creazionali più usati che ha lo scopo di garantire che di una determinata classe venga creata una e una sola istanza, e di fornire un punto di accesso globale a tale istanza.

Un esempio di pattern creazionale è il Pattern Builder.

E’ un pattern estremamente semplice nella sua struttura in quanto è formato da una sola classe, che è la classe in questione.

Singleton pattern - Wikipedia

Nel pattern singleton ho un unico costruttore privato, in modo da impedire l’istanziazione diretta della classe. La classe fornisce inoltre un metodo “getter” statico che restituisce una istanza della classe (sempre la stessa), creandola preventivamente o alla prima chiamata del metodo, e memorizzandone il riferimento in un attributo privato anch’esso statico.

Ogni linguaggio possiede dei trucchi per poter scrivere una classe singleton, il codice indicato qui è ottimizzato per .NET, utilizzando le feature che lo contraddistinguono.

private class MainApp
{
  /// <summary>
  /// Codice Main() della console application.
  /// </summary>
  private static void Main()
  {
    //Creo due LoadBalancer e verifico che siano la stessa istanza
    LoadBalancer b1 = LoadBalancer.GetLoadBalancer();
    LoadBalancer b2 = LoadBalancer.GetLoadBalancer();
    if (b1 == b2)
      Console.WriteLine("Same instance\n");
  }
}

/// <summary>
/// LoadBalancer è la classe singleton che voglio implementare
/// La classe è definita sealed per sottolineare il fatto che non può avere classi derivate
/// </summary>
private sealed class LoadBalancer
{
  // Gli attributi statici di una classe sono inizializzati quando la classe è caricata per la prima volta
  // Tramite l'attributo readonly impongo che, una volta che viene fatto il load della classe, il valore di _instance non
  // possa più essere cambiato (ricordo che readonly agisce al caricamento della classe, il const invece durante la compilazione)
  //Inoltre questa operazione è thread safe di default
  private static readonly LoadBalancer _instance = new LoadBalancer();

  // Attributo della classe: una lista di server
  private List<Server> _servers;

  //Il costruttore è privato e non può essere chiamato dall'esterno
  private LoadBalancer()
  {
    // Il costruttore istanzia una nuova lista di server
    _servers = new List<Server>
      {
       new Server{ Name = "ServerI", IP = "120.14.220.18" },
       new Server{ Name = "ServerII", IP = "120.14.220.19" }
      };
  }

  // Per avere l'istanza della classe utilizzo questo metodo, che non fa altro che ritornare la variabile _instance
  public static LoadBalancer GetLoadBalancer()
  {
    return _instance;
  }
}

Dove approfondire

Per approfondire consiglio assolutamente la lettura di Head First Design Pattern, un libro imprendiscindibile per chiunque voglia migliorarsi come programmatore.

Indice

Share
Ultimi articoli
Join

Newsletter

Nessuno spam, solo articoli interessanti ;)

Focus

Post correlati

semaphoreslim

SmaphoreSlim 101

SemaphoreSlim è una classe che permette la sincronizzazione di n thread che hanno una risorsa (scarsa) condivisa limitandone l’uso ad un numero massimo.

interlocked

Interlocked 101

La sincronizzazione dei thread è un elemento fondamentale nella programmazione asincrona, ne ho infatti parlato in vari post. La soluzione più versatile è sicuramente utilizzare

event

Come testare gli eventi

Testare che degli eventi siano stato effettivamente lanciati in C# non è immediato. Tipicamente è possibile testare che un evento venga lanciato aspettando un ManualResetEvent

Codice Pragmatico

Contatti

Per informazioni, dubbi o consulenze non esitate a contattarmi.

Lascia un messaggio

Ricevi le ultime news

Iscrivi alla newsletter

Solo articoli interessanti, promesso ;)