Guide to Implement the Factory Pattern in C#

Introduction

This article will focus on explaining the factory pattern in C#, which is one of the most used patterns in the object oriented programming world. People say that design patterns originally evolved in the civil construction field and were later adopted in the software development field.

In simple design, patterns are defined as the solutions to the recurring problems. These are the solutions or program templates that were adopted and successfully implemented by the people for some specific problems. These standard program templates or designs are being adopted by developers to overcome similar problems. A good design pattern makes the code clean and mandates the other programmers to follow it.

In this article I will be including the C# language code samples for demonstration in the form of class diagrams.

Factory Pattern

Gang of Four patterns is the famous design patterns that are being widely followed today. Factory pattern is one among them. These patterns are divided into three sub groups as Creational pattern, Structural Pattern and Behavioral pattern. The factory falls under the creational pattern category.

The factory pattern can be sub categorized into two.

  1.        Factory Method
  2.        Abstract Factory

The factory pattern is applicable in scenarios where you don't want the clients to decide on which of your concrete classes to be used rather than making your code decide which of your concrete class objects to be returned based on the parameters provided by the client.

What is Achieved by Using Factory Pattern?

  1. The object creation can be separated from the clients deciding on what objects to be created.
  2. The object creation of the concrete classes can be controlled through values such as:
    1. Parameters passed by the client functions.
    2. Configuration value stored in the .net framework configuration file.
    3. Configuration value stored in the database.
  3. Factory allows you to add new concrete classes and methods without breaking or modifying the existing code.

Factory Method

In the factory method, define an interface for multiple factory classes and handover the object creation task to those factory classes based. The respective factory class should be loaded then to create the concrete objects. Below is the class diagram of the C# application implementing the factory method pattern.

Create an interface named ISnackFactory.

namespace FactoryMethod
{
    interface ISnackFactory
    {
        ISnack CreateSnack();
    }
}

Create two factory classes IcecreamFactory and ChocolateFactory for creating the objects Icecream and Chocolate respectively. Both of the concrete factories should implement from the ISnackFactory interface.

namespace FactoryMethod
{
    class IcecreamFactory : ISnackFactory
    {
        public ISnack CreateSnack()
        {
            return new Icecream();
        }
    }
}


namespace FactoryMethod
{
    class ChocolateFactory : ISnackFactory
    {
        public ISnack CreateSnack()
        {
            return new Chocolate();
        }
    }
}
 

Create the interface called ISnack, which should be inherited by both the concrete classes.

namespace FactoryMethod
{
    interface ISnack
    {
        bool IsRefrigirationRequired { get; }
        void Eat();
    }
}

Below are the implementations for the concrete classes Icecream and Chocolate.

namespace FactoryMethod
{
    class Chocolate : ISnack
    {
        public bool IsRefrigirationRequired
        {
            get { return false; }
        }
 
        public void Eat()
        {
            Console.WriteLine(string.Format("Refrigiration Required? {0}", IsRefrigirationRequired));
            Console.WriteLine("Chocolate is sweet and yummy");
        }
    }
}


namespace FactoryMethod
{
    class Icecream : ISnack
    {
        public bool IsRefrigirationRequired
        {
            get { return true; }
        }
 
        public void Eat()
        {
            Console.WriteLine(string.Format("Refrigiration Required? {0}", IsRefrigirationRequired));
            Console.WriteLine("Icecream is cool and soft");
        }
    }
}

Finally add the code for the client, which does the call to the factories and fetches the object of the concrete class.

namespace FactoryMethod
{
    class Program
    {
        static void Main(string[] args)
        {
            ISnackFactory snackFactory = LoadFactory("icecream");

            ISnack snack = snackFactory.CreateSnack();
            snack.Eat();
        }
 
        private static ISnackFactory LoadFactory(string snack)
        {
            switch (snack)
            {
                case "icecream":
                    return new IcecreamFactory();

                default:
                    return new ChocolateFactory();

                    break;
            }
        }
    }
}


Figure 1

As the diagram shows, below are the advantages and drawbacks.

  1. Since the objects are created by the respective factories the reference of the concrete classes are eliminated.
  2. The factories can still be inherited to make more specific objects.
  3. This also mandates us to create one factory just for creating the object of one concrete class.

Abstract Factory

Abstract factory pattern is abstracted further that the object is created from a family or related classes without specifying the concrete class. The client wouldn't know which factory will return which object from the family. Abstract factory can have multiple factory methods each creating different types of concrete objects belonging to the same family.

Considering the code example in the previous section's C# code, with the abstract factory implementation, the Chocolate factory would know how to create a dark chocolate and milk chocolate. For each concrete class representing a type, belonging to a family would sign the contracts to an interface.

Conclusion

I hope this article provides an in-depth explanation of the factory patterns and acts as a guide to the C# programmers who are striving to implement it. Please make use of the comments section to punch in your valuable comments.



About the Author

V.N.S Arun

I work for an MNC in Bangalore, India. I am fond of writing articles, posting answers in forums and submitting tips in dotnet. To contact me please feel free to make use of the "Send Email" option next to the display name.

Related Articles

Comments

  • factory pattern c#

    Posted by sara on 04/23/2013 08:37pm

    I need factory pattern for crossroads and traffic signal. thanks!

    Reply
Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • Live Event Date: September 17, 2014 @ 1:00 p.m. ET / 10:00 a.m. PT Another day, another end-of-support deadline. You've heard enough about the hazards of not migrating to Windows Server 2008 or 2012. What you may not know is that there's plenty in it for you and your business, like increased automation and performance, time-saving technical features, and a lower total cost of ownership. Check out this upcoming eSeminar and join Rich Holmes, Pomeroy's practice director of virtualization, as he discusses the …

  • Packaged application development teams frequently operate with limited testing environments due to time and labor constraints. By virtualizing the entire application stack, packaged application development teams can deliver business results faster, at higher quality, and with lower risk.

Most Popular Programming Stories

More for Developers

Latest Developer Headlines

RSS Feeds