Skip to main content

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.

Labels:

Comments

Post a Comment

Popular posts from this blog

C# : How can we access private method outside class

Introduction In object-oriented programming, encapsulation is a fundamental principle that restricts direct access to the internal implementation details of a class. Private methods, being part of this internal implementation, are designed to be accessible only within the confines of the class they belong to. However, there might be scenarios where you need to access a private method from outside the class. In this blog post, we'll explore several techniques to achieve this in C#. 1. Reflection: A Powerful Yet Delicate Approach Reflection is a mechanism in C# that allows inspecting and interacting with metadata about types, fields, properties, and methods. While it provides a way to access private methods, it should be used cautiously due to its potential impact on maintainability and performance. using System ; using System . Reflection ; public class MyClass { private void PrivateMethod ( ) { Console . WriteLine ( "This is a private method."
Post a Comment
Read more

C# : Understanding Types of Classes

In C#, classes serve as the building blocks of object-oriented programming, providing a blueprint for creating objects. Understanding the types of classes and their applications is crucial for designing robust and maintainable software. In this blog, we’ll delve into various types of classes in C#, accompanied by real-world scenarios and code snippets for a practical understanding. 1. Regular (Instance) Classes Definition: Regular classes are the most common type and are used to create instances or objects. They can contain fields, properties, methods, and other members. Example Scenario: A Person class representing individual persons with properties like Name and Age. public class Person { public string Name { get ; set ; } public int Age { get ; set ; } } 2. Static Classes Definition: A static class cannot be instantiated and can only contain static members (methods, properties, fields). It’s often used for utility functions. Example Scenario: A MathUtility cla
Post a Comment
Read more

C# : 12.0 : Primary constructor

Introduction In C# 12.0, the introduction of the "Primary Constructor" simplifies the constructor declaration process. Before delving into this concept, let's revisit constructors. A constructor is a special method in a class with the same name as the class itself. It's possible to have multiple constructors through a technique called constructor overloading.  By default, if no constructors are explicitly defined, the C# compiler generates a default constructor for each class. Now, in C# 12.0, the term "Primary Constructor" refers to a more streamlined way of declaring constructors. This feature enhances the clarity and conciseness of constructor declarations in C# code. Lets see an simple example code, which will be known to everyone. public class Version { private int _value ; private string _name ; public Version ( int value , string name ) { _name = name ; _value = value ; } public string Ve
Post a Comment
Read more