Builder Pattern in C#

Hello, fellow C# developers! In this post, I’m going to talk about the Builder pattern, one of the creational design patterns that can help you create complex objects in a flexible and elegant way. 😎

What is the Builder pattern?

The Builder pattern separates the construction of a complex object from its representation so that the same construction process can create different representations. This is useful when you want to create an object with many parts or options, and you don’t want to use a constructor with too many parameters or a mutable object with setters. 🙅

Instead, you can use a separate class, called a Builder, that provides methods for adding parts or options to the object. The Builder class also has a method for returning the final product. You can have different Builders for different representations of the same product. 🙌

How to implement the Builder pattern in C#?

There are many ways to implement the Builder pattern in C#, but one common approach is to use an abstract base class or an interface for the Builder, and then create concrete subclasses or implementations for each representation. You also need a Director class that controls the construction process and uses the Builder interface. Finally, you need a Product class that represents the complex object you want to create. 🚀

Here is an example of how to implement the Builder pattern in C# using an interface:

// The Builder interface
interface IBuilder
{
    void BuildEngine();
    void BuildWheels();
    void BuildColor();
    Car GetResult();
}

// A concrete Builder for one representation
class ToyotaBuilder : IBuilder
{
    private Car car = new Car();

    public void BuildEngine()
    {
        car.Add("Hybrid engine");
    }

    public void BuildWheels()
    {
        car.Add("16-inch wheels");
    }

    public void BuildColor()
    {
        car.Add("Silver color");
    }

    public Car GetResult()
    {
        return car;
    }
}

// Another concrete Builder for another representation
class NissanBuilder : IBuilder
{
    private Car car = new Car();

    public void BuildEngine()
    {
        car.Add("Gasoline engine");
    }

    public void BuildWheels()
    {
        car.Add("18-inch wheels");
    }

    public void BuildColor()
    {
        car.Add("Red color");
    }

    public Car GetResult()
    {
        return car;
    }
}

// The Director class that controls the construction process
class Director
{
    public void Construct(IBuilder builder)
    {
        builder.BuildEngine();
        builder.BuildWheels();
        builder.BuildColor();
    }
}

// The Product class that represents the complex object
class Car
{
    List<string> parts = new List<string>();

    public void Add(string part)
    {
        parts.Add(part);
    }

    public void Display()
    {
        Console.WriteLine("\nCar Parts -------");
        foreach (string part in parts)
            Console.Write(part + " ");
        Console.WriteLine();
    }
}

How to use the Builder pattern in C#?

To use the Builder pattern in C#, you need to create an instance of the Director class and an instance of the Builder class you want to use. Then, you can call the Construct method of the Director with the Builder as an argument. This will build the car according to the steps defined by the Builder. Finally, you can call the GetResult method of the Builder to get the final car. 🎉

Here is an example of how to use the Builder pattern in C#:

// Create a director and two builders
Director director = new Director();
IBuilder b1 = new ToyotaBuilder();
IBuilder b2 = new NissanBuilder();

// Construct two cars using different builders
director.Construct(b1);
Car c1 = b1.GetResult();
c1.Display();

director.Construct(b2);
Car c2 = b2.GetResult();
c2.Display();

The output of this code is:

Car Parts -------
Hybrid engine 16-inch wheels Silver color 

Car Parts -------
Gasoline engine 18-inch wheels Red color 

As you can see, we have created two different cars using the same construction process but different builders. 😍

What are the benefits of using the Builder pattern in C#?

The Builder pattern has several benefits, such as:

• It allows you to create complex objects step by step, without exposing their internal structure or requiring a large constructor.
• It allows you to reuse the same construction process for different representations of the same product.
• It allows you to encapsulate the construction logic in separate classes, making it easier to maintain and extend.
• It gives you more control over the construction process, as you can vary the order or number of steps.

What are some examples of using the Builder pattern in C#?

The Builder pattern is widely used in C#, especially when dealing with objects that have many parts or options. Some examples are:

• StringBuilder: This class allows you to create a string by appending or inserting parts, without creating a new string object each time. It implements the Builder pattern by providing methods for adding parts and returning the final string.
• HttpRequestMessage: This class represents an HTTP request message that can have many headers, properties and content. It implements the Builder pattern by providing methods for setting the parts and returning the final message.
• FluentAssertions: This is a popular library for writing unit tests in C#. It implements the Builder pattern by providing a fluent interface for creating assertions, using methods that return the same or a different builder.

Where can I learn more about the Builder pattern in C#?

If you want to learn more about the Builder pattern in C#, you can check out these resources:

• C# Builder Design Pattern - Dofactory
• Understanding Builder Pattern in C# - Stack Overflow
• C# Builder Pattern: The Complete Guide to Mastering It - MethodPoet
• Builder pattern in C# - TechNet Articles

I hope you enjoyed this post and learned something new about the Builder pattern in C#. If you have any questions or feedback, please leave a comment below. 

You can find the code examples here: source code

Happy coding! 😊