Singleton Design Pattern In C# - Part One

Introduction

I always wanted to write on Singleton design pattern in C#. Though there already are many posts available on Singleton design pattern, I’ll try to cover this topic in the most simplistic and easy to understand way. This article will also talk about Static classes and the differences between singleton design pattern and static classes. Following is the link to next part of this article.

The Singleton design pattern is a creational type of design pattern. We have distinct categories of design patterns, out of which creational is the one which deals with instance creation and initialization. This pattern helps a programmer to write a program with more flexibility of creating objects subjective to various cases, the example of which are Singleton, Factory, Abstract factory etc. Covering design pattern types are out of the scope of this article, so let’s focus on Singleton design pattern.

Let’s highlight the advantages of singleton class or pattern first before we jump into actual implementation. The first advantage that we can make out from the request logging example is that singleton takes care of concurrent access to a shared resource, which means if we are sharing a resource with multiple clients simultaneously, then it should be well taken care of. In our case, our log file is the shared resource and singleton makes sure, every client accesses it with no deadlock or conflict. The second advantage is that it only allows one instance of a class responsible for sharing the resource, which is shared across all the clients or applications in a controlled state.

Guidelines

Every pattern is based on certain guidelines which should be followed while implementing the pattern. These guidelines help us build a robust pattern and each guideline has its significance in the pattern that we’ll discuss which creating a singleton class. Stick to the following guidelines whenever you need to implement Singleton design pattern in C#.

1. Check that the implementation when done, creates only one instance of the class, and there should be only one point from where an instance is to be created.
   
2. The singleton’s class constructors should be private so that no class can directly instantiate the singleton class.
3. There should be a static property/method that takes care of singleton class instantiation and that property should be shared across applications and is solely responsible for returning a singleton instance.
4. The C# singleton class should be sealed so that it could not be inherited by any other class, this is useful when we deal with nested class structure. We’ll discuss this scenario as well later when we implement the singleton.

That's a lot of theory covered, now let’s practically implement the singleton pattern. We’ll cover this step by step.

1. Open the visual studio and create a console application named Singleton (you can choose whatever name you like).
   
   
   

2. Add a class named Singleton and add the following code to log a request message to it. For now, we are not actually logging into the file, but displaying the message at the console.
   

   Singleton.cs

   1. using static System.Console;
   2. namespace Singleton
   3. {
   4. class Singleton
   5. {
   6. public void LogMessage(string message)
   7. {
   8. WriteLine("Message " + message);
   9. }
   10. }
   11. }

   Let’s also add a public constructor in the class with a variable to hold the counter of the number of objects created of this singleton class. We increment the instanceCounter variable whenever an instance of the Singleton class is created, so the best place to increment and print it is a constructor.

   1. using static System.Console;
   3. namespace Singleton
   4. {
   5. class Singleton
   6. {
   7. static int instanceCounter = 0;
   8. public Singleton()
   9. {
   10. instanceCounter++;
   11. WriteLine("Instances created " + instanceCounter);
   12. }
   13. public void LogMessage(string message)
   14. {
   15. WriteLine("Message " + message);
   16. }
   17. }
   18. }

   Note that we are not using any singleton guideline here and first we’ll try to invoke this method from our main method i.e. in Program.cs class. So, go to Program.cs class and write following code for calling that LogMessage method of singleton class by creating an object of that class. We assume that two clients or two classes(Manager class and Employee class) are creating the objects of Singleton class to log their request message. Let’s name those instances as “fromManager” and “fromEmployee”.

   Program.cs

   1. using static System.Console;
   2. namespace Singleton
   3. {
   4. class Program
   5. {
   6. static void Main(string[] args)
   7. {
   8. Singleton fromManager = new Singleton();
   9. fromManager.LogMessage("Request Message from Manager");
   11. Singleton fromEmployee = new Singleton();
   12. fromEmployee.LogMessage("Request Message from Employee");
   14. ReadLine();
   15. }
   16. }
   17. }

   When we run the application, we see the output as following.
   
   
   

   We see here that we created two instances of our class named Singleton and got the method invoked by both the objects separately. When the first time fromManager instance was created, the counter was incremented by 1 and the second time at the time of fromEmployee instance creation, it is incremented again by 1 so 2 in total. Note that we have not yet implemented singleton guidelines and our aim is to restrict this multiple object creation.

3. If we again refer to the guidelines, it says that all the constructors of the singleton class should be private and there should be a property or method which takes responsibility of providing the instance of that singleton class. So, let’s try that. Convert the public constructor in the Singleton class a private as following.
   
   1. private Singleton()
   2. {
   3. instanceCounter++;
   4. WriteLine("Instances created " + instanceCounter );
   5. }

But when you go back to Program.cs class where we were making the instance we see the error as follows which is a compile-time error and appears as well when we compile the program at this point of time.

It says that the constructor could not be accessed and that’s because we have made it private. So, let’s delegate this responsibility of serving objects to a static property in the Singleton class. Add a new property to the Singleton class

Following is the code,