Introduction
Cristopher Alexander says, “Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice”.
Although Cristopher was an architect, who had designed great buildings, this saying holds true in our day-to-day life as well. We can very much relate this to software development. Since we come across many design problems every day, we can define a strategy for solving these problems. The strategy remains the same but the implementation may vary from developer to developer.
These strategies of solving commonly occurring problem without defining the exact code are called patterns and since these are very much related to our software designs, we call then Software Design Patterns.
Singleton Pattern
The singleton pattern is a software design pattern that is used to restrict instantiation of a class to one object. This is useful when we require exactly one object of a class to perform our operations. In this pattern, we ensure that the class has only one instance and we provide a global point of access to this object.
The singleton pattern can be implemented in C# by the use of static
method, which provides a global point of access to a singleton object. We create a static
volatile object of the class which serves as a single instance for the class. Look at the code sample given below:
public class Singleton
{
private static volatile Singleton _instance = null;
public static Singleton Instance()
{
if (_instance == null)
{
lock (typeof(Singleton))
{
_instance = new Singleton();
}
}
return _instance;
}
private Singleton() { }
}
In the above code, we have made the constructor as private
, this will ensure that no one can create an object of this class using the new
keyword. Then we created a static
volatile object of class Singleton
. This object will serve as the single point of access to this class. Going ahead, we have written a public static
method GetInstance()
, this method is responsible for creating the static
object of the Singleton
class if it already doesn’t exist. If the object is already created, then this method will return an instance of the already created object. Hence, the code will ensure creation of only one object of the Singleton
class.
In the above code, the lock
statement is used for thread safety. In multi-threaded environment, we would require the creation of object in a thread safe manner. Furthermore, the volatile
keyword is used to ensure that there is no optimizer reordering of the code.
Look at the code given below. Is it an implementation of Singleton design pattern??? This I leave it to you… explore and enjoy understanding patterns…. :)
sealed class SingletonCounter
{
public static readonly SingletonCounter Instance =
new SingletonCounter();
private SingletonCounter() {}
}
Conclusion
The Singleton design pattern is a very useful mechanism for providing a single point of object access in OOPs application. Regardless of the implementation used, the pattern provides a commonly understood concept that can be easily shared among design and development teams. Special care must be taken while implementing the singleton pattern. This pattern must only be used when required, otherwise it may act as an anti-pattern.
Want more Tech-Articles?
History
- 24th April, 2008: Initial version