HTML clipboardDesign Patterns provide solutions to common
recurring problems. Design patterns can be classified as creational, structural
or behavioral .Singleton and Factory patterns are two of the creational
pattern.Here we will discuss these two patterns .In the later posts we will
discuss other design patterns.
Singleton Design Pattern
We use this design pattern when we want to restrict the number of instances of
any object to one at max at any instant of time. The practical implementation of
this design pattern can be seen in applications that we use daily. Take the
example of Microsoft word .What happens when you open multiple word documents
and navigate between them?. There is only one instance of the word application
active at a time ,you can verify this by checking the active processes .So all
the requests for handling the different word documents is handled by a single
application instance.
Here is an implementation of the singleton design pattern in C#. We will use a
console application for this example. We will create a class and define a
private constructor in that class so that the instances of that class can be
created from only within that class.
private
Singleton()
{
}
Since we declare our class constructor as shown above we can not access it from
outside the class .The below statement will give compilation error
Singleton
obj = new Singleton();
To access the single object of the Singleton class we will create a static
variable of type Singleton and a property to access that private variable.
Here is the complete source code of the above example :
class
Singleton
{
private Singleton()
{
}
//private static variable of Singleton type.
private static
Singleton objSingle =
new Singleton();
//declare a public static property that returns the
//Singleton object as we can not call the private
//constructor from outside the class.
public static
Singleton ObjSingle
{
get {
return Singleton.objSingle; }
set {
Singleton.objSingle = value; }
}
private string name;
public string Name
{
get {
return name; }
set { name =
value; }
}
}
class Program
{
static void Main(string[]
args)
{
//the below line create an object of
singleton type
Singleton objFirstObject =
Singleton.ObjSingle;
objFirstObject.Name = "ashish";
//if we access the objSingle property from
another variable we will get the same object
Singleton objSecondObject
= Singleton.ObjSingle;
//We have assigned the name in first
object,we will get the same value in second object since both points
//to the same instance
Console.WriteLine("objFirstObject.Name={0}
,objSecondObject.Name={1}",objFirstObject.Name,objSecondObject.Name);
Console.ReadLine();
}
}
Factory Method Pattern
In the Factory method pattern there is Factory method which decides which
subclass to instantiate depending on the information passed by the client. All
the subclasses implement a common interface.
The client declares a variable of interface type and calls the Factory method
that returns an instance of the subclass to the client code.So the client is
decoupled from the implementation details of subclass creation.
Following is an example of factory method pattern.
interface IGreet
{
string Hello();
}
class
WeekStart : IGreet
{
public
string Hello()
{
return
" Week Started";
}
}
class
WeekEnd : IGreet
{
public
string Hello()
{
return
"Happy Weekend";
}
}
class
Creator
{
public
IGreet FactoryMethod()
{
if (DateTime.Now.DayOfWeek
== DayOfWeek.Monday ||
DateTime.Now.DayOfWeek ==
DayOfWeek.Tuesday
|| DateTime.Now.DayOfWeek ==
DayOfWeek.Wednesday ||
DateTime.Now.DayOfWeek ==
DayOfWeek.Thursday
)
return
new WeekStart();
else
return
new WeekEnd();
}
}
class Program
{
private
DateTime dt = DateTime.Now;
static void
Main(string[] args)
{
Creator ct =
new Creator();
IGreet weekDayStatus =
ct.FactoryMethod();
Console.WriteLine(weekDayStatus.Hello());
Console.ReadLine();
}
}