Nick Gravelyn

It seems that for one reason or another I was never able to make a good base class for singletons in C#. They usually wound up with requiring that the derived class call some method to set itself as the static instance. Today, while working on building a fresh new library that I’m going to build a 3D “engine” on top of, I wound up stumbling upon a really nice solution. I realized that I can cast the ‘this’ reference to the type of the singleton. So I wound up with this base class:

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

	protected Singleton()
	{
		// make sure we only have one instance
		Debug.Assert(
			instance == null,
			string.Format(
				"Singleton of type {0} already instantiated.",
				typeof(T)));

		instance = this as T;

		// validate that the cast worked
		Debug.Assert(
			instance != null,
			string.Format(
				"Singleton of type {0} failed to be instantiated.",
				GetType()));
	}
}

With that laid out my singleton classes don’t have to do anything at all to take advantage of it. The trick is that to make type A a singleton, it simply derives from Singleton<A>. A little confusing initially, but it works quite well in practice. For instance, here’s a simple singleton Log class:

public class Log : Singleton<Log>
{
}

Yep, that’s it. I wanted to illustrate that this base class removes any and all singleton-related code from derived classes. So now to instantiate our single Log we have three options (technically two, but they’re written differently):

var log = new Log(); // manually instantiate

// or use property which instantiates if needed.
// we can use the Log class itself or the base
// Singleton<Log> class to reference it.
var log = Log.Instance;
var log = Singleton<Log>.Instance;

I generally recommend using the Instance properties to make the code more explicit that the object is a singleton, but all three work just fine. If you are manually calling the constructor, the Debug.Assert will fail if you call it multiple times like this:

var a = new Log();
var b = new Log(); // Debug.Assert fails

I’m sure I’m not the first to think up this exact implementation, but since it seems to be a really nice way to stop writing the same singleton boiler plate over and over, I figured I’d share.