Factory Method pattern in C#

Hi there! Welcome to my blog where I share my passion for C# and design patterns. Today I’m going to talk about one of the most popular and useful design patterns: the Factory Method pattern.šŸ˜Ž

What is the Factory Method pattern?

The Factory Method pattern is a creational design pattern that defines an interface for creating an object but lets subclasses decide which class to instantiate. This pattern lets a class defer instantiation to subclasses.

In other words, the Factory Method pattern allows us to create objects without exposing the creation logic to the client. Instead of using a constructor or a simple factory, we use an abstract method (or an interface) that returns an object of a specific type. The subclasses can then override this method and return different types of objects based on some criteria.

Why use the Factory Method pattern?

The Factory Method pattern is useful when we want to:

  • Decouple the creation of objects from their usage
  • Encapsulate the object creation logic and make it more flexible and extensible
  • Avoid hard-coding the class names in the client code
  • Support multiple types of objects with a common interface
  • Handle complex dependencies between objects

How to implement the Factory Method pattern in C#?

Let’s see how we can implement the Factory Method pattern in C# with a currency-related example. Suppose we have an interface called ICurrency that defines some common properties and methods for different currencies:


// The 'Product' interface
public interface ICurrency
{
    string Name { get; }
    string Symbol { get; }
    decimal ExchangeRate { get; }
    void DisplayInfo();
}


We can then create some concrete classes that implement this interface, such as USDCurrency, CADCurrency, and GBPCurrency:


// A 'ConcreteProduct' class
public class USDCurrency : ICurrency
{
    public string Name => "United States Dollar";
    public string Symbol => "$";
    public decimal ExchangeRate => 1.25m; // 1 USD = 1.25 CAD

    public void DisplayInfo()
    {
        Console.WriteLine($"The currency of USA is {Name} ({Symbol})");
        Console.WriteLine($"The exchange rate is {ExchangeRate} CAD per USD");
    }
}

// Another 'ConcreteProduct' class
public class CADCurrency : ICurrency
{
    public string Name => "Canadian Dollar";
    public string Symbol => "C$";
    public decimal ExchangeRate => 0.8m; // 1 CAD = 0.8 USD

    public void DisplayInfo()
    {
        Console.WriteLine($"The currency of Canada is {Name} ({Symbol})");
        Console.WriteLine($"The exchange rate is {ExchangeRate} USD per CAD");
    }
}

// Yet another 'ConcreteProduct' class
public class GBPCurrency : ICurrency
{
    public string Name => "British Pound Sterling";
    public string Symbol => "£";
    public decimal ExchangeRate => 1.7m; // 1 GBP = 1.7 CAD

    public void DisplayInfo()
    {
        Console.WriteLine($"The currency of UK is {Name} ({Symbol})");
        Console.WriteLine($"The exchange rate is {ExchangeRate} CAD per GBP");
    }
}


Now, instead of creating these objects directly in the client code, we can use an abstract class (or an interface) called CurrencyFactory that defines a factory method for creating ICurrency objects:


// The 'Creator' abstract class
public abstract class CurrencyFactory
{
    // The factory method that returns an ICurrency object
    public abstract ICurrency CreateCurrency();
}


We can then create some concrete subclasses that override this method and return different types of ICurrency objects based on some criteria, such as the country name:


// A 'ConcreteCreator' class
public class USACurrencyFactory : CurrencyFactory
{
    // Override the factory method to return a USDCurrency object
    public override ICurrency CreateCurrency()
    {
        return new USDCurrency();
    }
}

// Another 'ConcreteCreator' class
public class CanadaCurrencyFactory : CurrencyFactory
{
    // Override the factory method to return a CADCurrency object
    public override ICurrency CreateCurrency()
    {
        return new CADCurrency();
    }
}

// Yet another 'ConcreteCreator' class
public class UKCurrencyFactory : CurrencyFactory
{
    // Override the factory method to return a GBPCurrency object
    public override ICurrency CreateCurrency()
    {
        return new GBPCurrency();
    }
}


Finally, in the client code, we can use the CurrencyFactory class to create and use ICurrency objects without knowing their concrete types:


// The 'Client' class
class Program
{
    static void Main(string[] args)
    {
        // Create a CurrencyFactory object based on the country name
        CurrencyFactory factory = GetCurrencyFactory("USA");

        // Use the factory method to create an ICurrency object
        ICurrency currency = factory.CreateCurrency();

        // Use the ICurrency object
        currency.DisplayInfo();

        // Output:
        // The currency of USA is United States Dollar ($)
        // The exchange rate is 1.25 CAD per USD
    }

    // A helper method that returns a CurrencyFactory object based on the country name
    static CurrencyFactory GetCurrencyFactory(string country)
    {
        switch (country)
        {
            case "USA":
                return new USACurrencyFactory();
            case "Canada":
                return new CanadaCurrencyFactory();
            case "UK":
                return new UKCurrencyFactory();
            default:
                throw new ArgumentException("Invalid country");
        }
    }
}


As you can see, the Factory Method pattern allows us to create and use different types of ICurrency objects without exposing the creation logic to the client. We can also easily add more types of currencies by creating new subclasses of CurrencyFactory and ICurrency.šŸ‘

Conclusion

The Factory Method pattern is a powerful design pattern that helps us create objects without exposing the creation logic to the client. It also makes our code more flexible and extensible by decoupling the object creation from their usage.šŸ˜Š

If you want to learn more about the Factory Method pattern and other design patterns in C#, I recommend you check out these resources:

I hope you enjoyed this article and learned something new. Please leave a comment below and share your thoughts and feedback. Also, don’t forget to subscribe to my blog for more awesome articles on C# and design patterns. 


You can find the code examples here: source code


See you next time!šŸ˜„

Comments

Post a Comment

Popular posts from this blog

Which GOF patterns are good for C#?

Hello, C# fans! šŸ˜Š In this article, I will answer a common question that many C# developers have: which GOF patterns are good for C#? šŸ¤” GOF patterns are the 23 design patterns that were described in the book “ Design Patterns: Elements of Reusable Object-Oriented Software ” by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. They are also known as the Gang of Four (GoF) patterns. They are divided into three categories: creational, structural, and behavioral. šŸ“š These patterns provide solutions to common software design problems that you may encounter in your projects. They help you write code that is more reusable, flexible, maintainable, and elegant. šŸ˜ But not all GOF patterns are equally useful or applicable in C#. Some of them are more relevant and popular than others. Some are already supported by the language features or the .NET framework. Some of them may be outdated or replaced by newer patterns. šŸ˜® So, which GOF patterns are good for C#?  Creational patterns...
Read more

Angular on a regular SharePoint page (part 2)

Image
In my  previous article , we have added an empty angular element to the SharePoint page.  And now we are ready to move forward and add some functionality to our elements. Before we begin      First of all, let's create in SharePoint Announcements list with the name "Announcements" and add a couple of items with some text. We will access data in our list via the SharePoint REST API, calling "/_api/web/lists/getbytitle('Announcements')/Items" endpoint. Angular project      Now, open the angular elements project which we have created in the previous article in VS Code.      For convenience let's create an interface to work with our data model. Create the "data" folder wonder the "src/app" and create a new file named Announcement.ts.      Add this code to it: export interface Announcement { ID : number ; Title : string ; Body : string ; }      We will use the service to get the data from our list. ...
Read more

Chain of Responsibility pattern in C#

Hello, C# lovers! šŸ˜ Today I want to talk about a very useful design pattern called Chain of Responsibility. This pattern allows you to pass a request along a chain of handlers until one of them can handle it. This way, you can avoid coupling the sender of the request with the receiver, and you can dynamically compose the chain at runtime. Sounds cool, right? šŸ˜Ž Let’s see an example of how to implement this pattern in C#. Suppose you have a simple ATM machine that can dispense bills of 10, 20, and 50 dollars. You want to write a program that can handle any amount of money requested by the user, using the least number of bills possible. To do this, you can create an abstract class called Handler that defines an interface for handling the requests. It also has a reference to the next handler in the chain, and a method to set it. // The 'Handler' abstract class public abstract class Handler { protected Handler successor; public void SetSuccessor ( Handler successo...
Read more