Factory Pattern vs Factory Method Pattern vs
Abstract Factory Pattern
Factory Pattern
Suppose we have two classes ClassA and ClassB
Now i am having a Third Class or suppose a Web
Page where i need to create objects of both of these class(ClassA & ClassB).
So what we can do here simply is:
ClassA a = new ClassA();
ClassB b = new ClassB();
But it is not a good way as the Client or the
consumer is directly having permission to create an object or the you can say
Client or Consumer should not be responsible for creating the objects. This is
because if something changes in the way of initialization (Creation of objects)
then we need to change everywhere in the consumer files wherever we are
initializing these classes. So best way, is to give out the responsibility of
creation of objects to a new class. This is known as Factory Pattern. So
whenever there is a change in the process of initialization we need to makes
changes only in factory Pattern.
So, for this we can create a Factory Class which
will have the responsibility of creating Objects. It can be either parameterised (Open-Close Principle is not followed) or can be
based on reflection.
Parameterised Factory:
public class SampleClass
{
}
public class ClassA : SampleClass
{
}
public class ClassB : SampleClass
{
}
public class Factory
{
public SampleClass
Create(int classType)
{
SampleClass classObject = new
SampleClass();
if (classType == 1)
{
classObject = new ClassA();
}
if (classType == 2)
{
classObject = new ClassB();
}
//So On for every Class
return classObject;
}
}
So now for creating
object code will be something like this:
SampleClass a = new Factory().Create(1);
SampleClass b = new Factory().Create(2);
But this breaks open
close principle, so we can do it by reflection
Using Reflection:
public class SampleClass
{
}
public class ClassA : SampleClass
{
}
public class ClassB : SampleClass
{
}
public class Factory
{
public SampleClass
Create(string className)
{
SampleClass instance = new
SampleClass();
var requiredClass = (from
assembly in AppDomain.CurrentDomain.GetAssemblies()
from type in
assembly.GetTypes()
where string.Equals(type.Name,
className, StringComparison.OrdinalIgnoreCase)
select type).FirstOrDefault();
if (requiredClass != null)
{
instance = (SampleClass)Activator.CreateInstance(requiredClass);
}
return instance;
}
}
So now for creating
object code will be something like this:
SampleClass a = new Factory().Create(“ClassA”);
SampleClass b = new Factory().Create(“ClassB”);
Now we don’t need to
change Factory class, but right now we are having type of classes “SampleClass”
that is our both the classes are inherited by this “SampleClass”, what if a new
base class comes into picture, then we need to have multiple factories and
which is fine (But then the consumer should know that which factory needs to be
referred to get the objects of that type and also each factory can have
different methods which actually create the object and returns them, example:
Right now Factory class which we created above is having a method “Create” but
in future someone can create a new Factory say “FactoryNew” to get the objects
of some other type and the method which will be creating and returning the
object can be named as “CreateNew”). So here comes the Factory Method and
Abstract factory pattern into the picture.
Factory Method
It’s the way of imposing
that every Factory should have a method “Create” which should return the
desired object(Sub classes that are original factories can decide which type of
object needs to be returned)
It helps the consumer to
directly call a method “Create” to get the object irrespective of which factory
going to be used.
Here goes the code:
public class SampleClass
{
}
public class SampleClassA : SampleClass
{
}
public class SampleClassB : SampleClass
{
}
public class ClassA : SampleClassA
{
}
public class ClassB : SampleClassA
{
}
public class ClassC : SampleClassB
{
}
public class ClassD : SampleClassB
{
}
public abstract class Factory
{
public SampleClass
GetObject(string className)
{
return CreateObject(className);
}
//Acting as a Factory Method
protected abstract SampleClass CreateObject(string
className);
}
public class FactoryA : Factory
{
protected SampleClass
CreateObject(string className)
{
SampleClass instance = new
SampleClassA();
var requiredClass = (from
assembly in AppDomain.CurrentDomain.GetAssemblies()
from type in
assembly.GetTypes()
where string.Equals(type.Name,
className, StringComparison.OrdinalIgnoreCase)
select type).FirstOrDefault();
if (requiredClass != null)
{
instance = (SampleClassA)Activator.CreateInstance(requiredClass);
}
return instance;
}
}
public class FactoryB : Factory
{
protected SampleClass
CreateObject(string className)
{
SampleClass instance = new
SampleClassB();
var requiredClass = (from
assembly in AppDomain.CurrentDomain.GetAssemblies()
from type in
assembly.GetTypes()
where string.Equals(type.Name,
className, StringComparison.OrdinalIgnoreCase)
select type).FirstOrDefault();
if (requiredClass != null)
{
instance = (SampleClassB)Activator.CreateInstance(requiredClass);
}
return instance;
}
}
So now for creating
object code will be something like this:
SampleClass a = new FactoryA().GetObject(“ClassA”);
SampleClass b = new FactoryA().GetObject(“ClassB”);
SampleClass c = new FactoryB().GetObject(“ClassC”);
SampleClass d = new FactoryB().GetObject(“ClassD”);
So what’s the problem
now which still persists, any guesses?????
As of now everything is
perfect just one problem is remaining and that is client or the consumer has to
create the objects of factory (knowing that which factory will return which
type of object). This problem can be eliminated by adding one more level of abstraction
on Factories (i.e. Factory for numerous factories). It that case consumer don’t
have to create the object of factory themselves they will just provide which
object they need and based on that it’s the task of the parent factory to
decide which factory needs to be initiated to create that kind of object). So here
comes the Abstract Factory into picture.
Abstract Factory:
I don’t think I need to
explain what Abstract Factory pattern is and why we need it. But anyways,
Abstract Factory is used to provide one more level of modularization by which
consumer don’t have to worry to create an instance of the Factory also, the
responsibility goes inside the Parent Factory
Here goes the Code:
public class SampleClass
{
}
public class SampleClassA : SampleClass
{
}
public class SampleClassB : SampleClass
{
}
public class ClassA : SampleClassA
{
}
public class ClassB : SampleClassA
{
}
public class ClassC : SampleClassB
{
}
public class ClassD : SampleClassB
{
}
public class Factory
{
public SampleClass
GetObject(string className)
{
SampleClass instance = new
SampleClass();
//Here we can have Enums or XML as Depedency Injection
Container have XML to get which factory needs to be initiated for which class
//So we can
read that value and use reflection code to initiate that Factory and call its
method "CreateObject" here goes the code for that
//Suppose we get the name of the factory class from XML and
put it ninto the string, consider we get "FactoryA" in this example
string factoryName = "FactoryA";
var requiredFactory = (from
assembly in AppDomain.CurrentDomain.GetAssemblies()
from type in
assembly.GetTypes()
where string.Equals(type.Name,
factoryName, StringComparison.OrdinalIgnoreCase)
select type).FirstOrDefault();
if (requiredFactory != null)
{
object factoryInstance = Activator.CreateInstance(requiredFactory);
// Get the operation's method, invoke it, and
get the return value, Factory knows method name is CreateObject
var methodInfo =
factoryInstance.GetType().GetMethod("CreateObject");
object[] operationParameters = new object[] {
className };
instance = (SampleClass)methodInfo.Invoke(factoryInstance,
System.Reflection.BindingFlags.InvokeMethod,
null, operationParameters, null);
}
return instance;
}
}
public interface IFactory
{
SampleClass CreateObject(string
className);
}
public class FactoryA : IFactory
{
public SampleClass
CreateObject(string className)
{
SampleClass instance = new
SampleClassA();
var requiredClass = (from
assembly in AppDomain.CurrentDomain.GetAssemblies()
from type in
assembly.GetTypes()
where string.Equals(type.Name,
className, StringComparison.OrdinalIgnoreCase)
select type).FirstOrDefault();
if (requiredClass != null)
{
instance = (SampleClassA)Activator.CreateInstance(requiredClass);
}
return instance;
}
}
public class FactoryB : IFactory
{
public SampleClass
CreateObject(string className)
{
SampleClass instance = new
SampleClassB();
var requiredClass = (from
assembly in AppDomain.CurrentDomain.GetAssemblies()
from type in
assembly.GetTypes()
where string.Equals(type.Name,
className, StringComparison.OrdinalIgnoreCase)
select type).FirstOrDefault();
if (requiredClass != null)
{
instance = (SampleClassB)Activator.CreateInstance(requiredClass);
}
return instance;
}
}
So now for creating
object code will be something like this:
SampleClass a = new Factory().GetObject(“ClassA”);
SampleClass b = new Factory().GetObject(“ClassB”);
SampleClass c = new Factory().GetObject(“ClassC”);
SampleClass d = new Factory().GetObject(“ClassD”);
Note: Abstract Factory is normally not required
in small applications.
I hope it helps you in
distinguishing now what is the difference between Factor Pattern, Factory
Method Pattern and Abstract Factory.
