C# Abstract Factory Design Pattern With Code Example

public class ClassicCabinet {
    public void FurnitureFunction() {
        Console.WriteLine("I'm used for storing item");
    }
    public void ShowStyle() {
        Console.WriteLine("I'm a Classical cabinet ");
    }
}

do {
    Console.WriteLine("Please select your desired design style:");
    Console.WriteLine("[1]Classic, [2]Contemporary, [3]Scandinavian");
    int.TryParse(Console.ReadLine(), out design);
}
while (design == 0 || design > 3);
switch (design) {
    case 1: //Classic
        do {
            Console.WriteLine("Seems like you prefer Classic design!");
            Console.WriteLine("Please select your desired furniture :");
            Console.WriteLine("[1]Cabinet, [2]Chair, [3]Dining Table");
            int.TryParse(Console.ReadLine(), out furniture);
        } while (furniture == 0 || furniture > 3);
        switch (furniture) {
            case 1: //Cabinet
                Console.WriteLine("Terrific choice! We sell the best cabinet in the town!");
                ClassicCabinet cabinet = new ClassicCabinet();
                cabinet.ShowStyle();
                cabinet.FurnitureFunction();
                break;

case 2: //Contemporary
    do {
        Console.WriteLine("Seems like you prefer Contemporary design!");
        Console.WriteLine("Please select your desired furniture :");
        Console.WriteLine("[1]Cabinet, [2]Chair, [3]Dining Table");
        int.TryParse(Console.ReadLine(), out furniture);
    } while (furniture == 0 || furniture > 3);
switch (furniture) {
    case 1: //Cabinet
        Console.WriteLine("Terrific choice! We sell the best cabinet in the town!");
        ContemporaryCabinet cabinet = new ContemporaryCabinet();
        cabinet.ShowStyle();
        cabinet.FurnitureFunction();
        break;
    case 2: //Chair
        Console.WriteLine("Terrific choice! We sell the best chair in the town!");
        ContemporaryChair chair = new ContemporaryChair();
        chair.ShowStyle();
        chair.FurnitureFunction();
        break;
    case 3: //Dinning table
        Console.WriteLine("Terrific choice! We sell the best dining table in the town!");
        ContemporaryDiningTable diningtable = new ContemporaryDiningTable();
        diningtable.ShowStyle();
        diningtable.FurnitureFunction();
        break;

public interface IFurniture {
    void FurnitureFunction();
    void ShowStyle();
}

public interface IFurnitureFactory {
    IFurniture CreateCabinet();
    IFurniture CreateChair();
    IFurniture CreateDiningTable();
}

public class ClassicFurnitureFactory: IFurnitureFactory {
    public IFurniture CreateCabinet() {
        return new ClassicCabinet();
    }
    public IFurniture CreateChair() {
        return new ClassicChair();
    }
    public IFurniture CreateDiningTable() {
        return new ClassicDiningTable();
    }
}

public class ScandinavianFurnitureFactory: IFurnitureFactory {
    public IFurniture CreateCabinet() {
        return new ScandinavianCabinet();
    }
    public IFurniture CreateChair() {
        return new ScandinavianChair();
    }
    public IFurniture CreateDiningTable() {
        return new ScandinavianDiningTable();
    }
}

public class ContemporaryCabinet: IFurniture {
    public void FurnitureFunction() {
        Console.WriteLine("I'm used for storing item");
    }
    public void ShowStyle() {
        Console.WriteLine("I'm a Contemporary cabinet ");
    }
}

do {
    Console.WriteLine("Please select your furniture style:");
    Console.WriteLine("[1]Classic, [2]Contemporary, [3]Scandinavian");
    int.TryParse(Console.ReadLine(), out style);
}
while (style == 0 || style > 3);
IFurnitureFactory Factory = null;
switch (style) {
    case 1:
        Factory = new ClassicFurnitureFactory();
        break;
    case 2:
        Factory = new ContemporaryFurnitureFactory();
        break;
    case 3:
        Factory = new ScandinavianFurnitureFactory();
        break;
}
do {
    Console.WriteLine("Please select your furniture :");
    Console.WriteLine("[1]Cabinet, [2]Chair, [3]Dining Table");
    int.TryParse(Console.ReadLine(), out furniture);
}
while (furniture == 0 || furniture > 3);
IFurniture furnitureProduct = null;
switch (furniture) {
    case 1:
        furnitureProduct = Factory.CreateCabinet();
        break;
    case 2:
        furnitureProduct = Factory.CreateChair();
        break;
    case 3:
        furnitureProduct = Factory.CreateDiningTable();
        break;
}
Console.WriteLine("Furniture Created: ");
furnitureProduct.ShowStyle();
furnitureProduct.FurnitureFunction();

First I created an abstract class called Furniture, which has two methods. One is a virtual method called FurnitureFunction(), another is an abstract ShowStyle. Since we know that both methods will be overridden, I should set both methods as abstract instead of virtual, but for the sake of demo, I just make them different.

public abstract class Furniture {
    public virtual void FurnitureFunction() {
        Console.WriteLine("Dummy furniture function");
    }
    public abstract void ShowStyle();
}

Another base class is FurnitureFactory, which has 3 abstract methods that must be overridden.

public abstract class FurnitureFactory {
    public abstract Furniture CreateCabinet();
    public abstract Furniture CreateChair();
    public abstract Furniture CreateDiningTable();
}

For the concrete factory, it is the same with the above example, we have ClassicFurnitureFactory, ContemporaryFurnitureFactory, and ScandinavianFurnitureFactory. I showed one of them, ContemporaryFactory. As you can see, this factory inherit from FurnitureFactory and override all the methods

public class ContemporaryFactory: FurnitureFactory {
    public override Furniture CreateCabinet() {
        return new ContemporaryCabinet();
    }
    public override Furniture CreateChair() {
        return new ContemporaryChair();
    }
    public override Furniture CreateDiningTable() {
        return new ContemporaryDiningTable();
    }
}

Same thing happens to the furniture class, they inherit from the Furniture base class and override the parent method with their own.

public class ScandinavianCabinet: Furniture {
    public override void FurnitureFunction() {
        Console.WriteLine("I'm used for storing item");
    }
    public override void ShowStyle() {
        Console.WriteLine("I'm a Scandinavian cabinet ");
    }
}

Again, for diagram person, the UML class diagram will look like this:

The main program is the same, so I skip the code demo. You can get my full source code via Github at the end of this article.

It depends on the design,

From above 2 examples that either using interface or abstract class, my interface/base class is the design style of the furniture, and the product is furniture itself, how about if we inverse the relationship, can we create a factory that creates furniture, and the product is the design style?

I create an Interface called IStyles that will be implemented by abstract factory classes. This interface has two methods, one is to show the design philosophy of each design, and another is to display the major build material for that design.

public interface IStyles {
    void DesignPhilosophy();
    void BuildMaterials();
}

Another Interface is IStyleFactory to be implemented by the concrete classes, as you can see, our concrete product will create 3 different design respectively.

public interface IStyleFactory {
    IStyles CreateClassic();
    IStyles CreateContemporary();
    IStyles CreateScandinavian();
}

Example of one Concrete Factory class, CabinetFactory, it implements the IStyleFactory, it creates cabinet only, but will different style.

public class CabinetFactory: IStyleFactory {
    public IStyles CreateClassic() {
        return new ClassicCabinet();
    }
    public IStyles CreateContemporary() {
        return new ContemporaryCabinet();
    }
    public IStyles CreateScandinavian() {
        return new ScandinavianCabinet();
    }
}

Example of one Concrete Product class, ClassicCabinet, shows the detailed implementations of the logic of classic design of cabinet.

public class ClassicCabinet: IStyles {
    public void DesignPhilosophy() {
        Console.WriteLine("This style inspiration from English and French styles of the " + "18th and 19th centuries");
    }
    public void BuildMaterials() {
        Console.WriteLine("This style build by oak, cherry, walnut and birch. " + "As for the upholstery, it is brocade, satin, velvet, silk and leather");
    }
}

The client main code will look more or less the same as the previous example, just change the question order. The console output will look something like this.

Nested 3 Level Abstract Factory?

I read a few articles and one pdf book about the Abstract Factory for the past few days, but I never found any example with more than 2 levels. So, I decided to add one more level, try to create something like the ‘Abstract Factory of the Abstract Factory’. Just a reminder, this ‘Nested Abstract Factory’ is just some fun experiment by myself to test my understanding of the factory, please let me know if my approach is wrong or if there is a better way to do it.

I still take this furniture factory as an example, but I will add one more level of categorization called “Marketing”. That means for our furniture products, it either be Art category, or fall into commercial category. For the Art category, we will emphasize the myth or fiction about each design, tied to the furniture itself. For the commercial category, we will display the price of the furniture. (I know this might not be a good example, but just for the sake of the demo please bear with my dummy example)

For simplicity (pronounced: lazy to code more repeated classes), I reduce the design and furniture to 2, then we will have 8 different products, instead of 18 (3 x 3 x 2)

The UML class looks like this:

Again, sorry for my poor drawing. First, there are Contemporary and Scandinavian Factories, both factories will create their own Art and Commercial Factory. It is like ‘factory creates another factory’, and finally both the Art and Commercial factory will create their own furniture, will the properties be stacked. For example, if a Contemporary Factory creates an Art Factory, and an Art Factory finally creates a Chair, so the chair will have properties of their parent and grandparent, become a Contemporary Art Chair.

For a better understanding of my design, let’s have a walkthrough of my code.

public interface IFurniture {
    void FurnitureFunction();
    void FurnitureStyle();
}
public interface IArtFurniture: IFurniture {
    void FictionOrMythStory();
}
public interface ICommercialFurniture: IFurniture {
    void Price();
}

First is the Interface, IFurniture is like the previous example, 2 methods to show furniture function and design style. And since we have 2 different marketing categories, and each have different methods, so I split it into two:

IArtFurniture with its own FictionOrMythStory() method, and ICommercialFurniture with its own Price() method. Our concrete product later will implement multiple interfaces.

public interface IFurnitureFactory {
    IFurniture CreateChair();
    IFurniture CreateDiningTable();
}
public interface IDesignFactory {
    IFurnitureFactory GetMarketingFactory(string marketingFactoryType);
}

IFurnitureFactory to standardize create chair and dining table function, IDesignFactory interface contains function to get marketing factory (Art or Commercial)

public class ContemporaryFactory: IDesignFactory {
    public IFurnitureFactory GetMarketingFactory(string marketingFactoryType) {
        switch (marketingFactoryType) {
            case nameof(ArtFactory):
                return new ArtFactory(nameof(ContemporaryFactory));
            case nameof(CommercialFactory):
                return new CommercialFactory(nameof(ContemporaryFactory));
            default:
                return null;
        }
    }
}

ContemporaryFactory class, this class will create the factory for Art or Commercial, based on the value passed in. Art of Commercial factory created by this class, will stack will properties of Contemporary as well. (Same thing happen for ScandinavianFactory class)

public class ArtFactory: IFurnitureFactory {
    private readonly string DesignName;
    public ArtFactory(string designName) {
        DesignName = designName;
    }
    public IFurniture CreateChair() {
        switch (DesignName) {
            case nameof(ScandinavianFactory):
                return new ScandinavianArtChair();
            case nameof(ContemporaryFactory):
                return new ContemporaryArtChair();
            default:
                return null;
        }
    }
    public IFurniture CreateDiningTable() {
        switch (DesignName) {
            case nameof(ScandinavianFactory):
                return new ScandinavianArtDiningTable();
            case nameof(ContemporaryFactory):
                return new ContemporaryArtDiningTable();
            default:
                return null;
        }
    }
}

ArtFactory class, this class will create a chair or a dining table based on input. Same thing happens for CommercialFactory.

do {
    Console.WriteLine("Please select your desired design style: [1]Contemporary, [2]Scandinavian");
    int.TryParse(Console.ReadLine(), out design);
} while (design <= 0 || design > 2);
switch (design) {
    case 1:
        Console.WriteLine("Seems like you prefer Contemporary design!");
        designFactory = new ContemporaryFactory();
        break;
    case 2:
        Console.WriteLine("Seems like you prefer Scandinavian design!");
        designFactory = new ScandinavianFactory();
        break;
    default:
        designFactory = null;
        break;
}
do {
    Console.WriteLine("Now, please select your preference type : [1]Art, [2]Commercial");
    int.TryParse(Console.ReadLine(), out marketing);
} while (marketing <= 0 || marketing > 2);
switch (marketing) {
    case 1:
        Console.WriteLine("Cool! Seems like you are an artistic person!");
        furnitureFactory = designFactory.GetMarketingFactory(nameof(ArtFactory));
        break;
    case 2:
        Console.WriteLine("Cool! Seems like you are fond with commercial world!");
        furnitureFactory = designFactory.GetMarketingFactory(nameof(CommercialFactory));
        break;
    default:
        furnitureFactory = null;
        break;
}
do {
    Console.WriteLine("Finally, please select your desired furniture: [1]Chair, [2]Dining Table");
    int.TryParse(Console.ReadLine(), out furniture);
} while (furniture <= 0 || furniture > 2);
switch (furniture) {
    case 1:
        Console.WriteLine("Terrific choice! We sell the best chair in the town!");
        product = furnitureFactory.CreateChair();
        break;
    case 2:
        Console.WriteLine("Terrific choice! We sell the best dining table in the town!");
        product = furnitureFactory.CreateDiningTable();
        break;
    default:
        product = null;
        break;
}

Main program, 3 switch statements to get 3 different things before creating the furniture. Logic is pretty similar to the previous example, but just an extra one more level.

The console program will show something like this,

Conclusion

Abstract Factory is one of the popular design patterns. I hope you enjoy my writing and can have a better understanding of this pattern. Again, please feel free to let me know if I did something wrong in this article.

Full source code of my project can be downloaded via Github.