Articles → .NET DESIGN PATTERN → Factory Method Design Pattern In C#

Factory Method Design Pattern In C#

This article describes the Factory Method Design Pattern using C#.

Purpose

The Factory Method Design Pattern is the creational design pattern. Its purpose 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 invoke 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 expose the object creation method to the client. To avoid this scenario, we use the factory method design pattern.

Steps

The following UML diagram illustrates the Factory Method design pattern.

Picture showing the UML diagram of factory method design pattern

To implement the Factory Method Design Pattern, we will focus 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 to create an object for the class.

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

Create A Concrete Product Class That Implements The Product Interface

We will create four classes (one for each operation). All four 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

We will now create an abstract class that declares a factory method that returns an object implementing 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 utilize 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	**