Singleton Pattern C# with Example

The Singleton pattern is designed to restrict creation of a class to exactly one single instance. 
This pattern is used in a scenario where it makes sense to have only one of something, such as: 
a single class that orchestrates other objects' interactions, ex. Manager class 
or one class that represents a unique, single resource, ex. Logging component 
One of the most common ways to implement the Singleton pattern is via a static factory method such as a 
CreateInstance() or GetInstance() (or a static property in C#, Instance), which is then designed to always return 
the same instance. 
The first call to the method or property creates and returns the Singleton instance. Thereafter, the method always 
returns the same instance. This way, there is only ever one instance of the singleton object. 
Preventing creation of instances via new can be accomplished by making the class constructor(s) private. 
Here is a typical code example for implementing a Singleton pattern in C#: 
class Singleton 
{ 
// Because the _instance member is made private, the only way to get the single 
// instance is via the static Instance property below. This can also be similarly 
// achieved with a GetInstance() method instead of the property. 
private static Singleton _instance = null; 
// Making the constructor private prevents other instances from being 
// created via something like Singleton s = new Singleton(), protecting 
// against unintentional misuse. 
private Singleton() 
{ 
} 
public static Singleton Instance 
{ 
get 
{ 
// The first call will create the one and only instance. 
if (_instance == null) 
{ 
_instance = new Singleton(); 
} 
// Every call afterwards will return the single instance created above. 
return _instance; 
} 
} 
} 
To illustrate this pattern further, the code below checks whether an identical instance of the Singleton is returned 
when the Instance property is called more than once. 
class Program 
{ 
 

static void Main(string[] args) 
{ 
Singleton s1 = Singleton.Instance; 
Singleton s2 = Singleton.Instance; 
// Both Singleton objects above should now reference the same Singleton instance. 
if (Object.ReferenceEquals(s1, s2)) 
{ 
Console.WriteLine("Singleton is working"); 
} 
else 
{ 
// Otherwise, the Singleton Instance property is returning something 
// other than the unique, single instance when called. 
Console.WriteLine("Singleton is broken"); 
} 
} 
} 
Note: this implementation is not thread safe. 
To see more examples, including how to make this thread-safe, visit: Singleton Implementation 
Singletons are conceptually similar to a global value, and cause similar design flaws and concerns. Because of this, 
the Singleton pattern is widely regarded as an anti-pattern. 
Visit "What is so bad about Singletons?" for more information on the problems that arise with their use. 
In C#, you have the ability to make a class static, which makes all members static, and the class cannot be 
instantiated. Given this, it is common to see static classes used in place of the Singleton pattern. 
For key differences between the two, visit C# Singleton Pattern Versus Static Class.