Menu
Article Design Patterns

Exploring the Factory Method Pattern in C#: A Comprehensive Guide

Casper

Casper

• 3 min read

Introduction

The Factory Method Pattern is a creational design pattern that provides an interface for creating instances of a class, but allows subclasses to alter the type of objects that will be created. This pattern promotes loose coupling by delegating the responsibility of object instantiation to subclasses, making it a valuable tool for designing flexible and extensible systems. In this article, we will delve into the Factory Method Pattern, examining its structure, advantages, and providing practical examples in C#.

Anatomy of the Factory Method Pattern

The Factory Method Pattern involves the following key components:

  1. Product: The interface or abstract class for the objects that the factory method creates.
  2. ConcreteProduct: Concrete classes that implement the Product interface or extend the Product abstract class.
  3. Creator: An interface or abstract class that declares the factory method for creating products.
  4. ConcreteCreator: Concrete classes that implement the factory method to create specific products.

Implementation in C#

Let's explore a simple example of the Factory Method Pattern in C#. Suppose we have a scenario where different types of documents (e.g., Resume, Report) need to be created, and each document type has its own creation logic.

// Step 1: Define the Product interface or abstract class
public interface IDocument
{
    void CreateDocument();
}

// Step 2: Implement ConcreteProduct classes
public class Resume : IDocument
{
    public void CreateDocument()
    {
        Console.WriteLine("Creating a Resume document.");
    }
}

public class Report : IDocument
{
    public void CreateDocument()
    {
        Console.WriteLine("Creating a Report document.");
    }
}

// Step 3: Define the Creator interface or abstract class with the factory method
public interface IDocumentCreator
{
    IDocument CreateDocument();
}

// Step 4: Implement ConcreteCreator classes with the factory method
public class ResumeCreator : IDocumentCreator
{
    public IDocument CreateDocument()
    {
        return new Resume();
    }
}

public class ReportCreator : IDocumentCreator
{
    public IDocument CreateDocument()
    {
        return new Report();
    }
}

In this example, IDocument represents the product interface, and Resume and Report are concrete product classes. The IDocumentCreator is the creator interface with the factory method CreateDocument, and ResumeCreator and ReportCreator are concrete creator classes implementing this factory method.

Advantages of the Factory Method Pattern

1. Decoupling: The Factory Method Pattern promotes loose coupling between the client code and the specific classes being instantiated. Clients interact with the abstract creator interface and product interface, unaware of the concrete classes.

2. Extensibility: Adding new product types or variations is straightforward by introducing new concrete creator and product classes. This makes the system more extensible without modifying existing code.

3. Subclassing: Subclasses can alter the behavior of the factory method to create different types of products. This allows for customization and specialization without changing the overall structure.

4. Testing: The pattern enhances testability by allowing the use of mock or stub objects. Clients can be easily tested with different implementations of the product without changing the client code.

Real-world Examples

1. UI Frameworks

Consider a scenario where a UI framework needs to create different UI elements, such as buttons, text fields, or checkboxes. The framework can define a UIElement interface, and each UI element type (e.g., Button, TextField) can have its own creator class implementing the factory method.

public interface IUIElement
{
    void Render();
}

public class Button : IUIElement
{
    public void Render()
    {
        Console.WriteLine("Rendering a button.");
    }
}

public class TextField : IUIElement
{
    public void Render()
    {
        Console.WriteLine("Rendering a text field.");
    }
}

public interface IUIElementCreator
{
    IUIElement CreateUIElement();
}

public class ButtonCreator : IUIElementCreator
{
    public IUIElement CreateUIElement()
    {
        return new Button();
    }
}

public class TextFieldCreator : IUIElementCreator
{
    public IUIElement CreateUIElement()
    {
        return new TextField();
    }
}

2. Document Processing Framework

In a document processing framework, different document types (e.g., PDF, Word) may require specific creation logic. The framework can define a Document interface, and each document type can have its own creator class.

public interface IDocument
{
    void Export();
}

public class PdfDocument : IDocument
{
    public void Export()
    {
        Console.WriteLine("Exporting to PDF.");
    }
}

public class WordDocument : IDocument
{
    public void Export()
    {
        Console.WriteLine("Exporting to Word.");
    }
}

public interface IDocumentExporter
{
    IDocument ExportDocument();
}

public class PdfDocumentExporter : IDocumentExporter
{
    public IDocument ExportDocument()
    {
        return new PdfDocument();
    }
}

public class WordDocumentExporter : IDocumentExporter
{
    public IDocument ExportDocument()
    {
        return new WordDocument();
    }
}

Conclusion

The Factory Method Pattern is a versatile design pattern that enhances flexibility, extensibility, and maintainability in software development. By encapsulating object creation logic within a factory method, this pattern allows for easy customization and extension of the system. Through practical examples in C#, we have demonstrated how the Factory Method Pattern can be applied to real-world scenarios, providing a blueprint for creating systems that can adapt to changing requirements with minimal impact on existing code. Understanding and applying this pattern can significantly contribute to building robust, scalable, and modular software architectures.

Share