Simplifying Design Patterns : Builder

Introduction Design patterns are proven solutions to common software design problems. In this article, we’ll simplify the Builder pattern—explaining how it works, when to use it, and how to implement it with clear examples. The examples are inspired by Refactoring Guru and Dive Into Design Patterns (Alexander Shvets), distilled to their essence. How Does the Builder Pattern Work? The Builder Pattern is a creational design pattern that separates the construction of a complex object into step-by-step processes. This allows the same construction logic to create different representations of an object while avoiding overly complex constructors. Example Scenario: A Restaurant Kitchen Imagine a restaurant kitchen where: All pasta dishes follow a base preparation flow: boiling pasta, preparing sauce, adding garnishes, and serving. Some pastas require extra steps (e.g., adding cheese, spices, or special toppings), but the core process remains consistent. Without the Builder Pattern, a Pasta class would need a massive constructor with many parameters (most unused in most cases), leading to messy code and null defaults. Define a PastaBuilder interface with methods for each construction step (e.g., setPastaType(), addSauce(), addGarnish()). Implement concrete builders (e.g., SpaghettiBuilder, AlfredoBuilder) to handle variations. Introduce a Director (e.g., the head chef) to enforce standardized recipes (e.g., "Vegetarian Pasta" or "Spicy Arrabbiata") by executing predefined steps. Clients (or chefs) can either use the Director for preconfigured dishes, or Customize dishes directly via the Builder for flexibility. When to Use the Builder? Use this pattern when: You have enormous constructors You want different representations of the same product You are working with complex objects that can be constructed with steps How to Implement the Builder Step-by-Step (Restaurant Example) Define the product by creating a Pasta class with properties (type, sauce, garnish, etc.) public class Pasta { public string Type { get; set; } public string Sauce { get; set; } public string Garnish { get; set; } public bool HasCheese { get; set; } } Create a interface builder declaring methods for each construction step (SetPastaType, AddSauce, etc.) public interface IPastaBuilder { void SetPastaType(string type); void AddSauce(string sauce); void AddGarnish(string garnish); void AddCheese(bool hasCheese); Pasta GetPasta(); } Now implement concrete builders for each of the dishes, like SpaghettiBuilder that implement the builder public class SpaghettiBuilder : IPastaBuilder { private Pasta _pasta = new Pasta(); public void SetPastaType(string type) => _pasta.Type = type; public void AddSauce(string sauce) => _pasta.Sauce = sauce; public void AddGarnish(string garnish) => _pasta.Garnish = garnish; public void AddCheese(bool hasCheese) => _pasta.HasCheese = hasCheese; public Pasta GetPasta() => _pasta; } Create a director to coordinate the calling of those step methods and what parameters must be sent to them public class Chef { private IPastaBuilder _builder; public Chef(IPastaBuilder builder) => _builder = builder; public void MakeMargheritaPasta() { _builder.SetPastaType("Spaghetti"); _builder.AddSauce("Tomato"); _builder.AddGarnish("Basil"); _builder.AddCheese(true); } } In your client code instatiate a concrete builder and a director, passing the builder to the director for it to create the dish you want var builder = new SpaghettiBuilder(); var chef = new Chef(builder); // Standard recipe chef.MakeMargheritaPasta(); Pasta margherita = builder.GetPasta(); // Custom order (without Director) var customBuilder = new SpaghettiBuilder(); customBuilder.SetPastaType("Penne"); customBuilder.AddSauce("Alfredo"); Pasta customPasta = customBuilder.GetPasta(); Diagram

Apr 10, 2025 - 03:39

Introduction

Design patterns are proven solutions to common software design problems. In this article, we’ll simplify the Builder pattern—explaining how it works, when to use it, and how to implement it with clear examples. The examples are inspired by Refactoring Guru and Dive Into Design Patterns (Alexander Shvets), distilled to their essence.

How Does the Builder Pattern Work?

The Builder Pattern is a creational design pattern that separates the construction of a complex object into step-by-step processes. This allows the same construction logic to create different representations of an object while avoiding overly complex constructors.

Example Scenario: A Restaurant Kitchen

Imagine a restaurant kitchen where:

All pasta dishes follow a base preparation flow: boiling pasta, preparing sauce, adding garnishes, and serving.
Some pastas require extra steps (e.g., adding cheese, spices, or special toppings), but the core process remains consistent.
Without the Builder Pattern, a Pasta class would need a massive constructor with many parameters (most unused in most cases), leading to messy code and null defaults.
Define a PastaBuilder interface with methods for each construction step (e.g., setPastaType(), addSauce(), addGarnish()).
Implement concrete builders (e.g., SpaghettiBuilder, AlfredoBuilder) to handle variations.
Introduce a Director (e.g., the head chef) to enforce standardized recipes (e.g., "Vegetarian Pasta" or "Spicy Arrabbiata") by executing predefined steps.
Clients (or chefs) can either use the Director for preconfigured dishes, or Customize dishes directly via the Builder for flexibility.

When to Use the Builder?

Use this pattern when:

You have enormous constructors
You want different representations of the same product
You are working with complex objects that can be constructed with steps

How to Implement the Builder

Step-by-Step (Restaurant Example)

Define the product by creating a Pasta class with properties (type, sauce, garnish, etc.)

   public class Pasta 
   {
       public string Type { get; set; }
       public string Sauce { get; set; }
       public string Garnish { get; set; }
       public bool HasCheese { get; set; }
   }

Create a interface builder declaring methods for each construction step (SetPastaType, AddSauce, etc.)

   public interface IPastaBuilder 
   {
       void SetPastaType(string type);
       void AddSauce(string sauce);
       void AddGarnish(string garnish);
       void AddCheese(bool hasCheese);
       Pasta GetPasta();
   }

Now implement concrete builders for each of the dishes, like SpaghettiBuilder that implement the builder

   public class SpaghettiBuilder : IPastaBuilder
   {
       private Pasta _pasta = new Pasta();

       public void SetPastaType(string type) => _pasta.Type = type;
       public void AddSauce(string sauce) => _pasta.Sauce = sauce;
       public void AddGarnish(string garnish) => _pasta.Garnish = garnish;
       public void AddCheese(bool hasCheese) => _pasta.HasCheese = hasCheese;
       public Pasta GetPasta() => _pasta;
   }

Create a director to coordinate the calling of those step methods and what parameters must be sent to them

   public class Chef
   {
       private IPastaBuilder _builder;

       public Chef(IPastaBuilder builder) => _builder = builder;

       public void MakeMargheritaPasta()
       {
           _builder.SetPastaType("Spaghetti");
           _builder.AddSauce("Tomato");
           _builder.AddGarnish("Basil");
           _builder.AddCheese(true);
       }
   }

In your client code instatiate a concrete builder and a director, passing the builder to the director for it to create the dish you want

   var builder = new SpaghettiBuilder();
   var chef = new Chef(builder);

   // Standard recipe
   chef.MakeMargheritaPasta();
   Pasta margherita = builder.GetPasta();

   // Custom order (without Director)
   var customBuilder = new SpaghettiBuilder();
   customBuilder.SetPastaType("Penne");
   customBuilder.AddSauce("Alfredo");
   Pasta customPasta = customBuilder.GetPasta();