Factory Design Pattern Introduction

Suggested Videos
Part 5 - Lazy vs Eager loading in Singleton - Text - Slides
Part 6 - Static Class vs Singleton - Text - Slides
Part 7 - Exception Logging using Singleton Design Pattern - Text - Slides

In this tutorial we will discuss
  1. What is Factory Design Pattern
  2. Implementation Guidelines
  3. Simple factory implementation
(追記) (追記ここまで)

What is Factory Design Pattern

Gang of Four Definition
“Define an interface for creating an object, but let sub-classes decide which class to instantiate. The Factory method lets a class defer instantiation it uses to sub-classes”

(追記) (追記ここまで)

Factory pattern is one of the most used design patterns in real world applications

Factory pattern creates object without exposing the creation logic to the client and refer to newly created object using a common interface

factory pattern c#

From the above diagram, client uses factory and creates the product.

Implementation Guidelines : We need to choose Factory Pattern when
  • The Object needs to be extended to subclasses
  • The Classes doesn’t know what exact sub-classes it has to create
  • The Product implementation tend to change over time and the Client remains unchanged
Simple Factory Example : Business Requirement

Differentiate employees as permanent and contract and segregate their pay scales as well as bonus based on their employee types

We can address the above requirement with the below implementations
  1. Implement without Factory Pattern
  2. Use a Simple Factory
  3. Enhance Simple factory to Factory Method Pattern
We will be working on the Employee Portal that we used in the Singleton tutorials. Please refer to them before proceeding.

Prerequisite steps
Step 1 : Enhance the DB model to add Employee_Type Table
CREATE TABLE [dbo].[Employee_Type]
(
[Id] INT IDENTITY (1, 1) NOT NULL,
[EmployeeType] VARCHAR (150) NOT NULL,
PRIMARY KEY CLUSTERED ([Id] ASC)

)

Step 2 : Add Permanent and Contract Employees as Master Data

Step 3 : Add new columns EmployeeTypeID, Bonus, HourlyPay to Emplyee Table and add Foreign key constraint to the Emp
CREATE TABLE [dbo].[Employee]
(
[Id] INT IDENTITY (1, 1) NOT NULL,
[Name] VARCHAR (50) NOT NULL,
[JobDescription] VARCHAR (50) NOT NULL,
[Number] VARCHAR (50) NOT NULL,
[Department] VARCHAR (50) NOT NULL,
[HourlyPay] DECIMAL (18) NOT NULL,
[Bonus] DECIMAL (18) NOT NULL,
[EmployeeTypeID] INT NOT NULL,
PRIMARY KEY CLUSTERED ([Id] ASC),
CONSTRAINT [FK_Employee_EmployeeType] FOREIGN KEY ([EmployeeTypeID]) REFERENCES [dbo].[Employee_Type]([Id])

)

Step 4 : Update the Emloyee Model edmx file with the latest changes

Step 5 : Create new BaseController and Move the Singleton Exception logic to the base controller

publicclassBaseController : Controller
{
privateILog _ILog;
public BaseController()
{
_ILog = Log.GetInstance;
}
protectedoverridevoid OnException(ExceptionContext filterContext)
{
_ILog.LogException(filterContext.Exception.ToString());
filterContext.ExceptionHandled = true;
this.View("Error").ExecuteResult(this.ControllerContext);
}
}

Step 6 : Regenerate the EmployeesController and its corresponding views

Step 7 : Comment the code in Create and Update views which accepts inputs for Bonus and HourlyPay

Solution 1: Implement without Factory Pattern

EmployeeController.cs
[HttpPost]
[ValidateAntiForgeryToken]
publicActionResult Create([Bind(Include = "Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeID")] Employee employee)
{
if (ModelState.IsValid)
{
if (employee.EmployeeTypeID == 1)
{
employee.HourlyPay = 8;
employee.Bonus = 10;
}
elseif (employee.EmployeeTypeID == 2)
{
employee.HourlyPay = 12;
employee.Bonus = 5;
}
db.Employees.Add(employee);
db.SaveChanges();
return RedirectToAction("Index");
}

ViewBag.EmployeeTypeID = newSelectList(db.Employee_Type, "Id", "EmployeeType", employee.EmployeeTypeID);
return View(employee);
}

The above code introduces
  • Tight coupling between Controller class and Business logic
  • For any new employee type addition, we end up modifying the controller code adding extra over heads in the development and testing process
Using a simple factory eliminates the above drawbacks.

Solution 2: Implement with Simple Factory

Step 1 : Add new Manager folder and add the below interface and classes

IEmployeeManager.cs

publicinterfaceIEmployeeManager
{
decimal GetBonus();
decimal GetPay();
}

ContractEmployeeManager.cs

publicclassContractEmployeeManager : IEmployeeManager
{
publicdecimal GetBonus()
{
return 5;
}

publicdecimal GetPay()
{
return 12;
}
}

PermanentEmployeeManager.cs

publicclassPermanentEmployeeManager : IEmployeeManager
{
publicdecimal GetBonus()
{
return 10;
}

publicdecimal GetPay()
{
return 8;
}
}

Step 2 : Create Factory folder and add the below Manager class

EmployeeManagerFactory.cs

publicclassEmployeeManagerFactory
{
publicIEmployeeManager GetEmployeeManager(int employeeTypeID)
{
IEmployeeManager returnValue = null;
if (employeeTypeID == 1)
{
returnValue = newPermanentEmployeeManager();
}
elseif (employeeTypeID == 2)
{
returnValue = newContractEmployeeManager();
}
return returnValue;
}
}

Step 3 : Update the employee’s controller to consume the factory.

[HttpPost]
[ValidateAntiForgeryToken]
publicActionResult Create([Bind(Include = "Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeID")] Employee employee)
{
if (ModelState.IsValid)
{
EmployeeManagerFactory empFactory = newEmployeeManagerFactory();
IEmployeeManager empManager = empFactory.GetEmployeeManager(employee.EmployeeTypeID);
employee.Bonus = empManager.GetBonus();
employee.HourlyPay = empManager.GetPay();
db.Employees.Add(employee);
db.SaveChanges();
return RedirectToAction("Index");
}

ViewBag.EmployeeTypeID = newSelectList(db.Employee_Type, "Id", "EmployeeType", employee.EmployeeTypeID);
return View(employee);
}

Simple factory implementation is illustrated below
Simple factory implementation

Design Patterns tutorial for beginners

3 comments:

  1. Below code also tightly coupled

    if (employeeTypeID == 1)
    {
    returnValue = new PermanentEmployeeManager();
    }
    else if (employeeTypeID == 2)
    {
    returnValue = new ContractEmployeeManager();
    }

    Reply Delete
    Replies

    1. Instead hardcode value we can use Enum to check the value

      Delete

  2. This comment has been removed by the author.

    Reply Delete

It would be great if you can help share these free resources

[フレーム]

Subscribe to: Post Comments (Atom)

AltStyle によって変換されたページ (->オリジナル) /