Ensure a class has only one instance and provide a global point of access to it(Singleton Pattern)

Singleton Pattern:
Ensure a class has only one instance and provide a global point of access to it.

Solution:
The code below uses Double-checked locking. See here for an explanation of double checked locking.
Update(06/29/2016):
Jon Skeet’s article here, does not recommend implementing singleton pattern using Solution 1 below.
He instead recommend’s using .NET 4’s Lazy type, to implement a singleton pattern. The Lazy class internally uses double-checked locking by default to store either the exception that was thrown during construction, or the result of the function that was passed to Lazy.
I have implemented the same in Solution 2 below.

Solution 1(Not recommended):

Singleton Design Pattern

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class UnitTest1
{
        [TestMethod]
        public void SingletonTest()
        {
            var s1 = Singleton.Instance();
            var s2 = Singleton.Instance();

            if (s1 == s2)
            {
                Assert.IsTrue(true);
            }
            else
            {
                Assert.Fail();
            }
        }
}
public class Singleton
{
    private static Singleton singleton;
    private static object tempObjectForLocking = new object();
    private Singleton()
    {
    }
     public static Singleton Instance()
     {
            if (singleton != null)//First check
            {
                return singleton;
            }
            lock (tempObjectForLocking)
            {
                //Multiple processes could access the code below at the same time, 
                //therefore a "null" check has been added so only one process 
                //can create a singleton instance. 
                if (singleton == null)//Second(double) check
                {
                    singleton = new Singleton();
                }
            }
            return singleton;
     }
}

Solution 2(recommended):

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.VisualStudio.TestTools.UnitTesting;
public class UnitTest1
{
        [TestMethod]
        public void SingletonTest()
        {
            var s1 = Singleton.Instance();
            var s2 = Singleton.Instance();
            if (s1 == s2)
            {
                Assert.IsTrue(true);
            }
            else
            {
                Assert.Fail();
            }
        }
}
public sealed class Singleton
{
    //Using the .NET 4's Lazy<T>; type, to implement a singleton pattern. 
    //The Lazy<T>; class internally uses double-checked locking by default to 
    //store either the exception that was thrown during construction, 
    //or the result of the function that was passed to Lazy<T>.

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

You may also like

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.