Design Patterns can be categorized under the following Heads
- Creational
- Structural
- Behavioral
This section deals with the creational design patterns,
Creational Patterns
The creational patterns aim to separate a system from how its objects are created, composed, and represented.
Creational Patterns can be classified as follows
1. Abstract Factory
2. Builder
3. Factory
4. Prototype
5. Singleton
Factory Method Pattern
The Factory Method pattern is a way of creating objects, but letting subclasses decide exactly which class to instantiate.
Various subclasses might implement the interface; the Factory Method instantiates the appropriate subclass based on information supplied by the client or extracted from the current state.
Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
Example:
The Example presented below is a basic document creation factory, where different types of documents(Resumes, Reports etc.) can be created using the Factory Pattern
public abstract class DocPage
{
public string Header
{
set { Header = "P.Solutions"; }
}
public string Footer
{
set { Footer = "Confidential Document"; }
}
}
class SkillSetPage : DocPage
{
}
class EducationalDetailsPage : DocPage
{
}
class ExperienceSummaryPage : DocPage
{
}
class BriefInrtoPage : DocPage
{
}
class FindingsPage : DocPage
{
}
class ConclusionPage : DocPage
{
}
class SummaryPage : DocPage
{
}
class BibliographyPage : DocPage
{
}
//The 'Creator' abstract class. This is class that acts as creator of Documents, depending upon the requirements
public abstract class Document
{
private List<DocPage> _pages = new List<DocPage>();
// Constructor calls abstract Factory method
public Document()
{
this.CreatePages();
}
public List<DocPage> Pages
{
get { return _pages; }
}
// Factory Method
public abstract void CreatePages();
}
// 'ConcreteCreator' classes. These Classes are called in by Client , hieding the details as to how the classes produce documnents
public class Resume : Document
{
// Factory Method implementation
public override void CreatePages()
{
Pages.Add(new SkillsPage());
Pages.Add(new EducationPage());
Pages.Add(new ExperiencePage());
}
}
/// A 'ConcreteCreator' class
///
class Report : Document
{
// Factory Method implementation
public override void CreatePages()
{
Pages.Add(new IntroductionPage());
Pages.Add(new ResultsPage());
Pages.Add(new ConclusionPage());
Pages.Add(new SummaryPage());
Pages.Add(new BibliographyPage());
}
}
All in Place, Let’s now call these classes to get the documents.
protected void Page_Load(object sender, EventArgs e)
{
Resume rs = new Resume();
Response.Write("");
foreach( DocPage dp in rs.Pages)
{
Response.Write("
");
");
Response.Write(dp.GetType().Name);
}
}
When called, as shown above, Following pages become part of Resume document.
SkillsPage
EducationPage
ExperiencePage
EducationPage
ExperiencePage
Please note that instead of the abstract classes, Interface is generally considered for implementing the Factory pattern. In case you feel the need, feel free to modify the code for using interfaces.
For further understanding implementation of the pattern in .Net, go to the following link.
Hope this was helpful,
Till next time. Happy Coding!!
Comments
Post a Comment