Object oriented Design patterns : Builder Patterns


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



Participants

The classes and objects participating in this pattern are:

  • Builder  (VehicleBuilder)
    • specifies an abstract interface for creating parts of a Product object
  • ConcreteBuilder  (MotorCycleBuilder, CarBuilder, ScooterBuilder)
    • constructs and assembles parts of the product by implementing the Builder interface
    • defines and keeps track of the representation it creates
    • provides an interface for retrieving the product
  • Director  (Shop)
    • constructs an object using the Builder interface
  • Product  (Vehicle)
    • represents the complex object under construction. ConcreteBuilder builds the product's internal representation and defines the process by which it's assembled
    • includes classes that define the constituent parts, including interfaces for assembling the parts into the final result

Structural code in C#

This structural code demonstrates the Builder pattern in which complex objects are created in a step-by-step fashion. The construction process can create different object representations and provides a high level of control over the assembly of the objects.

  1.      
  3. using System;
  4. using System.Collections.Generic;
  5.  
  6. namespace DoFactory.GangOfFour.Builder.Structural
  7. {
  8.   /// <summary>
  9.   /// MainApp startup class for Structural
  10.   /// Builder Design Pattern.
  11.   /// </summary>
  12.   public class MainApp
  13.   {
  14.     /// <summary>
  15.     /// Entry point into console application.
  16.     /// </summary>
  17.     public static void Main()
  18.     {
  19.       // Create director and builders
  20.       Director director = new Director();
  21.  
  22.       Builder b1 = new ConcreteBuilder1();
  23.       Builder b2 = new ConcreteBuilder2();
  24.  
  25.       // Construct two products
  26.       director.Construct(b1);
  27.       Product p1 = b1.GetResult();
  28.       p1.Show();
  29.  
  30.       director.Construct(b2);
  31.       Product p2 = b2.GetResult();
  32.       p2.Show();
  33.  
  34.       // Wait for user
  35.       Console.ReadKey();
  36.     }
  37.   }
  38.  
  39.   /// <summary>
  40.   /// The 'Director' class
  41.   /// </summary>
  42.   class Director
  43.   {
  44.     // Builder uses a complex series of steps
  45.     public void Construct(Builder builder)
  46.     {
  47.       builder.BuildPartA();
  48.       builder.BuildPartB();
  49.     }
  50.   }
  51.  
  52.   /// <summary>
  53.   /// The 'Builder' abstract class
  54.   /// </summary>
  55.   abstract class Builder
  56.   {
  57.     public abstract void BuildPartA();
  58.     public abstract void BuildPartB();
  59.     public abstract Product GetResult();
  60.   }
  61.  
  62.   /// <summary>
  63.   /// The 'ConcreteBuilder1' class
  64.   /// </summary>
  65.   class ConcreteBuilder1 : Builder
  66.   {
  67.     private Product _product = new Product();
  68.  
  69.     public override void BuildPartA()
  70.     {
  71.       _product.Add("PartA");
  72.     }
  73.  
  74.     public override void BuildPartB()
  75.     {
  76.       _product.Add("PartB");
  77.     }
  78.  
  79.     public override Product GetResult()
  80.     {
  81.       return _product;
  82.     }
  83.   }
  84.  
  85.   /// <summary>
  86.   /// The 'ConcreteBuilder2' class
  87.   /// </summary>
  88.   class ConcreteBuilder2 : Builder
  89.   {
  90.     private Product _product = new Product();
  91.  
  92.     public override void BuildPartA()
  93.     {
  94.       _product.Add("PartX");
  95.     }
  96.  
  97.     public override void BuildPartB()
  98.     {
  99.       _product.Add("PartY");
  100.     }
  101.  
  102.     public override Product GetResult()
  103.     {
  104.       return _product;
  105.     }
  106.   }
  107.  
  108.   /// <summary>
  109.   /// The 'Product' class
  110.   /// </summary>
  111.   class Product
  112.   {
  113.     private List<string> _parts = new List<string>();
  114.  
  115.     public void Add(string part)
  116.     {
  117.       _parts.Add(part);
  118.     }
  119.  
  120.     public void Show()
  121.     {
  122.       Console.WriteLine("\nProduct Parts -------");
  123.       foreach (string part in _parts)
  124.         Console.WriteLine(part);
  125.     }
  126.   }
  127. }
  128.  
  129.  
  130.         
  131.
Output
Product Parts -------
PartA
PartB

Product Parts -------
PartX
PartY

Real-world code in C#

This real-world code demonstates the Builder pattern in which different vehicles are assembled in a step-by-step fashion. The Shop uses VehicleBuilders to construct a variety of Vehicles in a series of sequential steps.

  1.     
  2.    
  3. using System;
  4. using System.Collections.Generic;
  5.  
  6. namespace DoFactory.GangOfFour.Builder.RealWorld
  7. {
  8.   /// <summary>
  9.   /// MainApp startup class for Real-World 
  10.   /// Builder Design Pattern.
  11.   /// </summary>
  12.   public class MainApp
  13.   {
  14.     /// <summary>
  15.     /// Entry point into console application.
  16.     /// </summary>
  17.     public static void Main()
  18.     {
  19.       VehicleBuilder builder;
  20.  
  21.       // Create shop with vehicle builders
  22.       Shop shop = new Shop();
  23.  
  24.       // Construct and display vehicles
  25.       builder = new ScooterBuilder();
  26.       shop.Construct(builder);
  27.       builder.Vehicle.Show();
  28.  
  29.       builder = new CarBuilder();
  30.       shop.Construct(builder);
  31.       builder.Vehicle.Show();
  32.  
  33.       builder = new MotorCycleBuilder();
  34.       shop.Construct(builder);
  35.       builder.Vehicle.Show();
  36.  
  37.       // Wait for user
  38.       Console.ReadKey();
  39.     }
  40.   }
  41.  
  42.   /// <summary>
  43.   /// The 'Director' class
  44.   /// </summary>
  45.   class Shop
  46.   {
  47.     // Builder uses a complex series of steps
  48.     public void Construct(VehicleBuilder vehicleBuilder)
  49.     {
  50.       vehicleBuilder.BuildFrame();
  51.       vehicleBuilder.BuildEngine();
  52.       vehicleBuilder.BuildWheels();
  53.       vehicleBuilder.BuildDoors();
  54.     }
  55.   }
  56.  
  57.   /// <summary>
  58.   /// The 'Builder' abstract class
  59.   /// </summary>
  60.   abstract class VehicleBuilder
  61.   {
  62.     protected Vehicle vehicle;
  63.  
  64.     // Gets vehicle instance
  65.     public Vehicle Vehicle
  66.     {
  67.       get { return vehicle; }
  68.     }
  69.  
  70.     // Abstract build methods
  71.     public abstract void BuildFrame();
  72.     public abstract void BuildEngine();
  73.     public abstract void BuildWheels();
  74.     public abstract void BuildDoors();
  75.   }
  76.  
  77.   /// <summary>
  78.   /// The 'ConcreteBuilder1' class
  79.   /// </summary>
  80.   class MotorCycleBuilder : VehicleBuilder
  81.   {
  82.     public MotorCycleBuilder()
  83.     {
  84.       vehicle = new Vehicle("MotorCycle");
  85.     }
  86.  
  87.     public override void BuildFrame()
  88.     {
  89.       vehicle["frame"] = "MotorCycle Frame";
  90.     }
  91.  
  92.     public override void BuildEngine()
  93.     {
  94.       vehicle["engine"] = "500 cc";
  95.     }
  96.  
  97.     public override void BuildWheels()
  98.     {
  99.       vehicle["wheels"] = "2";
  100.     }
  101.  
  102.     public override void BuildDoors()
  103.     {
  104.       vehicle["doors"] = "0";
  105.     }
  106.   }
  107.  
  108.  
  109.   /// <summary>
  110.   /// The 'ConcreteBuilder2' class
  111.   /// </summary>
  112.   class CarBuilder : VehicleBuilder
  113.   {
  114.     public CarBuilder()
  115.     {
  116.       vehicle = new Vehicle("Car");
  117.     }
  118.  
  119.     public override void BuildFrame()
  120.     {
  121.       vehicle["frame"] = "Car Frame";
  122.     }
  123.  
  124.     public override void BuildEngine()
  125.     {
  126.       vehicle["engine"] = "2500 cc";
  127.     }
  128.  
  129.     public override void BuildWheels()
  130.     {
  131.       vehicle["wheels"] = "4";
  132.     }
  133.  
  134.     public override void BuildDoors()
  135.     {
  136.       vehicle["doors"] = "4";
  137.     }
  138.   }
  139.  
  140.   /// <summary>
  141.   /// The 'ConcreteBuilder3' class
  142.   /// </summary>
  143.   class ScooterBuilder : VehicleBuilder
  144.   {
  145.     public ScooterBuilder()
  146.     {
  147.       vehicle = new Vehicle("Scooter");
  148.     }
  149.  
  150.     public override void BuildFrame()
  151.     {
  152.       vehicle["frame"] = "Scooter Frame";
  153.     }
  154.  
  155.     public override void BuildEngine()
  156.     {
  157.       vehicle["engine"] = "50 cc";
  158.     }
  159.  
  160.     public override void BuildWheels()
  161.     {
  162.       vehicle["wheels"] = "2";
  163.     }
  164.  
  165.     public override void BuildDoors()
  166.     {
  167.       vehicle["doors"] = "0";
  168.     }
  169.   }
  170.  
  171.   /// <summary>
  172.   /// The 'Product' class
  173.   /// </summary>
  174.   class Vehicle
  175.   {
  176.     private string _vehicleType;
  177.     private Dictionary<string,string> _parts = 
  178.       new Dictionary<string,string>();
  179.  
  180.     // Constructor
  181.     public Vehicle(string vehicleType)
  182.     {
  183.       this._vehicleType = vehicleType;
  184.     }
  185.  
  186.     // Indexer
  187.     public string this[string key]
  188.     {
  189.       get { return _parts[key]; }
  190.       set { _parts[key] = value; }
  191.     }
  192.  
  193.     public void Show()
  194.     {
  195.       Console.WriteLine("\n---------------------------");
  196.       Console.WriteLine("Vehicle Type: {0}", _vehicleType);
  197.       Console.WriteLine(" Frame : {0}", _parts["frame"]);
  198.       Console.WriteLine(" Engine : {0}", _parts["engine"]);
  199.       Console.WriteLine(" #Wheels: {0}", _parts["wheels"]);
  200.       Console.WriteLine(" #Doors : {0}", _parts["doors"]);
  201.     }
  202.   }
  203. }
  204.  
  205.  
  206.  
  207.
Output
---------------------------
Vehicle Type: Scooter
 Frame  : Scooter Frame
 Engine : none
 #Wheels: 2
 #Doors : 0

---------------------------
Vehicle Type: Car
 Frame  : Car Frame
 Engine : 2500 cc
 #Wheels: 4
 #Doors : 4

---------------------------
Vehicle Type: MotorCycle
 Frame  : MotorCycle Frame
 Engine : 500 cc
 #Wheels: 2
 #Doors : 0