Articles → .NET DESIGN PATTERN → Factory Method Design Pattern

Factory Method Design Pattern

In this article, we will discuss the Factory Method Design Pattern using C#.

Purpose

The Factory Method Design Pattern is the creational pattern. The purpose of this pattern is to create an object of a class without exposing the object creation logic to the client.

Scenario

Consider the following class: -

public enum CalculationType
{
	Sum,
	Difference,
	Multiplication,
	Division
}

public class SimpleCalculator 
{
    private CalculationType calculationType;
    public SimpleCalculator(CalculationType _calculationType)
    {
		this.calculationType = _calculationType;
    }
	  public int ReturnResult(int arg1, int arg2)
	  {
		  int result = 0;
		  switch (calculationType)
		  {
			  case CalculationType.Sum:
				  result = arg1 + arg2;
				  break;
			  case CalculationType.Difference:
				  result = arg1 - arg2;
				  break;
			  case CalculationType.Multiplication:
				  result = arg1 * arg2;
				  break;
			  case CalculationType.Division:
				  result = arg1/arg2;
				  break;
		  }
		  return result;
	  }
}

To call the above class, the client will use the following code: -

SimpleCalculator oCalculator1 = new SimpleCalculator(CalculationType.Sum);
int result = oCalculator1.ReturnResult(1, 2);

In the above code, we are exposing the object creation method to the client. To avoid this scenario, the factory method design pattern comes into the picture.

Steps

Here is the UML diagram of the Factory method design pattern.

Picture showing the UML diagram of factory method design pattern

Click to Enlarge

For implementing the Factory Method Design Pattern, we will work on the following steps: -

Create a Product interface
Create a Concrete Product class that implements the Product interface
Create an abstract Creator class
create the Concrete Creator class and implement the Creator abstract class
Call the class method

So, let us start.

Create A Product Interface

The first step is to create an interface. This interface is used for creating an object of the class.

public interface iCalc
{
	int ReturnResult(int arg1, int arg2);
}

Create A Concrete Product Class That Implements The Product Interface

In this example, we will create 4 classes (one for each operation). All the 4 classes will implement the interface.

public class Sum : iCalc
{
	public int ReturnResult(int arg1, int arg2)
	{
		return (arg1 + arg2);
	}
}

public class Difference : iCalc
{
	public int ReturnResult(int arg1, int arg2)
	{
		return (arg1 - arg2);
	}
}

public class Multiplication : iCalc
{
	public int ReturnResult(int arg1, int arg2)
	{
		return (arg1 * arg2);
	}
}

public class Division : iCalc
{
	public int ReturnResult(int arg1, int arg2)
	{
		return Convert.ToInt32(arg1 / arg2);
	}
}

Create An Abstract Creator Class

In this step, we will create an abstract class that declares the factory method and returns the Product interface.

public abstract class AbstractCalculator
{
	public abstract iCalc CreateOperation(CalculationType oCalculationType);
}

Create The Concrete Creator Class And Implement The Creator Abstract Class

This class will implement the abstract class created in the last step.

public class Calculator : AbstractCalculator
{
	public override iCalc CreateOperation(CalculationType oCalculationType)
	{
		if (oCalculationType == CalculationType.Sum)
		{
			return new Sum();
		}
		else if (oCalculationType == CalculationType.Difference)
		{
			return new Difference();
		}
		else if (oCalculationType == CalculationType.Multiplication)
		{
			return new Multiplication();

		}
		else if (oCalculationType == CalculationType.Division)
		{
			return new Division();
		}
		else
		{
			throw new ApplicationException("Problem Occurs");
		}
	}


}

Call The Class Method

The client can now use the following code to create an instance of the class.

Calculator oCalculator = new Calculator();
iCalc x = oCalculator.CreateOperation(CalculationType.Sum);
int result = x.ReturnResult(1, 2);
Console.WriteLine(String.Format("Output is: {0}", result));

Output

Click to Enlarge

Complete Code

// A Simple Interface
public interface iCalc
{
	int ReturnResult(int arg1, int arg2);
}


public class Sum : iCalc
{
	public int ReturnResult(int arg1, int arg2)
	{
		return (arg1 + arg2);
	}
}

public class Difference : iCalc
{
	public int ReturnResult(int arg1, int arg2)
	{
		return (arg1 - arg2);
	}
}

public class Multiplication : iCalc
{
	public int ReturnResult(int arg1, int arg2)
	{
		return (arg1 * arg2);
	}
}

public class Division : iCalc
{
	public int ReturnResult(int arg1, int arg2)
	{
		return Convert.ToInt32(arg1 / arg2);
	}
}


public enum CalculationType
{
	Sum,
	Difference,
	Multiplication,
	Division
}
public abstract class AbstractCalculator
{
	public abstract iCalc CreateOperation(CalculationType oCalculationType);
}
public class Calculator : AbstractCalculator
{
	public override iCalc CreateOperation(CalculationType oCalculationType)
	{
		if (oCalculationType == CalculationType.Sum)
		{
			return new Sum();
		}
		else if (oCalculationType == CalculationType.Difference)
		{
			return new Difference();
		}
		else if (oCalculationType == CalculationType.Multiplication)
		{
			return new Multiplication();

		}
		else if (oCalculationType == CalculationType.Division)
		{
			return new Division();
		}
		else
		{
			throw new ApplicationException("Problem Occurs");
		}
	}


}

Posted By -	Karan Gupta

Posted On -	Tuesday, November 15, 2022

Query/Feedback

Your Email Id		**

Subject		*

Query/Feedback	Characters remaining 250	**