Exploring Abstract Factory in C#

Introduction to the Abstract Factory Pattern

Welcome back! You’ve already explored the power of the Factory Method Pattern and how it promotes flexibility in your code design. Today, we are moving a step further by diving into the Abstract Factory Pattern . This pattern will help you create families of related objects without specifying their concrete classes.

Understanding the Abstract Factory Pattern

The Abstract Factory Pattern is a creational design pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes . This pattern is particularly useful when you need to ensure that a set of related objects is created together, maintaining consistency across your application.

Scenario Example

To understand this better, let's consider a scenario where you are developing a graphical user interface (GUI) toolkit . Your toolkit should support multiple operating systems, such as: Windows Mac Each OS has its own set of UI components, like buttons and checkboxes . Using the Abstract Factory Pattern, you can define interfaces for these components and create their concrete implementations for each OS.

Step 1: Defining Abstract Product Interfaces

Let's learn how to use the Abstract Factory Pattern . First, we will define abstract product interfaces for the UI components. These interfaces will ensure that each concrete product implements the necessary behavior. Below is the basic definition of abstract products for buttons and checkboxes: C# // Abstract Product A abstract class Button {public abstract void Paint();} Here, Button is an abstract class defining the Paint method to be implemented by all concrete buttons. This ensures that any button created by our factories adheres to a common interface. C# // Abstract Product B abstract class Checkbox {public abstract void Paint();} Similarly, the Checkbox class sets the contract for all checkbox components, making sure they implement the Paint method. By defining these abstract products, we ensure a consistent interface across different operating systems.

Step 2: Creating Concrete Product Implementations

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

// Concrete Product A1
class WinButton : Button
{
    public override void Paint() => Console.WriteLine("Rendering a button in a Windows style.");
}

// Concrete Product A2
class MacButton : Button
{
    public override void Paint() => Console.WriteLine("Rendering a button in a Mac style.");
}

// Concrete Product B1
class WinCheckbox : Checkbox
{
    public override void Paint() => Console.WriteLine("Rendering a checkbox in a Windows style.");
}

// Concrete Product B2
class MacCheckbox : Checkbox
{
    public override void Paint() => Console.WriteLine("Rendering a checkbox in a Mac style.");
}

// Abstract Factory
abstract class GUIFactory
{
    public abstract Button CreateButton();
    public abstract Checkbox CreateCheckbox();
}

// Concrete Factory 1
class WinFactory : GUIFactory
{
    public override Button CreateButton() => new WinButton();
    public override Checkbox CreateCheckbox() => new WinCheckbox();
}

// Concrete Factory 2
class MacFactory : GUIFactory
{
    public override Button CreateButton() => new MacButton();
    public override Checkbox CreateCheckbox() => new MacCheckbox();
}

// Client code
class Application
{
    private GUIFactory factory;
    private Button button;
    private Checkbox checkbox;

    public Application(GUIFactory f)
    {
        // Initialization
        factory = f;
        button = factory.CreateButton();
        checkbox = factory.CreateCheckbox();
    }
    
    public void Paint()
    {
        // Render components
        button.Paint();
        checkbox.Paint();
    }
}

class Program
{
    static void Main(string[] args)
    {
        GUIFactory? factory = null;
        string osType = "Windows"; // You can change to "Mac" to see Mac UI

        // Determine which factory to use
        if (osType == "Windows")
        {
            factory = new WinFactory();
        }
        else if (osType == "Mac")
        {
            factory = new MacFactory();
        }

        if (factory != null)
        {
            // Create and paint the GUI
            Application app = new Application(factory);
            // Call its Paint method
            app.Paint();
            // Output (Windows):
            // Rendering a button in a Windows style.
            // Rendering a checkbox in a Windows style.
        }
        else
        {
            Console.WriteLine("Unknown OS type.");
        }
    }
}

Introduction to the Abstract Factory Pattern

Understanding the Abstract Factory Pattern

Scenario Example

Step 1: Defining Abstract Product Interfaces

Step 2: Creating Concrete Product Implementations

Join the 1M+ learners on CodeSignal

Step 3: Defining the Abstract Factory Interface

Step 4: Creating Concrete Factory Implementations

Step 5: Implementing the Client Code: Application Class

Step 6: Putting it All Together

Abstract Factory vs Factory Method: A Comparison

Conclusion