C#: Singleton

Singleton

Singleton is a creational design pattern, which ensures that only one object of its kind exists and provides single point of access to it for any other code.

Singleton has almost the same pros and cons as global variables. Although they are super-handy, they break modularity of your code.

You can just use a class, which depends on Singleton, in some other context. You'll have to carry the Singleton class as well. Most of the time, this limitation comes up during the creation of unit tests.

More about Singleton

Application of the pattern in C#

Complexity:

Popularity:

Usage examples: A lot of developers consider the Singleton pattern an antipattern. That's why its usage is on the decline in C# code.

Identification: Singleton can be recognized by a static creational method, which returns same cached object.

Example: Structure of the Pattern

This example illustrates the structure of the Singleton design pattern. It focuses on answering these questions:

  • What classes does it consists of?
  • What roles do these classes play?
  • In what way the elements of the pattern are related?

Program.cs: Structural Example

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Singleton
{
    class Program
    {
        static void Main(string[] args)
        {
            Client client = new Client();
            client.ClientCode();
        }
    }

    class Client
    {
        public void ClientCode()
        {
            Singleton s1 = Singleton.getInstance();
            Singleton s2 = Singleton.getInstance();

            if(s1 == s2)
            {
                Console.WriteLine("Singleton works, both variables contain the same instance.");
            }
            else
            {
                Console.WriteLine("Singleton failed, variables contain different instances.");
            }
        }
    }

    class Singleton
    {
        private static Singleton instance;

        private static object obj = new object();

        private Singleton()
        { }

        public static Singleton getInstance()
        {
            lock(obj)
            {
                if (instance == null)
                    instance = new Singleton();
            }

            return instance;
        }
    }
}

Output.txt: Output

Singleton works, both variables contain the same instance.