Singleton Pattern

Singleton pattern ensures a class can have only single instance during the lifetime of an application.

When to use Singleton Pattern?

When you want to create single object only once during application life you can go with Singleton Pattern. The implementation and use of singleton pattern is very easy. See below example.

Code –

public class Singleton

{

    //private static member.

    private static Singleton instance;

   

    //Private constructor prevents instance creation of class from outside.

    private Singleton() { }

   

    //This static method responsible for creation of instance of this class.

    public static Singleton GetInstance()

    {

        //create new instance only in first call, rest of the time it will return existing object

        if (instance == null)

            instance = new Singleton();

       return instance;

    }

    public void Display()

    {

        Console.WriteLine("Display Method called from Singleton Class...");

    }

}

class Program

{

    static void Main(string[] args)

    {

        Singleton singleObject =  Singleton.GetInstance();

        singleObject.Display();

        Console.Read();

    }

}

Output –

Another way (via Property) to implement singleton pattern.

public class Singleton

{

    //private static member.

    private static Singleton instance;

    //Private constructor prevents instance creation of class from outside.

    private Singleton() { }

    //This static method responsible for creation of instance of this class.

    public static Singleton Instance

    {

        get

        {

            //create new instance only in first call, rest of the time it will return existing object

            if (instance == null)

                instance = new Singleton();

            return instance;

        }

    }

    public void Display()

    {

        Console.WriteLine("Display Method called from Singleton Class...");

    }

}

class Program

{

    static void Main(string[] args)

    {

        Singleton singleObject = Singleton.Instance;

        singleObject.Display();

        Console.Read();

    }

}

Output –

Same as above example.

Advantages - 

• Class can perform additional functionalities other than creation of an object.
• This is referred as Lazy Initialization approach since instance of an object is not created until user call instance property or method. This approach avoids instantiating singletons class when application starts.

Disadvantage -

• Singleton pattern is not thread safe by default. You need to write additional code to make it thread safe. I'll post article for Thread safe singleton pattern in few days.

Hope you liked this article. Please leave your feedback.

References –

MSDN

DoFactory

See Also –

Creational Patterns	Structural Patterns	Behavioral Patterns
Singleton Pattern	Adapter Pattern	Chain of Responsibility Pattern
Thread safe singleton pattern	Bridge Pattern	Command Pattern
Factory Pattern	Composite Pattern	Interpreter Pattern
Abstract Factory Pattern	Decorator Pattern	Iterator Pattern
Builder Pattern	Facade Pattern	Mediator Pattern
Prototype Pattern	Flyweight Pattern	Memento Pattern
	Proxy Pattern	Observer Pattern
		State Pattern
		Strategy Pattern
		Template Method Pattern
		Visitor Pattern