Jean Paul's Blog

There are 2 types of People in the World, One who Likes SharePoint and..

  • Microsoft MVP

  • MindCracker MVP

  • CodeProject MVP

  • eBook on SharePoint 2010

  • eBook on Design Patterns

  • eBook on Windows Azure

  • NLayers Framework @ CodePlex

  • MSDN Forums

  • .Net vs. Java

    Due to Public Demand
  • Advertisements

Builder Pattern through a Robot Example

Posted by Paul on October 8, 2010

Builder Pattern

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.

Computer Peripherals

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.


Code Explained

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


        /// <summary>

        /// Dictionary containing peripheral and the option

        /// </summary>

        public Dictionary<Peripheral, string> Peripherals = new Dictionary<Peripheral, string>();


        /// <summary>

        /// The core method used to create different representations

        /// </summary>

        public void Create()


            while (true)


                // 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)









        public Robot()





        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);

                while (!result.IsCompleted)





                // 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


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s