Factory Method Design Pattern in C#

Back to: Design Patterns in C# With Real-Time Examples

Factory Method Design Pattern in C# with Real-time Example

In this article, I am going to discuss the Factory Method Design Pattern in C# with Examples. Please read our previous article where we discussed the Factory Design Pattern in C# with one Real-Time Example. The Factory Method Design Pattern belongs to the Creational Design Pattern Category and is one of the most frequently used design patterns in Real-Time Applications. As part of this article, we are going to discuss the following pointers.

1. What is Factory Method Design Pattern?
2. Understanding the Factory Method Design Pattern with Real-time Example
3. Implementing the Factory Method Design Pattern in C#
4. When to use the Factory Method Design Pattern?

Note: The most important point that you need to remember is the Factory Method Design pattern is not the exact same as the simple Factory Design Pattern that we discussed in our previous article. Most people think that both are the same and thus they use the terms Factory and Factory Method interchangeably which is not right.

What is Factory Method Design Pattern?

According to the Gang of Four, the Factory Method Design Pattern States that Defines an interface for creating an object, but lets the subclasses decide which class to instantiate. The Factory method lets a class defer instantiation to subclasses.

Let us simplify the above definition. The Factory Method Design Pattern is used, when we need to create the object (i.e. an instance of the Product class) without exposing the object creation logic to the client. To achieve this, in the factory method design pattern we will create an abstract class as the Factory class which will create and return the instance of the product, but it will let the subclasses decide which class to instantiate. If this is not clear at the moment then don’t worry, I will explain this with one real-time example.

Example to Understand Factory Method Design Pattern in C#:

Let us understand the Factory Method Design Pattern with one real-time example using C#. We are going to develop an application for showing credit card information. This is the same example that we discussed in our previous article, but here instead of Factory Design Pattern, we are going to use the Factory Method Design Pattern.

Please have a look at the following image. As you can see in the below diagram, we have three credit cards i.e. MoneyBack, Titanium, and Platinum. These credit cards are nothing but our Product classes. Again these three Credit Card classes are the subclasses of the CreditCard super interface (which we can also call Abstract Product). The CreditCard super interface defines the operations (i.e. GetCardType, GetCreditLimit, and GetAnnualCharge) which need to be implemented by the subclasses (i.e. MoneyBack, Titanium, and Platinum) i.e. the Product classes.

As per the definition of the Factory Method Design Pattern, we need to create an abstract class or interface for creating the object. Please have a look at the following diagram. This is going to be our Abstract Creator Class that declares the Factory Method i.e. CreateProduct() which will return an object of type Product via the abstract product type i.e. CreditCard. The CreditCardFactory Creator class declares the factory method i.e. MakeProduct() that is going to return an object of a Product class. The CreditCardFactory subclasses usually provide the implementation of the MakeProduct method.

As you can see, the above abstract class (i.e. CreditCardFactory) contains two methods, one abstract method i.e. MakeProduct() which is going to be our Factory method, and one concrete method i.e. CreateProduct(). The CreateProduct() method internally calls the MakeProduct() method of the subclass which will create the product instance and return that instance.

Please have a look at the following diagram. As we have three credit cards (i.e. MoneyBack, Platinum, and Titanium), so here we created three subclasses (i.e. PlatinumFactory, TitaniumFactory, and MoneyBackFactory) by implementing the Abstract CreditCradFactory class and providing implementation to the MakeProduct abstract method. This method is going to return the actual product object i.e. (MoneyBack, Platinum, and Titanium) via the product interface type i.e. CreditCard.

Now let’s see how the client is going to consume the above CreditCardFactory to create an object. Please have a look at the following diagram. The client code works with an instance of a concrete creator i.e. the classes which implement the CreditCardFactory abstract class. The CreateProduct method will return the actual product object via the abstract Product interface type i.e. Creditcard.

As shown in the above image, the client wants to create a Platinum object. In order to do so, the clients call the CreateProduct method on the PlatinumFactory instance which will return a concrete Platinum object via the CreditCard type. Similarly, if the client wants to create a Titanium object, then the client needs to call the CreateProduct method on the Titanium Factory instance which will return a concrete Titanium object.

Implementing the Factory Method Design Pattern in C#:

Now, let us proceed and implement the example step by step by using the Factory Method Design Pattern in C#.

Step 1: Creating Product Interface (CreditCard)

Create a class file with the name CreditCard.cs and then copy and paste the following code into it. This is going to be our Product interface which will provide the signature of the common functionalities which should be implemented by the concrete product classes.

namespace FactoryMethodDesignPattern
{
    // The CreditCard interface declares the operations that all 
    // concrete products must implement.
    public interface CreditCard
    {
        string GetCardType();
        int GetCreditLimit();
        int GetAnnualCharge();
    }
}

Step 2: Creating Concrete Products (MoneyBack, Titanium, and Platinum)

This is a class implementing the Product interface (CreditCard) and providing implementation to the interface methods. As we have three types of Credit cards in our example, so we are going to create three classes (MoneyBack, Titanium, and Platinum) by implementing the CreditCard interface.

MoneyBack.cs

Create a class file with the name MoneyBack.cs and then copy and paste the following code into it.

namespace FactoryMethodDesignPattern
{
    // MoneyBack Product provides implementations of the CreditCard interface methods.
    public class MoneyBack : CreditCard
    {
        public string GetCardType()
        {
            return "MoneyBack";
        }
        public int GetCreditLimit()
        {
            return 15000;
        }
        public int GetAnnualCharge()
        {
            return 500;
        }
    }
}

Titanium.cs:

Create a class file with the name Titanium.cs and then copy and paste the following code into it.

namespace FactoryMethodDesignPattern
{
    //Titanium Product provides implementations of the CreditCard interface methods.
    public class Titanium : CreditCard
    {
        public string GetCardType()
        {
            return "Titanium Edge";
        }
        public int GetCreditLimit()
        {
            return 25000;
        }
        public int GetAnnualCharge()
        {
            return 1500;
        }
    }
}

Platinum.cs:

Create a class file with the name Platinum.cs and then copy and paste the following code into it.

namespace FactoryMethodDesignPattern
{
    //Platinum Product provides implementations of the CreditCard interface methods.
    public class Platinum : CreditCard
    {
        public string GetCardType()
        {
            return "Platinum Plus";
        }
        public int GetCreditLimit()
        {
            return 35000;
        }
        public int GetAnnualCharge()
        {
            return 2000;
        }
    }
}

Step 3: Creating Abstract Creator (CreditCardFactory)

The Abstract Creator declares the factory method, which returns an object of type Product. As per the definition, we need to create an abstract class or interface for creating the object. So, let us create an abstract class that will be our factory class with a publicly exposed method. That method is nothing but the factory method which will return the instance of the product. So create a class file with the name CreditCardFactory.cs and then copy and paste the following code in it. The following class code is self-explained, so please go through the comment lines for a better understanding.

namespace FactoryMethodDesignPattern
{
    // The CreditCardFactory Creator class declares the factory method 
    // that is going to return an object of a Product class. 
    // The CreditCardFactory subclasses usually provide the implementation of the MakeProduct method.
    public abstract class CreditCardFactory
    {
        protected abstract CreditCard MakeProduct();

        // Also note that The Creator's primary responsibility is not creating products. 
        // Usually, it contains some core business logic that relies on Product objects, returned by the factory method. 
        public CreditCard CreateProduct()
        {
            //Call the MakeProduct which will create and return the appropriate object 
            CreditCard creditCard = this.MakeProduct();
            //Return the Object to the Client
            return creditCard;
        }
    }
}

We created the above abstract class with one abstract method i.e. MakeProduct() and one concrete method i.e. CreateProduct(). The CreateProduct() method internally calls the MakeProduct() method of the subclass which will create the product instance and return that instance. The MakeProduct() is going to be implemented by the concrete creator classes i.e. the sub-classes of the abstract creator class i.e. CreditCardFactory.

Step 4: Creating Concrete Creator (PlatinumFactory, MoneyBackFactory, and TitaniumFactory)

The Concrete Creator class implements the Abstract Creator class and overrides the factory method. The override Factory Method is going to return an instance of a Concrete Product via the base Product interface. As we have three types of Credit Cards, we are going to create three Concrete Creator classes i.e. PlatinumFactory, MoneyBackFactory, and TitaniumFactory which will implement the abstract Creator Class i.e. CreditCardFactory class.

PlatinumFactory Concrete Creator

So, create a class file with the name PlatinumFactory.cs and then copy and paste the following code into it. The following code is self-explained, so please go through the comment lines for a better understanding.

namespace FactoryMethodDesignPattern
{
    // PlatinumFactory Concrete Creators override the factory MakeProduct method
    // to create and return the Platinum Product
    public class PlatinumFactory : CreditCardFactory
    {
        // The signature of the method uses the abstract product CreditCard type,
        // Even though the concrete Platinum product is returned from the method.
        // This way the Abstract Creator CreditCardFactory can stay independent of concrete product classes.
        protected override CreditCard MakeProduct()
        {
            CreditCard product = new Platinum();
            return product;
        }
    }
}

MoneyBackFactory Concrete Creator

So, create a class file with the name MoneyBackFactory.cs and then copy and paste the following code into it. The following code is self-explained, so please go through the comment lines for a better understanding.

namespace FactoryMethodDesignPattern
{
    // MoneyBackFactory Concrete Creators override the factory MakeProduct method
    // to create and return the MoneyBack Product
    public class MoneyBackFactory : CreditCardFactory
    {
        // The signature of the method still uses the abstract product CreditCard type
        // Even though the concrete MoneyBack product is actually returned from the method.
        // This way the Creator can stay independent of concrete product classes.
        protected override CreditCard MakeProduct()
        {
            CreditCard product = new MoneyBack();
            return product;
        }
    }
}

TitaniumFactory Concrete Creator

So, create a class file with the name TitaniumFactory.cs and then copy and paste the following code into it. The following code is self-explained, so please go through the comment lines for a better understanding.

namespace FactoryMethodDesignPattern
{
    // TitaniumFactory Concrete Creators override the factory MakeProduct method
    // to create and return the Platinum Product
    public class TitaniumFactory : CreditCardFactory
    {
        // The signature of the method uses the abstract product CreditCard type,
        // Even though the concrete Titanium product is returned from the method.
        // This way the Abstract Creator CreditCardFactory can stay independent of concrete product classes.
        protected override CreditCard MakeProduct()
        {
            CreditCard product = new Titanium();
            return product;
        }
    }
}

As you can see the above three classes implement the MakeProduct method of the CreditCardFactory class. That’s it. We are done with our implementation. Let’s compare the Gang of Four Definition with our example.

According to Gang of Four, we need to define an interface or abstract class for creating an object. In our example, it is an abstract class i.e. CreditCardFactory class. The second part of the definition says that let the subclasses decide which class to instantiate. In our example, the subclasses are PlatinumFactory, MoneyBackFactory, and TitaniumFactory. So these subclasses will decide which class to instantiate, for example, MoneyBack, Titanium, and Platinum.

Step 5: Consuming the Factory Method in the Client Code:

The client code works with an instance of a concrete creator i.e. we need to create an instance of either PlatinumFactory, MoneyBackFactory, or TitaniumFactory. Then on the concrete creator instance, we need to call the CreateProduct method which will return the actual product instance via the product interface i.e. CreditCard type.

If you want to create an instance of the Platinum CreditCard then call the CreateProduct method on the PlatinumFactory instance, similarly, if you want the instance of Titanium CreditCard, then call the CreateProduct method of the TitaniumFactory instance. So, modify the Main method of the Program class as follows.

using System;
namespace FactoryMethodDesignPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            // The client code works with an instance of a concrete creator
            // The CreateProduct will return the actual product instance via the product interface

            //PlatinumFactory CreateProduct method will return an instance of Platinum Product via the CreditCard interface
            CreditCard creditCard = new PlatinumFactory().CreateProduct();
            if (creditCard != null)
            {
                Console.WriteLine("Card Type : " + creditCard.GetCardType());
                Console.WriteLine("Credit Limit : " + creditCard.GetCreditLimit());
                Console.WriteLine("Annual Charge :" + creditCard.GetAnnualCharge());
            }
            else
            {
                Console.Write("Invalid Card Type");
            }
            Console.WriteLine("--------------");
            //MoneyBackFactory CreateProduct method will return an instance of Platinum Product via the CreditCard interface
            creditCard = new MoneyBackFactory().CreateProduct();
            if (creditCard != null)
            {
                Console.WriteLine("Card Type : " + creditCard.GetCardType());
                Console.WriteLine("Credit Limit : " + creditCard.GetCreditLimit());
                Console.WriteLine("Annual Charge :" + creditCard.GetAnnualCharge());
            }
            else
            {
                Console.Write("Invalid Card Type");
            }
            Console.ReadLine();
        }
    }
}

When we run the application, it displays the output as expected as shown in the below image.

Factory Method Design Pattern UML (Class) Diagram:

Once we understand how to implement the Factory Method Design Pattern in C#, let us try to understand the UML (Unified Modeling Language) or Class diagram of the Factory Method Design Pattern. For a better understanding, please have a look at the following diagram which shows the different components of the Factory Method Design Pattern. Here, I am comparing the Factory Method Design Pattern UML diagram with our CreditCard example, so that you can easily understand the different components of the Factory Method Design Pattern.

Let us understand each component of the Factory Method Design Pattern:

1. Product: This is an interface for creating objects. Here, we need to define the Opeartions a Product should have. In our example, it is the CreditCard interface.
2. Concrete Product: This is a class that implements the Product interface. In our example, MoneyBack, Titanium, and Platinum classes are the Concrete Products. These classes implement the Product interface i.e. CreditCard.
3. Abstract Creator: This is an abstract class and declares the factory method, which returns an object of type Product. In our example, it is the CreditCardFactory abstract class and this class has the CreateProduct Factory method which will create and return an instance of the actual product. Internally, this CreateProduct method will call the subclass MakeProduct method which will actually create and return the appropriate product instance.
4. Concrete Creator: These are the classes that implement the Abstract Creator class and override the factory method to return an instance of a Concrete Product.

In the next article, I am going to discuss the Abstract Factory Design Pattern in C# with Examples. In this article, I try to explain the Factory Method Design Pattern in C# step by step with an example. I hope this article will help you with your needs. I would like to have your feedback. Please post your feedback, question, or comments about this Factory Method Design Pattern in C# with Examples article.