In this article I am trying to demonstrate the usage of Builder Patter using a Computer Assembling Robot. Builder Pattern is one among the 23 patters by Gang Of Four.
Definition of Builder
The GoF says that the Builder design patterns let you “Separate the construction of a complex object from its representation so that the same construction processes can create different representations.”
Problem to Solve
In a computer manufacturing unit, depending on the configuration – they have to create computers. The challenge is that the computer parts are chosen in the runtime. The order can contain n number of computers based on the same configuration. This could be the right example to implement the Builder pattern where each robot will be setup with a particular computer configuration. The robot will continue creating the same configuration based computer n times.
Processor: Intel / AMD
Monitor: Samsung / LG
Speakers: Yes / No
The Windows Form UI allows the user to choose the configuration. The virtual factory provides upto 3 robots to be added before the actual assembling takes place.
Following is the screen shot of the main class named Robot. The class contains a property called Peripherals which can be used to configure the peripherals added: like CPU as Intel, Monitor as Samsung etc.
After adding the peripherals, we can call the Create() method. It will iterate through the Peripherals dictionary and calls the appropriate methods to integrate the peripherals. This allows us to choose the peripherals at run time as well as the sequence too.
If the Peripheral dictionary contains CPU then the AssembleCPU() method is invoked.
If the Peripheral dictionary contains Monitor then the AssembleMonitor () method is invoked.
public partial class Robot : UserControl
/// Dictionary containing peripheral and the option
public Dictionary<Peripheral, string> Peripherals = new Dictionary<Peripheral, string>();
/// The core method used to create different representations
public void Create()
// Create new Computer
_computer = new Bitmap(Images.Computer);
foreach (Peripheral peripheral in Peripherals.Keys)
if (peripheral == Peripheral.Processor)
if (peripheral == Peripheral.Monitor)
if (peripheral == Peripheral.Speakers)
private Bitmap _computer;
private PictureBox _pictureBox;
private void AddToStore()
_pictureBox = new PictureBox();
_pictureBox.BorderStyle = BorderStyle.FixedSingle;
_pictureBox.Image = _computer;
_pictureBox.Height = _computer.Height;
_pictureBox.Width = _computer.Width;
MyDelegate del = new MyDelegate(AddToParent);
IAsyncResult result = Store.BeginInvoke(del);
// As no stop button provided we have to abort the thread
private void AddToParent()
if (Store.Controls.Count > 1)
Control lastControl = Store.Controls[Store.Controls.Count – 2];
_pictureBox.Top = lastControl.Top + lastControl.Height + 1;
private delegate void MyDelegate();
private const int Delay = 500;
public void AssembleCPU(string model)
AddLog("Assembling CPU " + model + "..");
public void AssembleMonitor(string model)
AddLog("Assembling Monitor " + model + "..");
public void AssembleSpeakers(string model)
AddLog("Assembling Speakers " + model + "..");
if (model == "Stereo")
_computer = new Bitmap(Images.ComputerWith2Speaker);
_computer = new Bitmap(Images.ComputerWithSurroundSpeakers);
private void AddLog(string msg)
LogBox.SelectedIndex = LogBox.Items.Count – 1;
The class Peripheral is an enumeration as following:
public enum Peripheral
You can find the entire article and source code in c-sharpcorner.com