Understanding the Factory Method Design Pattern in C#

 

The Factory Method design pattern is a creational pattern used to define an interface for creating objects, but allows subclasses to alter the type of objects that will be created. It encapsulates object creation, promoting flexibility and maintainability by decoupling the code that uses the objects from the code that creates them.

Understanding the Builder Design Pattern in C#

In this blog, we'll explore the Factory Method pattern, provide a comparison with a non-pattern approach, demonstrate its implementation in C#, and discuss its benefits and drawbacks. We'll also explain why other design patterns might not be suitable and guide you on identifying use cases for the Factory Method pattern.

Example Scenario: Creating Different Types of Documents

Consider a scenario where you need to create different types of Document objects, such as WordDocument and PDFDocument. The Factory Method pattern helps encapsulate the creation logic, allowing you to easily manage and extend different types of documents.

Non-Pattern Approach: Direct Creation

Without using the Factory Method pattern, you might directly instantiate objects, which can lead to tight coupling between the client code and the object creation logic.

using System;

namespace WithoutFactoryMethodPattern
{
    // Product interface
    public interface IDocument
    {
        void Print();
    }

    // Concrete product classes
    public class WordDocument : IDocument
    {
        public void Print()
        {
            Console.WriteLine("Printing Word Document...");
        }
    }

    public class PDFDocument : IDocument
    {
        public void Print()
        {
            Console.WriteLine("Printing PDF Document...");
        }
    }

    // Client code with direct object creation
    class Program
    {
        static void Main(string[] args)
        {
            IDocument document;

            // Directly creating a Word document
            document = new WordDocument();
            document.Print();

            // Directly creating a PDF document
            document = new PDFDocument();
            document.Print();
        }
    }
}

Problems in the Non-Pattern Approach

1. Tight Coupling: The client code is tightly coupled with the specific classes of the objects it creates.
2. Lack of Flexibility: Adding new types of documents requires changes in the client code, leading to potential modifications in multiple places.
3. Code Duplication: Different parts of the code may duplicate the object creation logic.

How the Factory Method Pattern Solves These Problems

The Factory Method pattern encapsulates the creation of objects in a creator class, allowing subclasses to decide which class to instantiate. This provides greater flexibility and reduces the coupling between client code and specific classes.

using System;

namespace FactoryMethodPattern
{
    // Product interface
    public interface IDocument
    {
        void Print();
    }

    // Concrete product classes
    public class WordDocument : IDocument
    {
        public void Print()
        {
            Console.WriteLine("Printing Word Document...");
        }
    }

    public class PDFDocument : IDocument
    {
        public void Print()
        {
            Console.WriteLine("Printing PDF Document...");
        }
    }

    // Creator class
    public abstract class DocumentCreator
    {
        // Factory Method
        public abstract IDocument CreateDocument();

        // Other methods
        public void PrintDocument()
        {
            IDocument document = CreateDocument();
            document.Print();
        }
    }

    // Concrete creators
    public class WordDocumentCreator : DocumentCreator
    {
        public override IDocument CreateDocument()
        {
            return new WordDocument();
        }
    }

    public class PDFDocumentCreator : DocumentCreator
    {
        public override IDocument CreateDocument()
        {
            return new PDFDocument();
        }
    }

    // Client code
    class Program
    {
        static void Main(string[] args)
        {
            DocumentCreator creator;

            // Creating and printing a Word document
            creator = new WordDocumentCreator();
            creator.PrintDocument();

            // Creating and printing a PDF document
            creator = new PDFDocumentCreator();
            creator.PrintDocument();
        }
    }
}

Benefits of the Factory Method Pattern

1. Encapsulation of Object Creation: Encapsulates the creation logic, promoting a clean separation between object creation and usage.
2. Flexibility: Allows the creation of different types of objects without modifying the client code.
3. Extensibility: Facilitates adding new types of objects with minimal changes to existing code.

Drawbacks of the Factory Method Pattern

1. Increased Complexity: Introduces additional classes and interfaces, which can add complexity to the codebase.
2. Overhead: For simpler object creation scenarios, the Factory Method pattern might introduce unnecessary overhead.

Why Can't We Use Other Design Patterns Instead?

• Abstract Factory Pattern: Focuses on creating families of related objects rather than managing individual object creation.
• Builder Pattern: Deals with constructing complex objects step-by-step rather than encapsulating the creation process.
• Prototype Pattern: Used for cloning objects rather than creating new instances.

Steps to Identify Use Cases for the Factory Method Pattern

1. Object Creation Variability: Use the Factory Method pattern when you need to create objects that can vary based on subclasses or configurations.
2. Encapsulation Requirement: When you want to encapsulate the creation logic and avoid exposing instantiation details to the client.
3. Extensibility: If you need to easily add new types of objects without modifying existing code, the Factory Method pattern is suitable.

The Factory Method design pattern is a robust solution for managing object creation in a flexible and encapsulated manner. It helps reduce coupling, promotes code maintainability, and facilitates the easy addition of new types of objects. While it introduces some complexity, its advantages in managing object creation make it an essential pattern in software design.