Builder (Design Patterns)

definition

Separate the construction of a complex object from its representation so that the same construction process can create different representations. UML class diagram participants     The classes and/or 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 sample 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. using System; using System.Collections.Generic; namespace DoFactory.GangOfFour.Builder.Structural {   /// <summary>   /// MainApp startup class for Structural   /// Builder Design Pattern.   /// </summary>   public class MainApp   {     /// <summary>     /// Entry point into console application.     /// </summary>     public static void Main()     {       // Create director and builders       Director director = new Director();       Builder b1 = new ConcreteBuilder1();       Builder b2 = new ConcreteBuilder2();       // Construct two products       director.Construct(b1);       Product p1 = b1.GetResult();       p1.Show();       director.Construct(b2);       Product p2 = b2.GetResult();       p2.Show();       // Wait for user       Console.ReadKey();     }   }   /// <summary>   /// The 'Director' class   /// </summary>   class Director   {     // Builder uses a complex series of steps     public void Construct(Builder builder)     {       builder.BuildPartA();       builder.BuildPartB();     }   }   /// <summary>   /// The 'Builder' abstract class   /// </summary>   abstract class Builder   {     public abstract void BuildPartA();     public abstract void BuildPartB();     public abstract Product GetResult();   }   /// <summary>   /// The 'ConcreteBuilder1' class   /// </summary>   class ConcreteBuilder1 : Builder   {     private Product _product = new Product();     public override void BuildPartA()     {       _product.Add("PartA");     }     public override void BuildPartB()     {       _product.Add("PartB");     }     public override Product GetResult()     {       return _product;     }   }   /// <summary>   /// The 'ConcreteBuilder2' class   /// </summary>   class ConcreteBuilder2 : Builder   {     private Product _product = new Product();     public override void BuildPartA()     {       _product.Add("PartX");     }     public override void BuildPartB()     {       _product.Add("PartY");     }     public override Product GetResult()     {       return _product;     }   }   /// <summary>   /// The 'Product' class   /// </summary>   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);     }   } } Output Product Parts ------- PartA PartB Product Parts ------- PartX PartY 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. using System; using System.Collections.Generic; namespace DoFactory.GangOfFour.Builder.RealWorld {   /// <summary>   /// MainApp startup class for Real-World   /// Builder Design Pattern.   /// </summary>   public class MainApp   {     /// <summary>     /// Entry point into console application.     /// </summary>     public static void Main()     {       VehicleBuilder builder;       // Create shop with vehicle builders       Shop shop = new Shop();       // Construct and display vehicles       builder = new ScooterBuilder();       shop.Construct(builder);       builder.Vehicle.Show();       builder = new CarBuilder();       shop.Construct(builder);       builder.Vehicle.Show();       builder = new MotorCycleBuilder();       shop.Construct(builder);       builder.Vehicle.Show();       // Wait for user       Console.ReadKey();     }   }   /// <summary>   /// The 'Director' class   /// </summary>   class Shop   {     // Builder uses a complex series of steps     public void Construct(VehicleBuilder vehicleBuilder)     {       vehicleBuilder.BuildFrame();       vehicleBuilder.BuildEngine();       vehicleBuilder.BuildWheels();       vehicleBuilder.BuildDoors();     }   }   /// <summary>   /// The 'Builder' abstract class   /// </summary>   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();   }   /// <summary>   /// The 'ConcreteBuilder1' class   /// </summary>   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";     }   }   /// <summary>   /// The 'ConcreteBuilder2' class   /// </summary>   class CarBuilder : VehicleBuilder   {     public CarBuilder()     {       vehicle = new Vehicle("Car");     }     public override void BuildFrame()     {       vehicle["frame"] = "Car Frame";     }     public override void BuildEngine()     {       vehicle["engine"] = "2500 cc";     }     public override void BuildWheels()     {       vehicle["wheels"] = "4";     }     public override void BuildDoors()     {       vehicle["doors"] = "4";     }   }   /// <summary>   /// The 'ConcreteBuilder3' class   /// </summary>   class ScooterBuilder : VehicleBuilder   {     public ScooterBuilder()     {       vehicle = new Vehicle("Scooter");     }     public override void BuildFrame()     {       vehicle["frame"] = "Scooter Frame";     }     public override void BuildEngine()     {       vehicle["engine"] = "50 cc";     }     public override void BuildWheels()     {       vehicle["wheels"] = "2";     }     public override void BuildDoors()     {       vehicle["doors"] = "0";     }   }   /// <summary>   /// The 'Product' class   /// </summary>   class Vehicle   {     private string _vehicleType;     private Dictionary<string,string> _parts =       new Dictionary<string,string>();     // Constructor     public Vehicle(string vehicleType)     {       this._vehicleType = vehicleType;     }     // Indexer     public string this[string key]     {       get { return _parts[key]; }       set { _parts[key] = value; }     }     public void Show()     {       Console.WriteLine("\n---------------------------");       Console.WriteLine("Vehicle Type: {0}", _vehicleType);       Console.WriteLine(" Frame : {0}", _parts["frame"]);       Console.WriteLine(" Engine : {0}", _parts["engine"]);       Console.WriteLine(" #Wheels: {0}", _parts["wheels"]);       Console.WriteLine(" #Doors : {0}", _parts["doors"]);     }   } } 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 This .NET optimized code demonstrates the same real-world situation as above but uses modern, built-in .NET features, such as, generics, reflection, object initializers, automatic properties, etc.

Abstract Factory (Design Patterns)

definition

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.  UML class diagram participants     The classes and/or objects participating in this pattern are: AbstractFactory  (ContinentFactory) declares an interface for operations that create abstract products ConcreteFactory   (AfricaFactory, AmericaFactory) implements the operations to create concrete product objects AbstractProduct   (Herbivore, Carnivore) declares an interface for a type of product object Product  (Wildebeest, Lion, Bison, Wolf) defines a product object to be created by the corresponding concrete factory implements the AbstractProduct interface Client  (AnimalWorld) uses interfaces declared by AbstractFactory and AbstractProduct classes sample code in C# This structural code demonstrates the Abstract Factory pattern creating parallel hierarchies of objects. Object creation has been abstracted and there is no need for hard-coded class names in the client code. // Abstract Factory pattern -- Structural example using System; namespace DoFactory.GangOfFour.Abstract.Structural {   /// <summary>   /// MainApp startup class for Structural   /// Abstract Factory Design Pattern.   /// </summary>   class MainApp   {     /// <summary>     /// Entry point into console application.     /// </summary>     public static void Main()     {       // Abstract factory #1       AbstractFactory factory1 = new ConcreteFactory1();       Client client1 = new Client(factory1);       client1.Run();       // Abstract factory #2       AbstractFactory factory2 = new ConcreteFactory2();       Client client2 = new Client(factory2);       client2.Run();       // Wait for user input       Console.ReadKey();     }   }   /// <summary>   /// The 'AbstractFactory' abstract class   /// </summary>   abstract class AbstractFactory   {     public abstract AbstractProductA CreateProductA();     public abstract AbstractProductB CreateProductB();   }   /// <summary>   /// The 'ConcreteFactory1' class   /// </summary>   class ConcreteFactory1 : AbstractFactory   {     public override AbstractProductA CreateProductA()     {       return new ProductA1();     }     public override AbstractProductB CreateProductB()     {       return new ProductB1();     }   }   /// <summary>   /// The 'ConcreteFactory2' class   /// </summary>   class ConcreteFactory2 : AbstractFactory   {     public override AbstractProductA CreateProductA()     {       return new ProductA2();     }     public override AbstractProductB CreateProductB()     {       return new ProductB2();     }   }   /// <summary>   /// The 'AbstractProductA' abstract class   /// </summary>   abstract class AbstractProductA   {   }   /// <summary>   /// The 'AbstractProductB' abstract class   /// </summary>   abstract class AbstractProductB   {     public abstract void Interact(AbstractProductA a);   }   /// <summary>   /// The 'ProductA1' class   /// </summary>   class ProductA1 : AbstractProductA   {   }   /// <summary>   /// The 'ProductB1' class   /// </summary>   class ProductB1 : AbstractProductB   {     public override void Interact(AbstractProductA a)     {       Console.WriteLine(this.GetType().Name +         " interacts with " + a.GetType().Name);     }   }   /// <summary>   /// The 'ProductA2' class   /// </summary>   class ProductA2 : AbstractProductA   {   }   /// <summary>   /// The 'ProductB2' class   /// </summary>   class ProductB2 : AbstractProductB   {     public override void Interact(AbstractProductA a)     {       Console.WriteLine(this.GetType().Name +         " interacts with " + a.GetType().Name);     }   }   /// <summary>   /// The 'Client' class. Interaction environment for the products.   /// </summary>   class Client   {     private AbstractProductA _abstractProductA;     private AbstractProductB _abstractProductB;     // Constructor     public Client(AbstractFactory factory)     {       _abstractProductB = factory.CreateProductB();       _abstractProductA = factory.CreateProductA();     }     public void Run()     {       _abstractProductB.Interact(_abstractProductA);     }   } } Output ProductB1 interacts with ProductA1 ProductB2 interacts with ProductA2

This real-world code demonstrates the creation of different animal worlds for a computer game using different factories. Although the animals created by the Continent factories are different, the interactions among the animals remain the same.

// Abstract Factory pattern -- Real World example

using System; namespace DoFactory.GangOfFour.Abstract.RealWorld {   /// <summary>   /// MainApp startup class for Real-World   /// Abstract Factory Design Pattern.   /// </summary>   class MainApp   {     /// <summary>     /// Entry point into console application.     /// </summary>     public static void Main()     {       // Create and run the African animal world       ContinentFactory africa = new AfricaFactory();       AnimalWorld world = new AnimalWorld(africa);       world.RunFoodChain();       // Create and run the American animal world       ContinentFactory america = new AmericaFactory();       world = new AnimalWorld(america);       world.RunFoodChain();       // Wait for user input       Console.ReadKey();     }   }   /// <summary>   /// The 'AbstractFactory' abstract class   /// </summary>   abstract class ContinentFactory   {     public abstract Herbivore CreateHerbivore();     public abstract Carnivore CreateCarnivore();   }   /// <summary>   /// The 'ConcreteFactory1' class   /// </summary>   class AfricaFactory : ContinentFactory   {     public override Herbivore CreateHerbivore()     {       return new Wildebeest();     }     public override Carnivore CreateCarnivore()     {       return new Lion();     }   }   /// <summary>   /// The 'ConcreteFactory2' class   /// </summary>   class AmericaFactory : ContinentFactory   {     public override Herbivore CreateHerbivore()     {       return new Bison();     }     public override Carnivore CreateCarnivore()     {       return new Wolf();     }   }   /// <summary>   /// The 'AbstractProductA' abstract class   /// </summary>   abstract class Herbivore   {   }   /// <summary>   /// The 'AbstractProductB' abstract class   /// </summary>   abstract class Carnivore   {     public abstract void Eat(Herbivore h);   }   /// <summary>   /// The 'ProductA1' class   /// </summary>   class Wildebeest : Herbivore   {   }   /// <summary>   /// The 'ProductB1' class   /// </summary>   class Lion : Carnivore   {     public override void Eat(Herbivore h)     {       // Eat Wildebeest       Console.WriteLine(this.GetType().Name +         " eats " + h.GetType().Name);     }   }   /// <summary>   /// The 'ProductA2' class   /// </summary>   class Bison : Herbivore   {   }   /// <summary>   /// The 'ProductB2' class   /// </summary>   class Wolf : Carnivore   {     public override void Eat(Herbivore h)     {       // Eat Bison       Console.WriteLine(this.GetType().Name +         " eats " + h.GetType().Name);     }   }   /// <summary>   /// The 'Client' class   /// </summary>   class AnimalWorld   {     private Herbivore _herbivore;     private Carnivore _carnivore;     // Constructor     public AnimalWorld(ContinentFactory factory)     {       _carnivore = factory.CreateCarnivore();       _herbivore = factory.CreateHerbivore();     }     public void RunFoodChain()     {       _carnivore.Eat(_herbivore);     }   } }

Output Lion eats Wildebeest Wolf eats Bison

This .NET optimized code demonstrates the same real-world situation as above but uses modern, built-in .NET features, such as, generics, reflection, object initializers, automatic properties, etc.