Creational Design Pattern for .NET

Design Pattern: Design Patterns are a reusable, high quality solution to a given requirement, task or recurring problem and are commonly defined as time-tested solutions. So basically you have a problem context and the proposed solution for the same. Patterns are about design and interaction of objects, as well as providing a communication platform concerning elegant, reusable solutions to commonly encountered programming challenges.

Design patterns have two major benefits.

1. They provide you with a way to solve issues related to software development using a proven solution.
2. Design patterns make communication between designers more efficient.
   

They are categorized in three groups:



Let's have a look at the Creational Design Pattern:

CREATIONAL: The Creational Design Pattern deals with object creation mechanisms; trying to create objects in a manner suitable to the situation. It focuses on how the objects are created and utilized in an application. The Creational Design Pattern deals with object creation mechanisms, trying to create objects in a manner suitable to the situation.

The Creational Design Pattern is divided into the five categories:



Factory Method: The Factory method takes care of one product whereas the abstract factory pattern provides a way to encapsulate a family of products. This pattern is used to create concrete class instances without specifying the exact class type. We can say it is an Object creation pattern also. Here objects are created without knowing the class of the object. So basically the factory pattern is used wherever the sub classes are given the previledge of instantiating a method that can create an object.

Model:



UML Diagram:



Example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace FactoryMethod
{
class Example
{
static void Main()
{
// constructors call Factory Method
File[] Files = new File[2];
Files[0] = new Furniture();
Files[1] = new Crokery();
foreach (File File in Files)
{
Console.WriteLine("\n" + File.GetType().Name + "--");
foreach (Items Items in File.Itemss)
{
Console.WriteLine(" " + Items.GetType().Name);
}
}
Console.ReadKey();
}
}
// The 'Product' abstract class
abstract class Items
{ }
// ConcreteProduct classes
class SofasetItems : Items
{ }
class PlatesItems : Items
{ }
class BedItems : Items
{ }
class GlassesItems : Items
{ }
class TeasetItems : Items
{ }
class BowlsItems : Items
{ }
class DiningItems : Items
{ }
abstract class File
{
private List<Items> _Itemss = new List<Items>();
// Constructor calls abstract Factory method
public File()
{
this.CreateItemss();
}
public List<Items> Itemss
{
get { return _Itemss; }
}
// Factory Method
public abstract void CreateItemss();
}
class Furniture : File
{
// Factory Method implementation
public override void CreateItemss()
{
Itemss.Add(new SofasetItems());
Itemss.Add(new BedItems());
Itemss.Add(new DiningItems());
}
}
class Crokery : File
{
public override void CreateItemss()
{
Itemss.Add(new PlatesItems());
Itemss.Add(new GlassesItems());
Itemss.Add(new TeasetItems());
Itemss.Add(new BowlsItems());
}
}
}


ABSTRACT FACTORY: Provides an interface for creating families of relegated or dependent objects without specifying their concrete classes.

There are two types of Abstract Factories:

• The simple Abstract Factory is an abstract class defining Factory methods to answer instances of concrete subclasses
• The second form of Abstract Factory is an abstract class defining a common protocol of Factory methods.