Builder Design Pattern in C# with Real-time Example in C#

In this article, we will discuss the Builder Design Pattern in C# with models. it is part of the Creational Design Pattern.

Definition: "Separate the construction of a complex object from its representation so that the same construction process can create different representations"

Builder Design Pattern solves the situation of increasing constructor parameters and constructors of a given class by providing a step-by-step initialization of Parameters. After step-by-step initialization, it returns the resulting constructed object at once.

The Builder Design Pattern is a creational design pattern that allows you to create complex objects step by step. It separates the construction of a complex object from its representation, allowing the same construction process to create different representations.

Here's a real-time example in C#: constructing a House object with various parts (walls, roof, etc.).

Step 1: Define the Product Class

public class House {

    public string Basement { get; set; }

    public string Structure { get; set; }

    public string Roof { get; set; }

    public string Interior { get; set; } 

public override string ToString()
{
    return $"House with Basement: {Basement}, Structure: {Structure}, Roof: {Roof}, Interior: {Interior}";
}
}

Step 2: Define the Builder Interface

public interface IHouseBuilder 
{
     void BuildBasement(); 
     void BuildStructure();
     void BuildRoof(); 
     void BuildInterior(); 
     House GetHouse(); 
}

Step 3: Implement Concrete Builders

public class ConcreteHouseBuilder : IHouseBuilder
{
    private House _house = new House(); 

    public void BuildBasement()
    {
        _house.Basement = "Concrete Basement";
    } 

    public void BuildStructure()
    {
        _house.Structure = "Concrete and Steel Structure";
    } 

    public void BuildRoof()
    {
        _house.Roof = "Concrete Roof";
    } 

    public void BuildInterior()
    {
        _house.Interior = "Painted Walls with Wooden Flooring";
    } 

    public House GetHouse()
    {
        return _house;
    }
} 

public class WoodenHouseBuilder : IHouseBuilder
{
    private House _house = new House();

    public void BuildBasement()
    {
        _house.Basement = "Wooden Basement";

    }

    public void BuildStructure()
    {
        _house.Structure = "Wood and Iron Structure";

    }

    public void BuildRoof()
    {
        _house.Roof = "Wooden Roof";
    }

    public void BuildInterior()
    {
        _house.Interior = "Wooden Walls with Carpet Flooring";
    }

    public House GetHouse()
    {
        return _house;
    }
}

Step 4: Define the Director Class

public class Director
{
    private IHouseBuilder _houseBuilder; 

    public Director(IHouseBuilder houseBuilder)
    {
         _houseBuilder = houseBuilder;
    } 

    public void ConstructHouse()
    {
        _houseBuilder.BuildBasement();
        _houseBuilder.BuildStructure();
        _houseBuilder.BuildRoof();
        _houseBuilder.BuildInterior();
    } 

    public House GetHouse()
    {
        return _houseBuilder.GetHouse();
    }

}

Step 5: Use the Builder Pattern

class Program
{
    static void Main(string[] args)
    {
        IHouseBuilder concreteHouseBuilder = new ConcreteHouseBuilder();
        Director director = new Director(concreteHouseBuilder); 
        director.ConstructHouse();
        House concreteHouse = director.GetHouse();
        Console.WriteLine(concreteHouse);

        IHouseBuilder woodenHouseBuilder = new WoodenHouseBuilder();
        director = new Director(woodenHouseBuilder); 

        director.ConstructHouse();
        House woodenHouse = director.GetHouse();
        Console.WriteLine(woodenHouse);

    }

}

Explanation

House: The product class, which has various parts such as Basement, Structure, Roof, and Interior.
IHouseBuilder: The builder interface with methods to build different parts of the house and a method to get the final house object.
ConcreteHouseBuilder and WoodenHouseBuilder: Concrete builder classes that implement the IHouseBuilder interface to build a concrete house and a wooden house, respectively.
Director: The director class that constructs a house using the builder interface.
Program: The client code that uses the builder pattern to create different types of houses.

This example shows how the Builder Design Pattern can be used to construct complex objects with a step-by-step approach, ensuring the same construction process can produce different representations of the object.