namespace SoftwarePatterns.Core.Builder

public enum Department

{

IT,

HR,

Accounting,

ServiceDesk

}

using System;

using System.Collections.Generic;

namespace SoftwarePatterns.Core.Builder

/// <summary>

/// This class is created to solve the problem of the employee with the large constructor by making all fields public properties.

/// However the issues with this is that we can no longer control the order or process of construction this is solved using director and builders

/// The employee object is now only concerned with data not process or logic around how it is made

/// </summary>

public class Employee

{

public string Name { get; set; }

public string Email { get; set; }

public string Phone { get; set; }

public Department Department { get; set; }

public Band Band { get; set; }

public bool IsFullTime { get; set; }

public List<string> Certifications { get; set; }

public void Display()

{

Console.WriteLine("Employee Details");

Console.WriteLine("Name: {0}", Name);

Console.WriteLine("Email: {0}", Email);

Console.WriteLine("Phone: {0}", Phone);

Console.WriteLine("Department: {0}", Department);

Console.WriteLine("Band: {0}", Band);

Console.WriteLine("FullTime: {0}", IsFullTime);

Console.WriteLine("Certifications:");

Certifications.ForEach(s => Console.WriteLine("{0}",s));

Console.WriteLine();

}

}

namespace SoftwarePatterns.Core.Builder

/// <summary>

/// Each employee builder is expected to know what is required at each stage of the process for its given implementation type

/// </summary>

public abstract class EmployeeBuilder

{

protected Employee employee;

public abstract void AddCertifications();

public abstract void AddHrDetails();

public abstract void AddPersonalDetails();

public abstract void EnterDepartment();

public virtual void CreateNewSandwitch()

{

employee = new Employee();

}

public Employee GetEmployee()

{

return employee;

}

}

using System;

using System.Collections.Generic;

namespace SoftwarePatterns.Core.Builder

/// <summary>

/// Class issues that our constructor grows and grows and becomes difficult to work with

/// </summary>

public class EmployeeConstructorTooBig

{

private readonly string name;

private readonly string email;

private readonly string phone;

private readonly Department department;

private readonly Band band;

private readonly bool isFullTime;

private readonly List<string> certifications;

public EmployeeConstructorTooBig(string name,string email, string phone, Department department, Band band, bool isFullTime, List<string> certifications)

{

this.name = name;

this.email = email;

this.phone = phone;

this.department = department;

this.band = band;

this.isFullTime = isFullTime;

this.certifications = certifications;

}

public void Display()

{

Console.WriteLine("Employee Details");

Console.WriteLine("Name: {0}", name);

Console.WriteLine("Email: {0}", email);

Console.WriteLine("Phone: {0}", phone);

Console.WriteLine("Department: {0}", department);

Console.WriteLine("Band: {0}", band);

Console.WriteLine("FullTime: {0}", isFullTime);

Console.WriteLine("Certifications:");

certifications.ForEach(s => Console.WriteLine("{0}",s));

Console.WriteLine();

}

}

namespace SoftwarePatterns.Core.Builder

/// <summary>

/// The employee director encapsulates the process of construction. It does not know anything about the data it only knows about order of operation.

/// </summary>

public class EmployeeDirector

{

private readonly EmployeeBuilder builder;

public EmployeeDirector(EmployeeBuilder builder)

{

this.builder = builder;

}

public Employee CreateEmployee()

{

builder.CreateNewSandwitch();

builder.AddPersonalDetails();

builder.AddCertifications();

builder.EnterDepartment();

builder.AddHrDetails();

return builder.GetEmployee();

}

}

The builder pattern is used when object construction becomes complex.

It deals with the issue of:

1. Too many parameters

2. When constructor parameters become order dependent

3. Construct different objects (we need to separate data and logic)

The pattern separates the construction of a complex object form its representation so the same construction process can create different representations.

Examples:

In our example we have a class the employee which constructor is getting to big. We refractor this so that we expose its data as public properties. This now mean we have no control over how our object is built.

So give us this control back we produce a Employee director this class knows what is the process for building an object but should not care about the data required to generate any concrete instance of the employee class.

The maker takes a employee builder this is an abstract class the we need to implement for any given employee type. These clases are concerned with what data is needed for their given type but not the process logic.

using System.Collections.Generic;

namespace SoftwarePatterns.Core.Builder

public class ServiceDeskEmployeeBuilder : EmployeeBuilder

{

public override void AddCertifications()

{

employee.Certifications = new List<string>();

}

public override void AddHrDetails()

{

employee.Band = Band.Entry;

employee.IsFullTime = false;

}

public override void AddPersonalDetails()

{

employee.Name = "Name";

employee.Email = "Email";

employee.Phone = "048915646131";

}

public override void EnterDepartment()

{

employee.Department = Department.ServiceDesk;

}

}

<Compile Include="Builder\Band.cs" />

<Compile Include="Builder\Department.cs" />

<Compile Include="Builder\EmployeeBuilder.cs" />

<Compile Include="Builder\EmployeeConstructorTooBig.cs" />

<Compile Include="Builder\Employee.cs" />

<Compile Include="Builder\EmployeeDirector.cs" />

<Compile Include="Builder\ServiceDeskEmployeeBuilder.cs" />

<Content Include="Builder\ReadMe.txt" />

using Ploeh.AutoFixture;

using SoftwarePatterns.Core.Builder;

using Xunit;

namespace SoftwarePatterns.Tests.Builder

public class ServiceDeskEmployeeBuilderTests

{

public class CreateEmployeeMethod

{

[Fact]

public void ShouldAddEmployeeToServiceDeskDepartment()

{

var fixture = new Fixture();

var builder = fixture.Create<ServiceDeskEmployeeBuilder>();

var director = new EmployeeDirector(builder);

var employee = director.CreateEmployee();

Assert.Equal(Department.ServiceDesk, employee.Department);

}

}

}