An obvious singleton implementation for .NET?

Question

I was thinking about the classic issue of lazy singleton initialization - the whole matter of the inefficiency of:

if (instance == null)
{
    instance = new         


        

Answer 1

This is the canonical, thread safe, lazy Singleton pattern in C#:

public sealed class Singleton
{
    Singleton(){}
    public static Singleton Instance
    {
        get
        {
            return Nested.instance;
        }
    }        
    class Nested
    {
        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static Nested() {}    
        internal static readonly Singleton instance = new Singleton();
    }
}

Answer 2

I always use this regular (non-lazy) one (you could nest it like the other examples): (requires using System.Reflection;)

public class SingletonBase<T> where T : class
{
    static SingletonBase()
    {
    }

    public static readonly T Instance = 
        typeof(T).InvokeMember(typeof(T).Name, 
                                BindingFlags.CreateInstance | 
                                BindingFlags.Instance |
                                BindingFlags.Public |
                                BindingFlags.NonPublic, 
                                null, null, null) as T;
}

Answer 3

Have you measured the performance?

Do you believe that an additional function call is cheaper than an if?

I agree with the others that using the static ctor works well for this initialization. This will also get rid of the inherent race condition that the you have since .net guarentees that static constructors will only be called once.

Answer 4

the whole matter of the inefficiency of:...

What inefficiency?

Those instructions will result into an extremely fast fragments of assembly code. I am completely sure that there is nothing to be gained by trying to "optimize" this. Even if you come up with something faster, it will be at a significant complexity cost.

Unless you do have positive evidence that this code is affecting your performance, you should use the simplest approach that solves your problem.

Answer 5

To prevent from having to copy the singleton code, you could make the type generic, as such:

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

    private class Nested
    {
        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static Nested() { }

        internal static readonly T instance = new T();
    }
}

public sealed class MyType : Singleton<MyType>
{
}

class Program
{
    static void Main()
    {
        // two usage pattterns are possible:
        Console.WriteLine(
            ReferenceEquals(
                Singleton<MyType>.Instance, 
                MyType.Instance
            )
        );
        Console.ReadLine();
    }
}

Answer 6

The best method I have found of creating a singleton is this:

public class Singleton
{
    static public Singleton Instance { get; } = new Singleton();
    private Singleton() { ... }
}

It is very concise, and more importantly, is also thread safe, which can be very troublesome to detect and fix as an application matures.

---

Update: To show it is lazy...

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

namespace SingletonTest
{
    class MySingleton
    {
        static public MySingleton Instance { get; } = new MySingleton();

        private MySingleton() { Console.WriteLine("Created MySingleton"); }

        public void DoSomething() { Console.WriteLine("DoSomething"); }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Starting Main");

            MySingleton.Instance.DoSomething();
        }
    }
}

Output:

Starting Main
Created MySingleton
DoSomething