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.

Join the 1M+ learners on CodeSignal

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

Step 6: Putting it All Together

Now, let's examine the main program that drives the application. The Program class contains the Main method, which is the entry point of the application.

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.");
        }
    }
}

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.");
        }
    }
}

It determines the operating system type and selects the appropriate factory. The Application instance then uses this factory to create and paint the GUI components, showcasing how easily the application can switch between different families of products.

Introduction to the Abstract Factory Pattern

Understanding the Abstract Factory Pattern

Scenario Example

Step 1: Defining Abstract Product Interfaces

Join the 1M+ learners on CodeSignal

Step 2: Creating Concrete Product Implementations

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