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

Clean Architecture: What It Is and How It Differs from Microservices

In the tech world, buzzwords like   Clean Architecture   and   Microservices   often dominate discussions about building scalable, maintainable applications. But what exactly is Clean Architecture? How does it compare to Microservices? And most importantly, is it more efficient? Let’s break it all down, from understanding the core principles of Clean Architecture to comparing it with Microservices. By the end of this blog, you’ll know when to use each and why Clean Architecture might just be the silent hero your projects need. What is Clean Architecture? Clean Architecture  is a design paradigm introduced by Robert C. Martin (Uncle Bob) in his book  Clean Architecture: A Craftsman’s Guide to Software Structure and Design . It’s an evolution of layered architecture, focusing on organizing code in a way that makes it  flexible ,  testable , and  easy to maintain . Core Principles of Clean Architecture Dependency Inversion : High-level modules s...
Post a Comment
Read more

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

20+ LINQ Concepts with .Net Code

LINQ   (Language Integrated Query) is one of the most powerful features in .NET, providing a unified syntax to query collections, databases, XML, and other data sources. Below are 20+ important LINQ concepts, their explanations, and code snippets to help you understand their usage. 1.  Where  (Filtering) The  Where()  method is used to filter a collection based on a given condition. var numbers = new List < int > { 1 , 2 , 3 , 4 , 5 , 6 } ; var evenNumbers = numbers . Where ( n => n % 2 == 0 ) . ToList ( ) ; // Output: [2, 4, 6] C# Copy 2.  Select  (Projection) The  Select()  method projects each element of a sequence into a new form, allowing transformation of data. var employees = new List < Employee > { /* ... */ } ; var employeeNames = employees . Select ( e => e . Name ) . ToList ( ) ; // Output: List of employee names C# Copy 3.  OrderBy  (Sorting in Ascending Order) The  Or...
Post a Comment
Read more