Factory Method Design Pattern in C#
Tags: csharp, designpatterns, factorydesignpattern
Published: 2024-02-24 13:19:05




![Factory Method Design Pattern](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wqblrgvazycj7e6hhj0n.jpg)
**Introduction**

The Factory Method Design Pattern is a creational design pattern that allows us to create objects without exposing the creation logic to the client. It provides a way to create objects based on input parameters and returns them using a common interface.


**Real-Time Example**
Suppose we’re building an application to display Credit Card Details. We have three credit card classes: MoneyBack, Titanium, and Platinum, all of which are subclasses of the CreditCard superclass (or super interface). Each credit card class implements methods like GetCardType, GetCreditLimit, and GetAnnualCharge.

Our task is to ask the user to select a credit card type. Based on their choice, we need to display relevant information about the selected credit card.

**Example Without Using the Factory Pattern**
Let’s first see how we might approach this without using the Factory Design Pattern:

```
// Without Factory Pattern
class Program
{
    static void Main()
    {
        // User selects a credit card type (e.g., "MoneyBack")
        string userChoice = GetUserInput();

        // Create an instance based on user choice
        CreditCard card;
        if (userChoice == "MoneyBack")
            card = new MoneyBack();
        else if (userChoice == "Titanium")
            card = new Titanium();
        else if (userChoice == "Platinum")
            card = new Platinum();
        else
            throw new ArgumentException("Invalid choice");

        // Display credit card details
        Console.WriteLine($"Card Type: {card.GetCardType()}");
        Console.WriteLine($"Credit Limit: {card.GetCreditLimit()}");
        Console.WriteLine($"Annual Charge: {card.GetAnnualCharge()}");
    }

    // Other methods...
}

```
**Problems Without Factory Pattern**
Tight Coupling: The client code is tightly coupled to specific credit card classes.
Maintenance Challenges: Adding new credit card types requires modifying the client code.
Testing Complexity: Unit testing becomes difficult due to direct dependencies on concrete classes.

**Implementing the Factory Design Pattern**
Now let’s use the Factory Design Pattern to address these issues:

```
// With Factory Pattern
class Program
{
    static void Main()
    {
        // User selects a credit card type (e.g., "MoneyBack")
        string userChoice = GetUserInput();

        // Create a credit card factory
        CreditCardFactory factory = new CreditCardFactory();

        // Get the appropriate credit card object
        CreditCard card = factory.CreateCreditCard(userChoice);

        // Display credit card details
        Console.WriteLine($"Card Type: {card.GetCardType()}");
        Console.WriteLine($"Credit Limit: {card.GetCreditLimit()}");
        Console.WriteLine($"Annual Charge: {card.GetAnnualCharge()}");
    }

    // Other methods...
}

// Factory class
class CreditCardFactory
{
    public CreditCard CreateCreditCard(string type)
    {
        switch (type)
        {
            case "MoneyBack":
                return new MoneyBack();
            case "Titanium":
                return new Titanium();
            case "Platinum":
                return new Platinum();
            default:
                throw new ArgumentException("Invalid choice");
        }
    }
}

// Credit card superclass
interface CreditCard
{
    string GetCardType();
    decimal GetCreditLimit();
    decimal GetAnnualCharge();
}

// Concrete credit card classes
class MoneyBack : CreditCard { /* Implementation */ }
class Titanium : CreditCard { /* Implementation */ }
class Platinum : CreditCard { /* Implementation */ }

```

**Summary**
The Factory Design Pattern provides flexibility, separation of concerns, and better maintainability. It allows us to create objects dynamically based on input parameters, without exposing the creation logic to the client. Choose the Factory Pattern when you need to create objects with varying behavior or when you want to promote loose coupling between client code and concrete classes