Factory Method Design Pattern In C#

Introduction

Design patterns are all about reusable solutions to common problems in software designing that occur in real-world application development.

The 23 Gang of Four (GoF) patterns are generally considered the foundation for all other patterns. They are broadly categorized into three groups, i.e., Creational, Structural, and Behavioral. Factory method pattern falls under Creational Pattern of Gang of Four (GoF) Design Patterns.

Background

Before learning Factory Method Pattern, I just want to share a little about "Gang of Four (GoF)" to which the Factory Method pattern belongs.

Who are the Gang of Four?

The Gang of Four are the authors of the book, "Design Patterns: Elements of Reusable Object-Oriented Software". This important book describes various development techniques and pitfalls in addition to providing 23 object-oriented programming design patterns. The four authors are Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides.

Now, let's move on to the Factory Method design pattern:

Factory Method is a Design Pattern which defines an interface for creating an object, but lets the classes that implement the interface decide which class to instantiate. Factory Pattern lets a class postpone instantiation to sub-classes.

The factory pattern is used to replace class constructors, abstracting the process of object generation so that the type of the object instantiated can be determined at run-time.

In this article I have tried to cover the Concept of Factory Method design pattern and the way of implementing Factory Method design pattern.

Where to Use It?

It is tedious when the client needs to specify the class name while creating the objects. So, to resolve this problem, we can use Factory Method design pattern. It provides the client a simple way to create the object.

UML Class Diagram

The classes and objects participating in the above UML class diagram are as follows:

1. Product
   This defines the interface of objects the factory method creates

2. ConcreteProduct
   This is a class which implements the Product interface.

3. Creator
   This is an abstract class and declares the factory method, which returns an object of type Product.
   

   This may also define a default implementation of the factory method that returns a default ConcreteProduct object.

   This may call the factory method to create a Product object.

4. ConcreteCreator
   This is a class which implements the Creator class and overrides the factory method to return an instance of a ConcreteProduct.

Now let’s understand this with a real world example

Assume you have three different cards which are considered here as classes MoneyBack, Titanium and Platinum, all of them implement abstract class CreditCard. You need to instantiate one of these classes, but you don't know which of them, it depends on the user. This is perfect scenario for the Factory Method design pattern.

 

Who is what?

The classes and objects participating in the above class diagram can be identified as follows:

1. Product - CreditCard
2. ConcreteProduct- MoneyBackCreditCard, TitaniumCreditCard, PlatinumCreditCard
3. Creator- CardFactory
4. ConcreteCreator- MoneyBackCardFactory, TitaniumCardFactory, PlatinumCardFactory

Here are the code blocks for each participant

1. Product
   

   namespace FactoryMethodDesignPatternInCSharp
   {
       /// <summary>
       /// The 'Product' Abstract Class
       /// </summary>
       abstract class CreditCard
       {
           public abstract string CardType { get; }
           public abstract int CreditLimit { get; set; }
           public abstract int AnnualCharge { get; set; }
       }
   }

2. ConcreteProduct
   
   MoneyBackCreditCard
   

   using System;
   
   namespace FactoryMethodDesignPatternInCSharp
   {
       /// <summary>
       /// A 'ConcreteProduct' class
       /// </summary>
       class MoneyBackCreditCard : CreditCard
       {
           private readonly string _cardType;
           private int _creditLimit;
           private int _annualCharge;
   
           public MoneyBackCreditCard(int creditLimit, int annualCharge)
           {
               _cardType = "MoneyBack";
               _creditLimit = creditLimit;
               _annualCharge = annualCharge;
           }
   
           public override string CardType
           {
               get { return _cardType; }
           }
   
           public override int CreditLimit
           {
               get { return _creditLimit; }
               set { _creditLimit = value; }
           }
   
           public override int AnnualCharge
           {
               get { return _annualCharge; }
               set { _annualCharge = value; }
           }
       }
   }

   TitaniumCreditCard
   

   using System;
   
   namespace FactoryMethodDesignPatternInCSharp
   {
       /// <summary>
       /// A 'ConcreteProduct' class
       /// </summary>
       class TitaniumCreditCard : CreditCard
       {
           private readonly string _cardType;
           private int _creditLimit;
           private int _annualCharge;
   
           public TitaniumCreditCard(int creditLimit, int annualCharge)
           {
               _cardType = "Titanium";
               _creditLimit = creditLimit;
               _annualCharge = annualCharge;
           }
   
           public override string CardType
           {
               get { return _cardType; }
           }
   
           public override int CreditLimit
           {
               get { return _creditLimit; }
               set { _creditLimit = value; }
           }
   
           public override int AnnualCharge
           {
               get { return _annualCharge; }
               set { _annualCharge = value; }
           }
       }
   }

   PlatinumCreditCard
   

   using System;
   
   namespace FactoryMethodDesignPatternInCSharp
   {
       /// <summary>
       /// A 'ConcreteProduct' class
       /// </summary>
       class PlatinumCreditCard : CreditCard
       {
           private readonly string _cardType;
           private int _creditLimit;
           private int _annualCharge;
   
           public PlatinumCreditCard(int creditLimit, int annualCharge)
           {
               _cardType = "Platinum";
               _creditLimit = creditLimit;
               _annualCharge = annualCharge;
           }
   
           public override string CardType
           {
               get { return _cardType; }
           }
   
           public override int CreditLimit
           {
               get { return _creditLimit; }
               set { _creditLimit = value; }
           }
   
           public override int AnnualCharge
           {
               get { return _annualCharge; }
               set { _annualCharge = value; }
           }
       }
   }

3. Creator
   

   namespace FactoryMethodDesignPatternInCSharp
   {
       /// <summary>
       /// The 'Creator' Abstract Class
       /// </summary>
       abstract class CardFactory
       {
           public abstract CreditCard GetCreditCard();
       }
   }

4. ConcreteCreator
   
   MoneyBackFactory
   

   namespace FactoryMethodDesignPatternInCSharp
   {
       /// <summary>
       /// A 'ConcreteCreator' class
       /// </summary>
       class MoneyBackFactory : CardFactory
       {
           private int _creditLimit;
           private int _annualCharge;
   
           public MoneyBackFactory(int creditLimit, int annualCharge)
           {
               _creditLimit = creditLimit;
               _annualCharge = annualCharge;
           }
   
           public override CreditCard GetCreditCard()
           {
               return new MoneyBackCreditCard(_creditLimit, _annualCharge);
           }
       }
   }

TitaniumFactory 

namespace FactoryMethodDesignPatternInCSharp
{
    class TitaniumFactory: CardFactory
    {
        private int _creditLimit;
        private int _annualCharge;

        public TitaniumFactory(int creditLimit, int annualCharge)
        {
            _creditLimit = creditLimit;
            _annualCharge = annualCharge;
        }

        public override CreditCard GetCreditCard()
        {
            return new TitaniumCreditCard(_creditLimit, _annualCharge);
        }
    }
}

PlatinumFactory 

namespace FactoryMethodDesignPatternInCSharp
{
    class PlatinumFactory: CardFactory
    {
        private int _creditLimit;
        private int _annualCharge;

        public PlatinumFactory(int creditLimit, int annualCharge)
        {
            _creditLimit = creditLimit;
            _annualCharge = annualCharge;
        }

        public override CreditCard GetCreditCard()
        {
            return new PlatinumCreditCard(_creditLimit, _annualCharge);
        }
    }
}

Factory Pattern Client Demo 

using System;

namespace FactoryMethodDesignPatternInCSharp
{
    /// <summary>
    /// Factory Pattern Demo
    /// </summary>
    public class ClientApplication
    {
        static void Main()
        {
            CardFactory factory = null;
            Console.Write("Enter the card type you would like to visit: ");
            string car = Console.ReadLine();

            switch (car.ToLower())
            {
                case "moneyback":
                    factory = new MoneyBackFactory(50000, 0);
                    break;
                case "titanium":
                    factory = new TitaniumFactory(100000, 500);
                    break;
                case "platinum":
                    factory = new PlatinumFactory(500000, 1000);
                    break;
                default:
                    break;
            }

            CreditCard creditCard = factory.GetCreditCard();
            Console.WriteLine("\nYour card details are below : \n");
            Console.WriteLine("Card Type: {0}\nCredit Limit: {1}\nAnnual Charge: {2}",
                creditCard.CardType, creditCard.CreditLimit, creditCard.AnnualCharge);
            Console.ReadKey();
        }
    }
}

Output

Here, we are accepting input from the clients/users as to which class they want to instantiate.

Enter the respective card type: (MoneyBack/Titanium/Platinum)

Summary

In this article, we have covered the basic concept of Factory Method design pattern and how to implement this in real world application development. I have attached the sample code for your reference.

I hope you enjoyed this article. Please share your valuable suggestions and feedback.

Happy Coding!!!