Design Patterns - Singleton

Singleton is one of the design patterns from the Gang of Four (GoF) design patterns. It is a creational design pattern.

 

Singleton design pattern restricts the class to create multiple instances. This design pattern would ensure that the class should have only one instance alive at any given time.

 

To make a class a singleton, we can use the following steps.

1. Create a class
2. Create a private static member of type class
3. Create a private constructor

In the above 3 steps, the 3^rd step is an important one; i.e., if we create a class with a private constructor, then the outer class or the subclasses are not able to create objects of that class. Refer to the screenshot below.

   public class Singleton
   {

       private Singleton()
       {
           // private constructor
       }
   }

   class CallSingleton
   {
       public static void Main(string[] args)
       {
           Singleton instance = new Singleton();

       }
   }

The above highlighted statement will generate the 'inaccessible' error as below.

 

 

A sample implementation of the singleton design pattern is given below.

 

Singleton Class

    public class Singleton
    {
        private static Singleton obj_singletonInstance=null; // A static class instance
        private Singleton()
        {
            // private constructor
        }
        public static Singleton createInstace()
        {
            // static method : check whether the instace is null or not.
            // If null , it will create an instace and assign to obj_singletonInstance
            // and will return the value of the obj_singletonInstance

            if (obj_singletonInstance==null)
            {
                Console.WriteLine("Creating instance!");
                obj_singletonInstance = new Singleton();
            }
            return obj_singletonInstance;
        }
        public void getMessage()
        {
            Console.WriteLine("This method is called using singleton instance!");
        }

    }

Main class

class CallSingleton
   {
       public static void Main(string[] args)
       {
           Console.WriteLine("Design Patterns : Singleton \n ------------------");

           Singleton instance; // object declared
           instance = Singleton.createInstace(); // initialized
           instance.getMessage();

           Console.ReadKey();

       }
   }

Output

 

Where can we use the Singleton design pattern?

 

The use of the Singleton design pattern is based on the requirement. A few of the applicable areas of singleton design pattern are mentioned below.

 

Shared resource access

 

We can use the singleton design pattern to prevent concurrent access to a class. This design pattern can be used to make external resources usage limitation as required. For example, to prevent the multiple concurrent access to the shared printer in the network.

 

Cache

 

Another area where we can use a singleton design pattern is Cache. We can create Cache as a singleton object, so it can have a global point of reference and all future references by the client will be using it from the in-memory object.

 

Configuration Files

 

We can use this design pattern for accessing the configuration files. By using the singleton design pattern, we can create a single instance for the configuration file which can be accessed by multiple calls concurrently using the static config data loaded in the in-memory.

 

Logger

 

Singleton design pattern can be used for log file generation. Consider, if our application has a log generation utility and it will generate a log file based on the message, what will happen if the utility will be accessed by multiple clients concurrently?

 

They will create multiple instances and might make issues during concurrent access. We can create the logging utility class as a singleton class and make sure that no two clients could access it simultaneously.

 

Database Connection

 

We can use the singleton design pattern for the creation of the database connection instances. It will improve performance.

 

These are the only few common areas where we can use a singleton design pattern. We can find many more project-specific areas to use the singleton design pattern.