Singleton Design Pattern In C#

1. The following code is thread-safe.
2. In the code, the thread is locked on a shared object and checks whether an instance has been created or not. It takes care of the memory barrier issue and ensures that only one thread will create an instance. For example: Since only one thread can be in that part of the code at a time, by the time the second thread enters it, the first thread will have created the instance, so the expression will evaluate as false.
3. The biggest problem with this is performance; performance suffers since a lock is required every time an instance is requested.

public sealed class Singleton2 {  
    Singleton2() {}  
    private static readonly object lock = new object();  
    private static Singleton2 instance = null;  
    public static Singleton2 Instance {  
        get {  
            lock(lock) {  
                if (instance == null) {  
                    instance = new Singleton2();  
                }  
                return instance;  
            }  
        }  
    }  
}

Thread Safety Singleton using Double-Check Locking

Explanation of the following code,

In the following code, the thread is locked on a shared object and checks whether an instance has been created or not with double checking.

public sealed class Singleton3 {  
    Singleton3() {}  
    private static readonly object lock = new object();  
    private static Singleton3 instance = null;  
    public static Singleton3 Instance {  
        get {  
            if (instance == null) {  
                lock(lock) {  
                    if (instance == null) {  
                        instance = new Singleton3();  
                    }  
                }  
            }  
            return instance;  
        }  
    }  
}

Thread Safe Singleton without using locks and no lazy instantiation

Explanation of the following code:

1. The preceding implementation looks like a very simple code.
2. This type of implementation has a static constructor, so it executes only once per Application Domain.
3. It is not as lazy as the other implementation.

public sealed class Singleton4    
{    
    private static readonly Singleton4 instance = new Singleton4();    
    static Singleton4()    
    {    
    }    
    private Singleton4()    
    {    
    }    
    public static Singleton4 Instance    
    {    
        get    
        {    
            return instance;    
        }    
    }    
}

Using .NET 4's Lazy<T> type

Explanation of the following code:

1. If you are using .NET 4 or higher then you can use the System.Lazy<T> type to make the laziness really simple.
2. You can pass a delegate to the constructor that calls the Singleton constructor, which is done most easily with a lambda expression.
3. Allows you to check whether or not the instance has been created with the IsValueCreated property.

public sealed class Singleton5    
{    
    private Singleton5()    
    {    
    }    
    private static readonly Lazy<Singleton5> lazy = new Lazy<Singleton5>(() => new Singleton5());    
    public static Singleton5 Instance    
    {    
        get    
        {    
            return lazy.Value;    
        }    
    }    
}

Hope you liked the article. Please let me know the feedback in the comments section.