Design Patterns – Builder

Tipologia: Creazionale

Obiettivo: separare la creazione di un oggetto complesso dalla sua rappresentazione in modo da poter creare rappresentazioni differenti

Frequenza di utilizzo: Medio – Bassa

Componenti:

• Builder: definisce l’interfaccia astratta per la creazione di parti di Product
• Director: costruisce l’oggetto Product utilizzando l’interfaccia astratta definita in Builder
• Product: è l’oggetto complesso da costruire. Concrete Builder costruisce la rappresentazione interna dell’oggetto Product e definisce il processo con cui verrà assemblato. Inoltre, include le classi e le interfacce degli elementi costituenti del risultato finale
• Concrete Builder: costruisce e assembla le parti di Product implementando l’interfaccia definita all’interno di Builder. Tiene traccia delle rappresentazioni che sono state create. Definisce un’interfaccia per ottenere Product.

Implementazione in C#

Il primo componente implementato è la classe astratta Builder:

abstract class VehicleBuilder
{
    protected Vehicle vehicle;
 
    // Gets vehicle instance

    public Vehicle Vehicle
    {
      get { return vehicle; }
    }
 
    // Abstract build methods

    public abstract void BuildFrame();
    public abstract void BuildEngine();
    public abstract void BuildWheels();
    public abstract void BuildDoors();
}

nella quale vengono definiti i metodi astratti che dovranno essere implementati. All’interno della classe astratta è anche presente la definizione di un oggetto di tipo Vehicle , accessibile da classi esterne ma solo in modalità read-only.

La seconda classe da implementare è Concrete Builder che implementerà i metodi definiti all’interno della Builder:

class MotorCycleBuilder : VehicleBuilder

  {
    public MotorCycleBuilder()
    {
      vehicle = new Vehicle("MotorCycle");
    }
 
    public override void BuildFrame()
    {
      vehicle["frame"] = "MotorCycle Frame";
    }
 
    public override void BuildEngine()
    {
      vehicle["engine"] = "500 cc";
    }
 
    public override void BuildWheels()
    {
      vehicle["wheels"] = "2";
    }
 
    public override void BuildDoors()
    {
      vehicle["doors"] = "0";
    }
  }

Il compito di questa classe è quello di creare l’oggetto product, definito in questo modo:

class Product
{
    private List<string> _parts = new List<string>();
 
    public void Add(string part)
    {
      _parts.Add(part);
    }
 
    public void Show()
    {
      Console.WriteLine("\nProduct Parts -------");
      foreach (string part in _parts)
        Console.WriteLine(part);
    }
}

Non rimane che definire la classe Director:

class Shop
{
    public void Construct(VehicleBuilder vehicleBuilder)
    {
      vehicleBuilder.BuildFrame();
      vehicleBuilder.BuildEngine();
      vehicleBuilder.BuildWheels();
      vehicleBuilder.BuildDoors();
    }
 }

che ha come parametro un oggetto di tipo Builder .

Builder Pattern può essere richiamato nel modo seguente:

VehicleBuilder builder;
Shop shop = new Shop();
 
builder = new MotorCycleBuilder();
shop.Construct(builder);
builder.Vehicle.Show();