DEV Community

Rohit Cdy
Rohit Cdy

Posted on

Builder Design Pattern in C#

Builder Design Pattern in C#

The Builder Design Pattern builds a complex object using many simple objects and a step-by-step approach. The goal is to create a generic process for constructing the complex object, which can be used to create different representations of the same object. This pattern is especially handy when:

  • You need to create an object with many optional and required fields.
  • The object’s construction process is complex.
  • Multiple representations of the object are possible.

Real-Life Analogy
Imagine building a laptop. A laptop is a complex object composed of various smaller components like LCD displays, USB ports, hard drives, batteries, keyboards, and more. To construct a laptop, we follow a generic process:

  1. Plug in the memory.
  2. Plug in the hard drive.
  3. Plug in the battery.
  4. Plug in the keyboard.
  5. Cover the laptop with a plastic case.

Using this process, we can create different types of laptops—some with 14-inch screens, others with 17-inch screens, varying RAM sizes, and so on. The Builder Design Pattern allows us to assemble these small components into a cohesive whole, following the same generic process.

Implementation in C#
In C#, you can use the Builder Design Pattern to create objects with many optional components or configurations. Here’s how it works:

  1. Define a Builder class responsible for constructing the complex object step by step.
  2. The Builder class has methods for adding components (e.g., memory, hard drive, battery).
  3. A Director class orchestrates the construction process by invoking the Builder methods.
  4. The final complex object is retrieved from the Builder.

Here’s a simplified example:

using System;

// Product class (complex object)
class Laptop
    public int MemorySize { get; set; }
    public string HardDriveType { get; set; }
    // Other properties...

    public void DisplayInfo()
        Console.WriteLine($"Laptop Info: Memory: {MemorySize}GB, Hard Drive: {HardDriveType}");
        // Display other properties...

// Builder interface
interface ILaptopBuilder
    void AddMemory(int size);
    void AddHardDrive(string type);
    // Other methods for adding components...
    Laptop GetLaptop();

// Concrete builder
class LaptopBuilder : ILaptopBuilder
    private Laptop _laptop = new Laptop();

    public void AddMemory(int size)
        _laptop.MemorySize = size;

    public void AddHardDrive(string type)
        _laptop.HardDriveType = type;

    // Other component methods...

    public Laptop GetLaptop()
        return _laptop;

// Director
class LaptopManufacturer
    public Laptop ConstructLaptop(ILaptopBuilder builder)
        builder.AddMemory(8); // Example: Add 8GB RAM
        builder.AddHardDrive("SSD"); // Example: Add SSD
        // Other component additions...
        return builder.GetLaptop();

class Program
    static void Main()
        var builder = new LaptopBuilder();
        var manufacturer = new LaptopManufacturer();
        var myLaptop = manufacturer.ConstructLaptop(builder);

        // Display laptop info

Enter fullscreen mode Exit fullscreen mode

Remember that the Builder Design Pattern allows you to create different representations of the same complex object using a consistent construction process. It’s a powerful tool when dealing with intricate object creation.

Top comments (0)