Static constructor in C#

Did you ever implement a singleton in C#? For those who don't know what a singleton is, it is a class which can only have one instance, more on Wikipedia. The preferred implementation of a singleton in C# is the following:

public sealed class Singleton
{
   private static readonly Singleton instance = new Singleton();
   
   private Singleton(){}

   public static Singleton Instance
   {
      get 
      {
         return instance; 
      }
   }
}

But what would you do if you want to execute some custom code before the instance of the singleton is initialized? You can use the classic singleton code which isn't really different than in other programming languages.

public sealed class ClassicSingleton
{
    private static ClassicSingleton instance;
    private static object syncRoot = new Object();

    private ClassicSingleton() { }

    public static ClassicSingleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock (syncRoot)
                {
                    if (instance == null)
                    {
                        ...custom code
                        instance = new ClassicSingleton();
                    }
                }
            }

            return instance;
        }
    }
}

You have to set the constructor private. A static field of the type of the class holds the single instance. Another static method is the single point of access to get an object of the class. Internally it has to lock the access to the static object to be sure that really only one object will be created. An implementation with a static constructor is easier to handle and also much clearer.

public sealed class Singleton
{
    private static Singleton instance;

    private Singleton() { }

    static Singleton()
    {
        ...custom code
        instance = new Singleton();
    }

    public static Singleton Instance
    {
        get
        {
            return instance;
        }
    }
}

In this sample, a static constructor is added which initializes the instance of the Singleton class. It will only be called one time, before one of the static methods of the class is called. So the Instance method doesn't have to do this anymore. This results in a much cleaner code, a singleton with no lock or if statement! But also in other cases, when you have static fields in your class, it helps you to avoid the lock and the if statements.