Scribd
Upload
56 views

Extension Method: Singleton Design Pattern

The singleton design pattern ensures that a class has only one instance and provides a global point of access to it. It has four key characteristics: 1) a private constructor, 2) the class is sealed, 3) a static variable stores the instance, and 4) a public static method to access the instance. Advantages include memory savings from reusing a single instance and hiding dependencies. Disadvantages are more difficult testing and reduced parallelism. A singleton class can be extended whereas a static class cannot, and a singleton allows initialization with state whereas a static class does not.

Uploaded by

Rajesh Vhadlure
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
56 views

Extension Method: Singleton Design Pattern

The singleton design pattern ensures that a class has only one instance and provides a global point of access to it. It has four key characteristics: 1) a private constructor, 2) the class is sealed, 3) a static variable stores the instance, and 4) a public static method to access the instance. Advantages include memory savings from reusing a single instance and hiding dependencies. Disadvantages are more difficult testing and reduced parallelism. A singleton class can be extended whereas a static class cannot, and a singleton allows initialization with state whereas a static class does not.

Uploaded by

Rajesh Vhadlure
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

Extension Method:

Singleton Design Pattern


It ensures a class has only one instance and provides a global point of access to it. There are
various different ways of implementing the singleton pattern in C#. However, all these
implementations share four common characteristics :
1. A single constructor, that is private and parameter less.
2. The class is sealed.
3. A static variable that holds a reference to the single created instance, if any.
4. A public static means of getting the reference to the single created instance, creating one if
necessary.

Advantages :
1. Its saves memory because the single instance is reused again and again.
2. It can be lazy loaded.
3. It helps to hide dependencies.
4. It can be extended into a factory pattern.

Disadvantage :
1. Unit testing is more difficult (because it introduces a global state into an application).
2. Singleton causes code to be tightly coupled. 
3. This pattern reduces the potential for parallelism within a program, because to access the
singleton in a mufti-threaded system, an object must be serialized (by locking).

Singleton class vs. Static class


1. A Static Class cannot be extended whereas a singleton class can be extended.
2. A Static Class can still have instances (unwanted instances) whereas a singleton class
prevents it.
3. A Static Class cannot be initialized with a STATE (parameter), whereas a singleton class can
be.
4. A Static class is loaded automatically by the CLR when the program or namespace
containing the class is loaded.

Example
namespace SingletonPattern
{
public sealed class SingleTon
{
private static int counter = 0;
private static readonly object obj = new object();

private static SingleTon instance = null;

private SingleTon()
{
counter++;
Console.WriteLine("Counter {0}", counter);
}

public static SingleTon GetInstance


{
get
{
if (instance == null)
{
lock (obj)
{
if (instance == null)
{
instance = new SingleTon();
}
}
}

return instance;
}
}

public void PrintMessage(string msg)


{
Console.WriteLine(msg);
}
}
}

namespace SingletonPattern
{
class Program
{
static void Main(string[] args)
{
Parallel.Invoke(
() => FromObject1(),
() => FromObject2()
);

Console.ReadLine();
}

private static void FromObject2()


{
SingleTon obj2 = SingleTon.GetInstance;
obj2.PrintMessage("From obj 2");
}

private static SingleTon FromObject1()


{
SingleTon obj1 = SingleTon.GetInstance;
obj1.PrintMessage("From obj 1");
return obj1;
}
}
}

You might also like