C#:Abstract Factory Pattern

• Download OOPS.zip - 26.0 KB

Introduction

Design patterns make it easier to reuse successful designs and architectures.
Design patterns help you choose design alternatives that make a system reusable and avoid alternatives that compromise reusability.
An abstract factory provides an interface for creating families of related objects without specifying their concrete classes

The Abstract Factory pattern let's us group like factory classes together. In the example below we group a factory for creating Indian Bread and a factory for creating American bread together and then we decide what "kind of" bread to create based on the information which we will get at run time.

Using the code

And below there is an implementation in C#:

//Let's define type of bread bases

public enum BreadBase
{
     HotIndianMasalaBase,
     PunjabiTadkaBase,
     ItalianCheeseBase,
     VeggieBase,
}
//This is a breadfactory where people visit to get their favorite bread bases

public interface BreadFactory
{
    Bread GetBread(BreadBase BreadBase);
}

//The abstract bread

public interface Bread
{
    void Bake();
}

//create concrete classes


public class HotIndianMasalaBread :Bread
{
    public void Bake()
    {
        Console.WriteLine ("For you::Hotindian Masala base Bread.");
    }
}
public class VeggieBread : Bread
{
    public void Bake()
    {
        Console.WriteLine("For you::Veggie base Bread.");
    }
}

public class ItalianCheeseBread : Bread
{
    public void Bake()
    {
        Console.WriteLine("For you::Italian cheese base Bread.");
    }
}
public class PunjabiTadkaBaseBread : Bread
{
    public void Bake()
    {
        Console.WriteLine("For you::Punjabi tadka base bread.");
    }
}
//Lets create bread factories aka concrete classes


public class AmericanBreadFactory :BreadFactory
{
    public Bread GetBread(BreadBase BreadBase)
    {
        Bread vBread = null;
        switch (BreadBase)
        {
            case BreadBase.VeggieBase:
                vBread = new VeggieBread();
                break;
            case BreadBase.ItalianCheeseBase:
                vBread = new ItalianCheeseBread();
                break;
        }
        return vBread;
    }
}

public class IndianBreadFactory :BreadFactory
{
    public Bread GetBread(BreadBase BreadBase)
    {
        Bread vBread = null;
        switch (BreadBase)
        {
            case BreadBase.HotIndianMasalaBase:
                vBread = new HotIndianMasalaBread();
                break;
            case BreadBase.PunjabiTadkaBase:
                vBread = new PunjabiTadkaBaseBread();
                break;
        }
        return vBread;
    }
}

//lets order breads


class Program
{
    static void Main(string[] args)
    {
    //example of abstract factory

    AmericanBreadFactory vAmericanBread = new AmericanBreadFactory();
    Bread vBread = vAmericanBread.GetBread(BreadBase.VeggieBase);
    vBread.Bake();

    //lets bak indian punjabi tadka bread

    IndianBreadFactory vIndianBreadFactory = new IndianBreadFactory();
    Bread vIndianBread = vIndianBreadFactory.GetBread(BreadBase.PunjabiTadkaBase);
    vIndianBread.Bake();
    }
} 
//Himachalsoft.com:: my website