by David Loo | Mar 17, 2013 | Design Patterns
Composite pattern is a collection of objects where one of the objects in the collection can branch out. When using this pattern it usually consist of the following elements a component, leaf and composite.
Component:
- is an abstraction of all components, including the composite ones.
- declares the interface for the objects in the composition.
Leaf:
- represents a leaf object in the composition.
- implements all the Component’s methods.
Composite:
- represents a composite component.
- implements methods for manipulating children.
- implements all Component’s methods
Below are some code snippet taken from the design-patterns repository from my github account, the console application is called Composite and uses a Parent (Composite) and Child (Leaf) objects to represent the use of the pattern.
IMember Interface:
The IMember interface represents the Component and it consist of a method signature called Print(). This interface will be implemented by the Parent and Child class and they will also implement the Print() method for outputing information, but I will explain this later.
using System;
namespace composite
{
public interface IMember
{
void Print();
}
}
(more…)
by David Loo | Sep 10, 2012 | Design Patterns
Facade Pattern is a class (complex system) that contains multiple instances of objects (subsystem) each of these objects has its own methods that perform certain tasks. Inside the complex system class it can have one or more methods that wraps one or more subsystem object methods.
To demonstrate this I will use a Car as an example, building car consist of several process or subsystems to build the parts such as wheels, seats, engines and the body. The main system or complex system is to assemble the car.
Below I have a class called Body, Engine, Seats and Wheels, and each of these class contain a method to add certain parts.
The Body class contains a method called AddBody() which takes a enumerated type of BodyType, the body type can be either a sedan, hatch or a suv.
public class Body
{
public Body ()
{
}
public void AddBody(BodyType bodyType)
{
Console.WriteLine ("{0} Body Added", Enum.GetName(typeof(BodyType), bodyType));
}
}
The Engine class contains a method called AddEngine() which takes an integer value to specify the engine’s cyclinder.
public class Engine
{
public Engine ()
{
}
public void AddEngine(int cyclinders)
{
Console.WriteLine("{0} Cylinder Engine Added", cyclinders.ToString());
}
}
(more…)
by David Loo | Sep 9, 2012 | Design Patterns
An Object Adapters is a wrapper class the wraps an old object that needs data manipulated before the new object can use it, just like you would with a real life object such as an electronic device where main power plugs are different in each country, so you will need a power adapter to plug it in. This post I will demonstrate one type of adapter which is the object adapter, this type of adapter basically contains an instance of the object that needs adapting or also known as the adaptee.
Lets put this into a real word situation where you have an old class called OldPerson which only allows you to set and get a person name by calling a member method called SetFullName() and GetFullName(). In the new system you have a new class called Person which only takes First and Last name as strings. So what do we do you ask, we need to write a PersonAdapter class!
The Person class implements the IPersion interface which contains four methods, SetFirstName(), GetFirstName(), SetLastName() and GetLastName(). In PersonAdapter class we will implement the IPerson interface so that we have the same implementation as Person class.
public class PersonAdapter : IPerson
{
// code here.
}
In the PersonAdapter class constructer we are going to pass the OldPerson object as a parameter and retrieve the person’s full name. By using the string’s Split method we can separate the first and last name and assign it to the private member variables called firstName and LastName.
public PersonAdapter (OldPerson oldPerson)
{
this.oldPerson = oldPerson;
var fullname = this.oldPerson.GetFullName();
this.firstName = fullname.Split(' ')[0];
this.lastName = fullname.Split(' ')[1];
}
(more…)
