Singleton Design Pattern

 What is Singleton design pattern?

    Of the Gang of Four design patterns, Singleton is the Creational design pattern used while creation of the object of the class. The creational design pattern is a technique to ensure that there is strictly only one instance of a particular class in your program.

Why Singleton?

    Suppose that your classes are using external resources like a database server, or a web Api etc, it would be a real problem if multiple objects try to use those resources at the same time. In such cases, singleton design pattern can help in overcoming the drawback in the above scenarios.

Real world example with code

    Suppose your program need to log the changes made in some data into a log file. Generally, in absence of the pattern, multiple objects may try to access the same log file which could create conflict. With a singleton log class object, you don't need to worry about several different objects trying to access the same class.

    First, Lets consider the below code where Singleton pattern is not implemented.

	namespace SingletonExample
	{
	class Program
	{
	static void Main(string[] args)
	{
	string Name = "Disha";
	string Address = "001 My address";
	Customer customer = new Customer(Name);
	customer.UpdateAddress(Name, Address);
	Console.ReadLine();
	}
	}
	class Customer
	{
	private readonly Logger _logger;
	public string Name { get; set; }
	public Customer(string name)
	{
	_logger = Logger.GetLogger();
	Name = name;
	}
	public void UpdateAddress(string Name, string Address)
	{
	//Normal updation code
	//Below is the logger updation code
	_logger.SaveLog(Name);
	}
	}
	class Logger
	{
	private Logger()
	{
	}
	public static Logger GetLogger()
	{
	return new Logger();
	}
	public void SaveLog(string Name)
	{
	Console.Write("Log saved for updation of " + Name);
	}
	}
	}

view raw singleton.cs hosted with ❤ by GitHub

In the above code, n number of Logger class objects could be created. Hence when multiple simultaneous requests come for accessing the SaveLog method, problems may occur if the log file for saving is accessed at the same time by multiple request.

Now lets use Singleton Design Pattern to create a Logger class that can be instantiated only once. Each update request from the Customer class will point to the single Logger object.

Please refer the below code where Singleton Logger class is used. 

	namespace SingletonExample
	{
	class Program
	{
	static void Main(string[] args)
	{
	string Name = "Disha";
	string Address = "001 My address";
	Customer customer = new Customer(Name);
	customer.UpdateAddress(Name, Address);
	Console.ReadLine();
	}
	}
	class Customer
	{
	private readonly Logger _logger;
	public string Name { get; set; }
	public Customer(string name)
	{
	_logger = Logger.GetLogger();
	Name = name;
	}
	public void UpdateAddress(string Name, string Address)
	{
	//Normal updation code
	//Below is the logger updation code
	_logger.SaveLog(Name);
	}
	}
	public sealed class Logger
	{
	private static Logger _logger;
	private static readonly object _lockObject = new object();
	private Logger()
	{
	}
	public static Logger GetLogger()
	{
	if (_logger == null)
	{
	lock (_lockObject)
	{
	if (_logger == null)
	{
	_logger = new Logger();
	}
	}
	}
	return _logger;
	}
	public void SaveLog(string Name)
	{
	Console.Write("Log saved for updation of " + Name);
	}
	}
	}

view raw loggersingleton.cs hosted with ❤ by GitHub

Lets review the Logger class in the above code.

Firstly, we made the Logger class as 'Sealed'. This means this class cannot be inherited any more.

Secondly, we created static Logger variable _logger. Since this variable is static, only one instance of the variable exists for the Logger class. 

The GetLogger() method first checks if the _logger  variable is null. If it is null, that means no instance of the Logger class has been yet created. Hence it will create new instance, assign it to the _logger variable  and return the _logger variable .

Now, another check is 'lock' check.

What is a lock?

    In a multi-threading environment, multiple threads can try to access the same object at a same time. The lock statement acquires the mutual-exclusion lock for a given object, executes a statement block, and then releases the lock. While a lock is held, the thread that holds the lock can again acquire and release the lock. Any other thread is blocked from acquiring the lock and waits until the lock is released.

In the above code, _lockObject  is simply an object and we are locking the object by using the lock statement. Anything that is executed inside the lock will happen only for one calling object at a time. Hence we ensure that only single instance of Logger class is present throughout the program at a time.

Even if you have multiple objects, on multiple threads, calling the GetLogger method, one of them will be “first”. This first object will see that the _logger is null, then attempt to get a lock on the _lockObject variable. Only one object at a time can have a lock on an object. Any other objects that try to lock the _lockObject variable will be queued up, until the first object releases its lock.

Conclusion

Here, we implemented the Singleton Design pattern to log updates in a log file. This pattern can be utilized in no of different scenarios like single Database connectivity object etc. I will try to implement the singleton pattern for database connection in the future blog.