This is very
popular creational design patterns which restrict us to have an instance of a
class.

Note:A singleton class can't have a public
constructor and it has to be sealed. The entry point to get the singleton
instance would be a static method or a static property.

Singleton
design pattern is implemented when we need one object of a class is initiated and
that object is used across the application like the following image

In above diagram
we will see different objects trying to invoke an object instantiated as
singleton. This single instance of the object is responsible to invoke
underneath methods or events.

We will
understand this Singleton design pattern with an example

1.Go to visual studio and select a
console application and give name as “SingletonApplication”

2.Add a class to this application and
give this class name as “Singleton” and write the following code to this class

using System;

using
System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonApplication

{

// Sealed ensures to restricted in the derived class

publicclassSingleton

{

privatestaticint counter = 0;

public Singleton()

{

counter++;

Console.WriteLine("Counter Value " + counter.ToString());

}

/*

* Public method which can be invoked
through the singleton instance

*/

publicvoid PrintDetails(string message)

{

Console.WriteLine(message);

}

}

}

This
in this we created a function to print and a static variable to check that how
many instance is creating or this class.

Now
call “PrintDetails” function from the “Programe.cs” class like following

using System;

using
System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonApplication

{

classProgram

{

staticvoid Main(string[] args)

{

/*

* Assuming Singleton is created
from employee class

* we refer to the GetInstance
property from the Singleton class

*/

Singleton fromEmployee = newSingleton();

fromEmployee.PrintDetails("From Employee");

/*

* Assuming Singleton is created
from student class

* we refer to the GetInstance
property from the Singleton class

*/

Singleton fromStudent = newSingleton();

fromStudent.PrintDetails("From Student");

Console.ReadLine();

}

}

}

Now
when we run this application and see

Above image
we can see that its counter value is incrementing as much time we are calling
to this class it means it’s creating the instance 2 time for “singleton” class
which is not the rule of singleton design pattern.

Now make some
changes in “singleton.cs” class and” program.cs” class.

Write the
following code to Singleton.cs class

using System;

using
System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonApplication

{

// Sealed ensures to restricted in the derived class

publicsealedclassSingleton

{

privatestaticint counter = 0;

/*

* Private property initilized with
null

* ensures that only one instance of
the object is created

* based on the null condition

*/

privatestaticSingleton instance = null;

/*

* public property is used to return
only one instance of the class

* leveraging on the private property

*/

publicstaticSingleton GetInstance

{

get

{

if (instance == null)

instance = newSingleton();

return instance;

}

}

/*

* Private constructor ensures that
object is not

* instantiated other than with in
the class itself

*/

private Singleton()

{

counter++;

Console.WriteLine("Counter Value " + counter.ToString());

}

/*

* Public method which can be invoked
through the singleton instance

*/

publicvoid PrintDetails(string message)

{

Console.WriteLine(message);

}

}

}

Program.cs
class

using System;

using
System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonApplication

{

classProgram

{

staticvoid Main(string[] args)

{

/*

* Assuming Singleton is created
from employee class

* we refer to the GetInstance
property from the Singleton class

*/

Singleton fromEmployee = Singleton.GetInstance;

fromEmployee.PrintDetails("From Employee");

/*

* Assuming Singleton is created
from student class

* we refer to the GetInstance
property from the Singleton class

*/

Singleton fromStudent = Singleton.GetInstance;

fromStudent.PrintDetails("From Student");

Console.ReadLine();

}

}

}

Run your
application and see the output

Now we can
see that counter value is not incrementing as much we create the object for
that class and this example follow the rule of singleton design pattern.

Why
singleton class is a sealed class

This can be a
question arise in our mind that when we have private constructor in singleton
class then what is the need to make that class as Sealed class.

We will
understand this with an example

Lets create a
class name “DerivedSingleton” and Inherit the singleton class ,it will give
compile time error that Singleton is inaccessible due to its protection level, Because
singleton is private class.

So now move
this derived class “DerivedSingleton” into the singleton class like following
code

using System;

using
System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonApplication

{

publicclassSingleton

{

privatestaticint counter = 0;

privatestaticobject obj = newobject();

/*

* Private constructor ensures that
object is not

* instantiated other than with in the
class itself

*/

private Singleton()

{

counter++;

Console.WriteLine("Counter Value " + counter.ToString());

}

privatestaticSingleton instance = null;

/*

* public property is used to return
only one instance of the class

* leveraging on the private property

*/

publicstaticSingleton GetInstance

{

get

{

if (instance == null)

instance = newSingleton();

return instance;

}

}

/*

* Public method which can be invoked
through the singleton instance

*/

publicvoid PrintDetails(string message)

{

Console.WriteLine(message);

}

/*

* By removing sealed keyword we can
inherit the singleton and instantiate multiple objects

* This violates singleton design
principles.

*/

publicclassDerivedSingleton : Singleton

{

}

}

}

We have remove sealed keywordfrom the class that why we are able to inherit .

Now run your
application and see the output, you will see that counter value is incremented,
that proving that we are able to create multiple instances of the singleton
using the nested derived class

This violates
the principle of singleton. Let’s go back to the Singleton and make the
class as sealed and remove the DeriviedSingletonclass.

Multithread
Safety in Singleton

Lazy
Initialization : The lazy initialization of an object improves the performance
and avoids unnecessary computation till the point the object is accessed.
Further, it reduces the memory footprint during the startup of the program.
Reducing the memory print will help faster loading of the application.

Lazy
Initialization in our example : GetInstance Property is responsible for the Singleton
Instance creation. Singleton object is not instantiated until and unless GetInstance is
invoked. Hence, there is a delay in instance creation till the GetInstance is
accessed. This Delay in Instance creation is called Lazy Initialization.

Basically Lazy initialization work fine
in single credential environment. In other case suppose that if multithreading
are invoking same getinstance
property at same instance of time then their chance that it create multiple
instance for this property.

Lets understand this with an example

Go to the Program class and write the following
code

using System;

using
System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonApplication

{

classProgram

{

staticvoid Main(string[] args)

{

System.Threading.Tasks.Parallel.Invoke(

() =>
PrintStudentdetails(),

() =>
PrintEmployeeDetails()

);

Console.ReadLine();

}

privatestaticvoid PrintEmployeeDetails()

{

/*

* Assuming Singleton is created
from employee class

* we refer to the GetInstance
property from the Singleton class

*/

Singleton fromEmployee = Singleton.GetInstance;

fromEmployee.PrintDetails("From Employee");

}

privatestaticvoid PrintStudentdetails()

{

/*

* Assuming Singleton
is created from student class

* we refer to the
GetInstance property from the Singleton class

*/

Singleton fromStudent = Singleton.GetInstance;

fromStudent.PrintDetails("From Student");

}

}

}

HereSystem.Threading.Tasks.Parallel.Invoke is a static method which is given by the Microsoft to invoke
multiple method parallel.

This method take Action which you can pass using the
Lambda expression like following

System.Threading.Tasks.Parallel.Invoke(

() =>
PrintStudentdetails(),

() => PrintEmployeeDetails()

);

Now run your application and you will see that its
calling the class 2 time to avoid this situation LOCK keyword is the best way
to controller from calling a class multiple time

So for change the Singleton class like following

using System;

using
System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonApplication

{

// Sealed ensures to restricted in the derived class

publicsealedclassSingleton

{

privatestaticint counter = 0;

privatestaticobject obj = newobject();

/*

* Private property initilized with
null

* ensures that only one instance of
the object is created

* based on the null condition

*/

privatestaticSingleton instance = null;

/*

* public property is used to return
only one instance of the class

* leveraging on the private property

*/

publicstaticSingleton GetInstance

{

get

{

if (instance == null)

{

lock (obj)

{

if (instance == null)

instance = newSingleton();

}

}

return instance;

}

}

/*

* Private constructor ensures that
object is not

* instantiated other than with in
the class itself

*/

private Singleton()

{

counter++;

Console.WriteLine("Counter Value " + counter.ToString());

}

/*

* Public method which can be invoked
through the singleton instance

*/

publicvoid PrintDetails(string message)

{

Console.WriteLine(message);

}

}

}

Now run your application you will see
that this issue is resolved.

How to implement a Thread Safe singleton
class : Locks are the best way to control
thread race condition and they help us to overcome the present situation.
Please refer to the Singleton.cs code for lock checks and double check locking.

Non-Lazy or Eager Loading :Eager loading is nothing but to
initialize the required object before it’s being accessed. Which means,
we instantiate the object and keep it ready and use it when we need it. This
type of initialization is used in lower memory footprints. Also, in eager
loading, the common language runtime takes care of the variable initialization
and its thread safety. Hence, we don’t need to write any explicit coding for
thread safety.

Non-Lazy or Eager in our application

Write the following code in singleton
class

using System;

using
System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonApplication

{

// Sealed ensures to restricted in the derived class

publicsealedclassSingleton

{

privatestaticint counter = 0;

/*

* Private property initilized with
null

* ensures that only one instance of
the object is created

* based on the null condition

*/

privatestaticreadonlySingleton instance = newSingleton();

/*

* public property is used to return
only one instance of the class

* leveraging on the private property

*/

publicstaticSingleton GetInstance

{

get

{

return instance;

}

}

/*

* Private constructor ensures that
object is not

* instantiated other than with in
the class itself

*/

private Singleton()

{

counter++;

Console.WriteLine("Counter Value " + counter.ToString());

}

/*

* Public method which can be invoked
through the singleton instance

*/

publicvoid PrintDetails(string message)

{

Console.WriteLine(message);

}

}

}

When you will run application you will
see following output

Modify
eager loading to Lazy initialization using Lazy keyword

Singleton with Lazy keyword (.NET 4.0) : Lazy keyword provides support for lazy initialization.
In order to make a property as lazy, we need to pass the type of object to the
lazy keyword which is being lazily initialized.

By default, Lazy objects are
thread-safe. In multi-threaded scenarios, the first thread which tries to
access the Value property of the lazy object will take care of thread safety
when multiple threads are trying to access the Get Instance at the same
time.

Therefore, it does not matter which thread
initializes the object or if there are any thread race conditions that are trying
to access this property.

using System;

using
System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonApplication

{

// Sealed ensures to restricted in the derived class

publicsealedclassSingleton

{

privatestaticint counter = 0;

privatestaticreadonlyLazy<Singleton> instance =

newLazy<Singleton>(() => newSingleton());

publicstaticSingleton GetInstance

{

get

{

return instance.Value;

}

}

private Singleton()

{

counter++;

Console.WriteLine("Counter Value " + counter.ToString());

}

/*

* Public method which can be invoked
through the singleton instance

*/

publicvoid PrintDetails(string message)

{

Console.WriteLine(message);

}

}

}

Difference
between Lazy Loading and Non-lazy or Eagar Loading

Lazy
Loading

1.Improve the performance

2.Avoid the unnecessary load till the
point object is accessed

3.Reduces the memory footprint on the
start-up.

4.Faster application load.

Non-Lazy
loading

1.Pre-Instantiation of the object

2.Commonly used in lower memory
footprints

When
we should Lazy initialization

Now assume a
situation that we need to assign some static property in the singleton class
and those property need to be retrieve from the database ,in those situation we
use last initialization as we do not need to retrieve these values till the
singleton object is initialize .

Differences between Singleton and static classes

1.Static is a keyword and Singleton is a design pattern

2.Static classes can contain only static members

3.Singleton is an object creational pattern with one instance of
the class

4.Singleton can implement interfaces, inherit from other classes
and it aligns with the OOPS concepts