C# Tutorial - Singleton Pattern [Beginner]

The singleton is one of the most used and well know design patterns in programming. The idea of a singleton is to have a class which can only be instantiated once. These are very useful for state objects and global resource objects. I will go over several different ways to create singletons and also how to create a generic singleton class.

There are several different places you find information on singletons and creating them for all different languages. One great resources is the Gang of Four book, Design Patterns: Elements of Reusable Object-Oriented Software.

One of the main concerns when using/creating singletons is multi threaded applications/environments. The issue occurs when two threads decided to get an instance of a never made singleton then they have the chance of creating two instances. All the solutions I will present are thread safe.

The first solution presented is a singleton class that you would template your classes after. It creates the singleton instance at the beginning of the start of the application, which makes the class thread safe. As you can notice below the class has a private constructor so the class can't be created outside the class. A static private variable to hold our single instance of our class is included along with a method that returns the instance.

public class Singleton1
{
  private static Singleton1 instance = new Singleton1();

  private Singleton1(){}

  public static Singleton1 GetInstance()
  {
    return instance;
  }
}

Now to create an instance of this class all we need to do is:

Singleton1 single = Singleton1.getInstance();

The second solution uses lazy instantiation, which means that the class is not created until it is needed. This is good if your class is only used on rare occasions and has a decent memory footprint. You will notice in the code below we again have the static private variable but this time it is not set to a new instance. And we have the same empty private constructor and the getInstance method. But this time you see a little more code in the method.

The first thing you will see is a lock command with the parameter typeof(Singleton2). This is locking the code in this block for one thread at a time. And the next item is an if statement to see if we have created an instance yet. If the instance is null we will create one. And finally we just return the instance. Now to get an instance we use the same technique as above.

public class Singleton2
{
  private static Singleton2 instance;

  private Singleton2() { }

  public static Singleton2 GetInstance()
  {
    lock (typeof(Singleton2))
    {
      if (instance == null)
      {
        instance = new Singleton2();
      }
      return instance;
    }
  }
}

The last singleton implementation I am going to go over is a generic singleton. This implementation is very similar to the last except that it now uses generics syntax to create a singleton of any class. This does not however prevent the class T from being created by itself. So this implementation has the benefit of being used as is but has the downfall of not being able to force strict control over the singleton.

class GenericSingleton<T> where T : class, new()
{
  private static T instance;

  public static T GetInstance()
  {
    lock (typeof(T))
    {
      if (instance == null)
      {
        instance = new T();
      }
      return instance;
    }
  }
}

To use this you simply would use a piece of code like below, assuming you have the class AutoFactory defined. AutoFactory's constructor would also not be able to take parameters in this implementation.

AutoFactory autoF = GenericSingleton<AutoFactory>.GetInstance();

This should give a decent understanding of the singleton pattern and how to implement it using C#.