How to abstract a singleton class?

Question

This is how I write my singleton classes.

public class MyClass {     /// <summary>     /// Singleton     /// </summary>     private static MyClass instance;      /// <summary>     /// Singleton access.     /// </summary>     public static MyClass Instance     {         get         {             if (_instance == null)             {                 _instance = new MyClass();             }             return _instance;         }     }      private MyClass() { .... } } 

How To Create A Singleton Pattern That Is Reusable?

Singleton patterns present the following challenges.

• The constructor is private or protected.
• A base class can't instantiate an inherited class. So you can reuse a common abstract MyAbstractSingletonClass.
• It has to have a local read-only property to get the instance.

The Problem

I'm using this pattern on a number of classes and always have to write the same code. How can I write something that is reused whenever I need a singleton?

Answer 1

You can achieve this using a combination of a self-referencing generic type constraint, and a "new()" type constraint.

The "new" constraint ensures that any child class will always have a parameterless constructor, so _instance = new T(); will always work.

The self-referencing type constraint ensures that the "Instance" static property always returns the correct Type; not the "base" type. Your singleton base class would look something like this:

public abstract class SingletonBase<T>      where T : SingletonBase<T>, new() {     private static T _instance = new T();     public static T Instance     {         get         {                             return _instance;         }        } } 

Your child classes will look like this:

public class MyChildSingleton : SingletonBase<MyChildSingleton> {     //Done! } 

Of course, if you want your singleton to be general-purpose, you should also change your "create singleton instance" code slightly, to use the "double-check lock" pattern, or the Lazy class, to make it thread-safe.

The big caveat: if you use this method, the "new()" constraint pretty much ensures that your class will always have a public, parameterless constructor. That means your end-users could always just call new MyChildSingleton() if they really wanted, bypassing your singleton instance entirely. Your singleton would be "by convention," instead of strictly enforced. To get around this would take a bit more engineering. In the above scenario, the convention seems to be that you should name your static instance "Default" instead of "Instance." This subtly conveys the fact that your class offers a 'suggested' singleton instance, but using it is technically optional.

I've made some attempts to strictly enforce the singleton pattern, and the end result was to use reflection to manually invoke a private constructor. You can see my full code attempt here.

Answer 2

The true solution is starting with BTownTKD's approach but augmenting it with the Activator.CreateInstance method which allows your child classes to keep the private constructors.

Parent Class

public abstract class SingletonBase<T> where T : SingletonBase<T> {     private static readonly Lazy<T> Lazy =         new Lazy<T>(() => Activator.CreateInstance(typeof(T), true) as T);      public static T Instance => Lazy.Value; } 

Child Class

public sealed class MySingleton : SingletonBase<MySingleton> {     private MySingleton() { } } 

Full Implementation Example Here