Abstract Factory Pattern

The Abstract Factory Pattern and Factory Method Pattern are both creational design patterns in software design, but they serve slightly different purposes. Here is an explanation of the Abstract Factory Pattern with a C# example, and how it differs from the Factory Method Pattern. I collected examples from external Ref.

Abstract Factory Pattern

The Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. This pattern is often used when the system needs to work with multiple families of products.

• Key Characteristics:
  • Provides a way to encapsulate a group of individual factories.
  • Suitable when you have multiple families of products that are designed to work together.

C# Example of Abstract Factory Pattern

Let's consider a UI components scenario where you want to create different UI elements like Buttons and Checkboxes for Windows and MacOS systems.

Step 1: Define Abstract Product Interfaces

// Abstract Product A
public interface IButton
{
    void Render();
}

// Abstract Product B
public interface ICheckbox
{
    void Render();
}

Step 2: Create Concrete Products for Windows

public class WindowsButton : IButton
{
    public void Render()
    {
        Console.WriteLine("Rendering Windows Button");
    }
}

public class WindowsCheckbox : ICheckbox
{
    public void Render()
    {
        Console.WriteLine("Rendering Windows Checkbox");
    }
}

Step 3: Create Concrete Products for MacOS

public class MacOSButton : IButton
{
    public void Render()
    {
        Console.WriteLine("Rendering MacOS Button");
    }
}

public class MacOSCheckbox : ICheckbox
{
    public void Render()
    {
        Console.WriteLine("Rendering MacOS Checkbox");
    }
}

Step 4: Define the Abstract Factory Interface

public interface IUIFactory
{
    IButton CreateButton();
    ICheckbox CreateCheckbox();
}

Step 5: Create Concrete Factories for Windows and MacOS

public class WindowsFactory : IUIFactory
{
    public IButton CreateButton() => new WindowsButton();
    public ICheckbox CreateCheckbox() => new WindowsCheckbox();
}

public class MacOSFactory : IUIFactory
{
    public IButton CreateButton() => new MacOSButton();
    public ICheckbox CreateCheckbox() => new MacOSCheckbox();
}

Step 6: Client Code

The client interacts only with the abstract factory and abstract product interfaces.

class Program
{
    static void Main(string[] args)
    {
        IUIFactory factory;
        
        // Decide the factory at runtime
        string osType = "Windows"; // Simulated input
        if (osType == "Windows")
            factory = new WindowsFactory();
        else
            factory = new MacOSFactory();

        // Create products using the factory
        IButton button = factory.CreateButton();
        ICheckbox checkbox = factory.CreateCheckbox();

        // Render UI components
        button.Render();
        checkbox.Render();
    }
}

Output

If osType is set to Windows, the output will be:

Rendering Windows Button
Rendering Windows Checkbox

If set to MacOS, the output will be:

Rendering MacOS Button
Rendering MacOS Checkbox

Difference Between Abstract Factory and Factory Method

Aspect	Abstract Factory Pattern	Factory Method Pattern
Purpose	Creates families of related objects.	Creates a single type of product.
Hierarchy	Uses multiple factory classes to create products.	A single factory class uses methods to create products.
Products	Multiple product families are supported.	Typically one product family.
Complexity	Slightly more complex; involves multiple interfaces/factories.	Less complex; focuses on one product factory.
Example	Windows UI Factory vs MacOS UI Factory.	A single factory for creating Shapes (e.g., Circle, Square).

Factory Method Example for Comparison

Here’s a simple Factory Method example in C# for creating shapes:

Factory Method Code

// Product Interface
public interface IShape
{
    void Draw();
}

// Concrete Products
public class Circle : IShape
{
    public void Draw() => Console.WriteLine("Drawing Circle");
}

public class Square : IShape
{
    public void Draw() => Console.WriteLine("Drawing Square");
}

// Factory Method
public abstract class ShapeFactory
{
    public abstract IShape CreateShape();
}

public class CircleFactory : ShapeFactory
{
    public override IShape CreateShape() => new Circle();
}

public class SquareFactory : ShapeFactory
{
    public override IShape CreateShape() => new Square();
}

// Client Code
class Program
{
    static void Main(string[] args)
    {
        ShapeFactory factory = new CircleFactory();
        IShape shape = factory.CreateShape();
        shape.Draw(); // Output: Drawing Circle
    }
}

When to Use Which Pattern

1. Use Abstract Factory when:

   • You need to create families of related products.
   • The product families are expected to change over time.

2. Use Factory Method when:

   • You need to create objects without specifying the exact class.
   • You are dealing with a single product hierarchy.

By understanding these differences, you can choose the appropriate creational pattern based on the complexity and requirements of your system.