Is this a valid, lazy, thread-safe Singleton implementation for C#?

Question

I implemented a Singleton pattern like this:

public sealed class MyClass {

    ...

    public static MyClass Instance {
        get { return SingletonHolder.instance; }
    }

    ...

    static class SingletonHolder {
        public static MyClass instance = new MyClass ();
    }
}

From Googling around for C# Singleton implementations, it doesn't seem like this is a common way to do things in C#. I found one similar implementation, but the SingletonHolder class wasn't static, and included an explicit (empty) static constructor.

Is this a valid, lazy, thread-safe way to implement the Singleton pattern? Or is there something I'm missing?

Answer 1

Jon Skeet has written an article about implementing the Singleton pattern in C#.

The lazy implementation is version 5:

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();
    }
}

Notice in particular that you have to explicitly declare a constructor even if it is empty in order to make it private.