Financial Year 2023 End Sale: Get upto 40% OFF on Job-oriented Training! Offer Ending in
D
H
M
S
Get Now
Abstract Factory Design Pattern

Abstract Factory Design Pattern

23 Aug 2022
Intermediate
213K Views
6 min read
Learn via Video Course & by Doing Hands-on Labs

⭐ .NET Design Patterns Course: Design Patterns in C# Online Training

Abstract Factory Design method falls under Creational Pattern of Gang of Four (GOF) Design Patterns in .Net. It is used to create a set of related objects, or dependent objects. Internally, Abstract Factory use Factory design pattern for creating objects. It may also use Builder design pattern and prototype design pattern for creating objects. It completely depends upon your implementation for creating objects. In this article, I would like to share what is abstract factory pattern and how is it work?

What is Abstract Factory Pattern?

Abstract Factory patterns act a super-factory which creates other factories. This pattern is also called a Factory of factories. In Abstract Factory pattern an interface is responsible for creating a set of related objects, or dependent objects without specifying their concrete classes.

Abstract Factory Pattern - UML Diagram & Implementation

The UML class diagram for the implementation of the abstract factory design pattern is given below:

The classes, interfaces, and objects in the above UML class diagram are as follows:

  1. AbstractFactory

    This is an interface which is used to create abstract product

  2. ConcreteFactory

    This is a class which implements the AbstractFactory interface to create concrete products.

  3. AbstractProduct

    This is an interface which declares a type of product.

  4. ConcreteProduct

    This is a class which implements the AbstractProduct interface to create a product.

  5. Client

    This is a class which uses AbstractFactory and AbstractProduct interfaces to create a family of related objects.

C# - Implementation Code

public interface AbstractFactory
{
 AbstractProductA CreateProductA();
 
 AbstractProductB CreateProductB();
}
 
public class ConcreteFactoryA : AbstractFactory
{
 public AbstractProductA CreateProductA()
 {
 return new ProductA1();
 }
 
 public AbstractProductB CreateProductB()
 {
 return new ProductB1();
 }
}
 
public class ConcreteFactoryB : AbstractFactory
{
 public AbstractProductA CreateProductA()
 {
 return new ProductA2();
 }
 
 public AbstractProductB CreateProductB()
 {
 return new ProductB2();
 }
}
 
public interface AbstractProductA { }
 
public class ProductA1 : AbstractProductA { }
 
public class ProductA2 : AbstractProductA { }
 
public interface AbstractProductB { }
 
public class ProductB1 : AbstractProductB { }
 
public class ProductB2 : AbstractProductB { }

public class Client
{
 private AbstractProductA _productA;
 private AbstractProductB _productB;
 
 public Client(AbstractFactory factory)
 {
 _productA = factory.CreateProductA();
 _productB = factory.CreateProductB();
 }
}

Abstract Factory Pattern - Example

Who is what?

The classes, interfaces, and objects in the above class diagram can be identified as follows:

  1. VehicleFactory - AbstractFactory interface

  2. HondaFactory & HeroFactory- Concrete Factories

  3. Bike & Scooter - AbstractProduct interface

  4. Regular Bike, Sports Bike, Regular Scooter & Scooty - Concrete Products

  5. VehicleClient - Client

C# - Sample Code

/// <summary>
/// The 'AbstractFactory' interface. 
/// </summary>
interface VehicleFactory
{
 Bike GetBike(string Bike);
 Scooter GetScooter(string Scooter);
}

/// <summary>
/// The 'ConcreteFactory1' class.
/// </summary>
class HondaFactory : VehicleFactory
{
 public Bike GetBike(string Bike)
 {
 switch (Bike)
 {
 case "Sports":
 return new SportsBike();
 case "Regular":
 return new RegularBike();
 default:
 throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Bike));
 }

 }

 public Scooter GetScooter(string Scooter)
 {
 switch (Scooter)
 {
 case "Sports":
 return new Scooty();
 case "Regular":
 return new RegularScooter();
 default:
 throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Scooter));
 }

 }
}

/// <summary>
/// The 'ConcreteFactory2' class.
/// </summary>
class HeroFactory : VehicleFactory
{
 public Bike GetBike(string Bike)
 {
 switch (Bike)
 {
 case "Sports":
 return new SportsBike();
 case "Regular":
 return new RegularBike();
 default:
 throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Bike));
 }

 }

 public Scooter GetScooter(string Scooter)
 {
 switch (Scooter)
 {
 case "Sports":
 return new Scooty();
 case "Regular":
 return new RegularScooter();
 default:
 throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Scooter));
 }

 }
}

/// <summary>
/// The 'AbstractProductA' interface
/// </summary>
interface Bike
{
 string Name();
}

/// <summary>
/// The 'AbstractProductB' interface
/// </summary>
interface Scooter
{
 string Name();
}

/// <summary>
/// The 'ProductA1' class
/// </summary>
class RegularBike : Bike
{
 public string Name()
 {
 return "Regular Bike- Name";
 }
}

/// <summary>
/// The 'ProductA2' class
/// </summary>
class SportsBike : Bike
{
 public string Name()
 {
 return "Sports Bike- Name";
 }
}

/// <summary>
/// The 'ProductB1' class
/// </summary>
class RegularScooter : Scooter
{
 public string Name()
 {
 return "Regular Scooter- Name";
 }
}

/// <summary>
/// The 'ProductB2' class
/// </summary>
class Scooty : Scooter
{
 public string Name()
 {
 return "Scooty- Name";
 }
}

/// <summary>
/// The 'Client' class 
/// </summary>
class VehicleClient
{
 Bike bike;
 Scooter scooter;

 public VehicleClient(VehicleFactory factory, string type)
 {
 bike = factory.GetBike(type);
 scooter = factory.GetScooter(type);
 }

 public string GetBikeName()
 {
 return bike.Name();
 }

 public string GetScooterName()
 {
 return scooter.Name();
 }

}

/// <summary>
/// Abstract Factory Pattern Demo
/// </summary>
class Program
{
 static void Main(string[] args)
 {
 VehicleFactory honda = new HondaFactory();
 VehicleClient hondaclient = new VehicleClient(honda, "Regular");
 
 Console.WriteLine("******* Honda **********");
 Console.WriteLine(hondaclient.GetBikeName());
 Console.WriteLine(hondaclient.GetScooterName());
 
 hondaclient = new VehicleClient(honda, "Sports");
 Console.WriteLine(hondaclient.GetBikeName());
 Console.WriteLine(hondaclient.GetScooterName());
 
 VehicleFactory hero = new HeroFactory();
 VehicleClient heroclient = new VehicleClient(hero, "Regular");
 
 Console.WriteLine("******* Hero **********");
 Console.WriteLine(heroclient.GetBikeName());
 Console.WriteLine(heroclient.GetScooterName());
 
 heroclient = new VehicleClient(hero, "Sports");
 Console.WriteLine(heroclient.GetBikeName());
 Console.WriteLine(heroclient.GetScooterName());
 
 Console.ReadKey();
 }
}

Abstract Factory Pattern Demo - Output

When to use it?

  1. Create a set of related objects or dependent objects which must be used together.

  2. System should be configured to work with multiple families of products.

  3. The creation of objects should be independent of the utilizing system.

  4. Concrete classes should be decoupled from clients.

Note

  1. Internally, Abstract Factory use Factory design pattern for creating objects. But it can also use Builder design pattern and prototype design pattern for creating objects. It completely depends upon your implementation for creating objects.

  2. Abstract Factory can be used as an alternative to Facade to hide platform-specific classes.

  3. When Abstract Factory, Builder, and Prototype define a factory for creating the objects, we should consider the following points :

    1. Abstract Factory use the factory for creating objects of several classes.

    2. Builder uses the factory for creating a complex object by using simple objects and a step by step approach.

    3. Prototype use the factory for building an object by copying an existing object.

Read More Articles Related to Design Pattern
What do you think?

I hope you will enjoy the Abstract Factory Pattern while designing your software. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.

Share Article
About Author
Shailendra Chauhan (Microsoft MVP, Founder & CEO at Scholarhat by DotNetTricks)

Shailendra Chauhan is the Founder and CEO at ScholarHat by DotNetTricks which is a brand when it comes to e-Learning. He provides training and consultation over an array of technologies like Cloud, .NET, Angular, React, Node, Microservices, Containers and Mobile Apps development. He has been awarded Microsoft MVP 8th time in a row (2016-2023). He has changed many lives with his writings and unique training programs. He has a number of most sought-after books to his name which has helped job aspirants in cracking tough interviews with ease.
Accept cookies & close this