A factory creates objects. A factory pattern is a reusable block of code that creates objects in a predictable way. We implement the factory design pattern in a C# program.
With this pattern, we develop an abstraction that isolates the logic for determining which type of class
to create. This helps us control what types we create.
The factory design pattern relies on a type hierarchy. The classes must all implement an interface
or derive from a base class
. We use an abstract
class
as the base.
class
is shared.Get()
takes a value and instantiates a class
based on that value. It translates integers to objects with a switch
statement.abstract
class
, the return type Position can be used.class
was instantiated for each integer.using System; class Program { abstract class Position { public abstract string Title { get; } } class Manager : Position { public override string Title { get { return "Manager"; } } } class Clerk : Position { public override string Title { get { return "Clerk"; } } } class Programmer : Position { public override string Title { get { return "Programmer"; } } } static class Factory { /// <summary> /// Decides which class to instantiate. /// </summary> public static Position Get(int id) { switch (id) { case 0: return new Manager(); case 1: case 2: return new Clerk(); case 3: default: return new Programmer(); } } } static void Main() { for (int i = 0; i <= 3; i++) { var position = Factory.Get(i); Console.WriteLine("Where id = {0}, position = {1} ", i, position.Title); } } }Where id = 0, position = Manager Where id = 1, position = Clerk Where id = 2, position = Clerk Where id = 3, position = Programmer
Imagine you have a system that needs to create objects in many different places. Suppose the system has integers and you want objects for those integers.
We use the factory design pattern to instantiate objects based on another data type such as integers. Factories make it easier to change which objects need to be created.