.NET Design Patterns(5) - Singleton

Singleton Design Pattern

definition  UML diagram  participants

sample code in C#

definition Ensure a class has only one instance and provide a global point of access to it. Frequency of use:   medium high

return to top

UML class diagram

return to top

participants

    The classes and/or objects participating in this pattern are:

• Singleton   (LoadBalancer)
  • defines an Instance operation that lets clients access its unique instance. Instance is a class operation.
  • responsible for creating and maintaining its own unique instance.

return to top

sample code in C#

This structural code demonstrates the Singleton pattern which assures only a single instance (the singleton) of the class can be created.

Hide code 

// Singleton pattern -- Structural example

using System; namespace DoFactory.GangOfFour.Singleton.Structural {   /// <summary>   /// MainApp startup class for Structural   /// Singleton Design Pattern.   /// </summary>   class MainApp   {     /// <summary>     /// Entry point into console application.     /// </summary>     static void Main()     {       // Constructor is protected -- cannot use new       Singleton s1 = Singleton.Instance();       Singleton s2 = Singleton.Instance();       // Test for same instance       if (s1 == s2)       {         Console.WriteLine("Objects are the same instance");       }       // Wait for user       Console.ReadKey();     }   }   /// <summary>   /// The 'Singleton' class   /// </summary>   class Singleton   {     private static Singleton _instance;     // Constructor is 'protected'     protected Singleton()     {     }     public static Singleton Instance()     {       // Uses lazy initialization.       // Note: this is not thread safe.       if (_instance == null)       {         _instance = new Singleton();       }       return _instance;     }   } }

Output Objects are the same instance

---

This real-world code demonstrates the Singleton pattern as a LoadBalancing object. Only a single instance (the singleton) of the class can be created because servers may dynamically come on- or off-line and every request must go throught the one object that has knowledge about the state of the (web) farm.

Hide code 

// Singleton pattern -- Real World example

using System; using System.Collections.Generic; using System.Threading; namespace DoFactory.GangOfFour.Singleton.RealWorld {   /// <summary>   /// MainApp startup class for Real-World   /// Singleton Design Pattern.   /// </summary>   class MainApp   {     /// <summary>     /// Entry point into console application.     /// </summary>     static void Main()     {       LoadBalancer b1 = LoadBalancer.GetLoadBalancer();       LoadBalancer b2 = LoadBalancer.GetLoadBalancer();       LoadBalancer b3 = LoadBalancer.GetLoadBalancer();       LoadBalancer b4 = LoadBalancer.GetLoadBalancer();       // Same instance?       if (b1 == b2 && b2 == b3 && b3 == b4)       {         Console.WriteLine("Same instance\n");       }       // Load balance 15 server requests       LoadBalancer balancer = LoadBalancer.GetLoadBalancer();       for (int i = 0; i < 15; i++)       {         string server = balancer.Server;         Console.WriteLine("Dispatch Request to: " + server);       }       // Wait for user       Console.ReadKey();     }   }   /// <summary>   /// The 'Singleton' class   /// </summary>   class LoadBalancer   {     private static LoadBalancer _instance;     private List<string> _servers = new List<string>();     private Random _random = new Random();     // Lock synchronization object     private static object syncLock = new object();     // Constructor (protected)     protected LoadBalancer()     {       // List of available servers       _servers.Add("ServerI");       _servers.Add("ServerII");       _servers.Add("ServerIII");       _servers.Add("ServerIV");       _servers.Add("ServerV");     }     public static LoadBalancer GetLoadBalancer()     {       // Support multithreaded applications through       // 'Double checked locking' pattern which (once       // the instance exists) avoids locking each       // time the method is invoked       if (_instance == null)       {         lock (syncLock)         {           if (_instance == null)           {             _instance = new LoadBalancer();           }         }       }       return _instance;     }     // Simple, but effective random load balancer     public string Server     {       get       {         int r = _random.Next(_servers.Count);         return _servers[r].ToString();       }     }   } }

Output Same instance ServerIII ServerII ServerI ServerII ServerI ServerIII ServerI ServerIII ServerIV ServerII ServerII ServerIII ServerIV ServerII ServerIV

---

This .NET optimized code demonstrates the same code as above but uses more modern, built-in .NET features.

Here an elegant .NET specific solution is offered. The Singleton pattern simply uses a private constructor and a static readonly instance variable that is lazily initialized. Thread safety is guaranteed by the compiler.