Builder Design Pattern in C#

Introduction
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
        myLaptop.DisplayInfo();
    }
}

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.