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 Foo(); } return instance; ``` Anyone who knows what a Singleton is is familiar with the issue(you only need the if once). It's trivial but irritating. So, I thought of an alternate solution, at least for .NET(although it should work anywhere that has some equivalent to function pointers: ``` public class Foo { private delegate Foo FooReturner(); private static Foo innerFoo; private static FooReturner fooReturnHandler = new FooReturner(InitialFooReturner); public static Foo Instance { get { return fooReturnHandler(); } } private static Foo InitialFooReturner() { innerFoo = new Foo(); fooReturnHandler = new FooReturner(NewFooReturner); return innerFoo; } private static Foo NewFooReturner() { return innerFoo; } } ``` In short - the Instance returns a delegate method. The delegate is initially set to a method that initializes your in…

Accepted Answer

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

An obvious singleton implementation for .NET?

Solution

Problem

Related problems