Creational Patterns

Introduction

Most programming involves usage of Design Patterns in one form or other .There are around 23 Design Patterns that are available. They are categorized as given below:

I] Creational Patterns

Singleton
Factory
Abstract Factory
Builder
Prototype

II] Structural Patterns

Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy

III] Behavioral Pattern

Chain Of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Template Method
Visitor

This paper discusses the implementation of the Singleton Design Pattern.

The Concept

Design patterns are commonly defined as time-tested solutions to recurring design problems.

The most striking benefits of Design Patterns are as follows:

They provide you with a way to solve issues related to software development using a proven solution. The solution facilitates the development of highly cohesive modules with minimal coupling. They isolate the variability that may exist in the system requirements, making the overall system easier to understand and maintain.
Design patterns make communication between designers more efficient. Software professionals can immediately picture the high-level design in their thoughts immediately the name of the pattern used to solve a particular issue when discussing system design

Singleton Pattern: In the Singleton Pattern we have at any given instance a single instance of the Singleton Class active. All instantiation of the Singleton Class references the same instance of the Class. The pattern also provides a global point of access to the sole instance of the class.

Class Diagram

Sequence Diagram

Implementation

Steps for implementing the Singleton Pattern:

Step1:
Create a project of type Console Application. Name it SingletonTest.

Step2:
Add a Class File named Singleton and add the following code

/// <summary>
/// Summary description for Singleton.
/// </summary>
public class Singleton
{
//Fields
private static Singleton instance;
/// <summary>
/// Standard default Constructor
/// </summary>
protected Singleton() {}
/// <summary>
/// Static method for creating the single instance
/// of the Constructor
/// </summary>
/// <returns></returns>
public static Singleton Instance()
{
// initialize if not already done
if( instance == null )
instance = new Singleton();
// return the initialized instance of the Singleton Class
return instance;
}
}

Step 3:
Create a Client class that would access the Singleton Class as follows :

/// <summary>
/// Summary description for Client.
/// </summary>
class Client
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
// Constructor is protected -- cannot use new
Singleton s1 = Singleton.Instance();
Singleton s2 = Singleton.Instance();
if( s1 == s2 )
Console.WriteLine( "The same instance" );
Console.ReadLine();
}
}

Step 4:
Run the Application it would display the following output:

Conclusion

Thus we have implemented the Singleton Design Pattern using the .Net framework.Like any Concepts/Theory Singleton Pattern also has its pros and cons.

Benefits of Singleton Pattern:

Instance control: Singleton prevents other objects from instantiating their own copies of the Singleton object, ensuring that all objects access the single instance.
Flexibility: Because the class controls the instantiation process, the class has the flexibility to change the instantiation process.

Drawbacks of Singleton Pattern:

Overhead. Although the amount is minuscule, there is some overhead involved in checking whether an instance of the class already exists every time an object requests a reference. This problem can be overcome by using static initialization.
Possible development confusion. When using a singleton object (especially one defined in a class library), developers must remember that they cannot use the new keyword to instantiate the object. Because application developers may not have access to the library source code, they may be surprised to find that they cannot instantiate this class directly.
Object lifetime. Singleton does not address the issue of deleting the single object. In languages that provide memory management (for example, languages based on the .NET Framework), only the Singleton class could cause the instance to be deallocated because it holds a private reference to the instance. In languages, such as C++, other classes could delete the object instance, but doing so would lead to a dangling reference inside the Singleton class.