Did you ever wish for a superhuman power to be impervious to bullets or travel outside your body? How about the superpower to be able to breathe underwater or fly? Or how about a changing the way you look so you can disguise yourself as anyone, or anything? In this series of four articles, we will travel down the C# rabbit hole and see how it is all possible with some wrapper patterns: Proxy, Decorator, and Adapter.
Part III. The Decorator
In part II we looked at the Proxy pattern. The proxy pattern is a wrapper that limits access to the wrapped object. This time we're going to look at extending the functionality of the wrapped object with the Decorator. This time we'll use our wrapper power to extend the functionality of an object in order to manifest the ability to breathe underwater or fly.
First, let's get a basic contract for a NormalDude again. Our NormalDude interface has two things the Dudes Name and the ability to Move();
public interface INormalDude
{
string Name { get; set; }
void Move();
}
Here is our NormalDude that implements our INormalDude interface. Notice that when moving the NormalDude just walks.
public class NormalDude : INormalDude
{
private string m_name;
#region INormalDude Members
public string Name
{
get { return m_name; }
set { m_name = value; }
}
public void Move()
{
Console.WriteLine(string.Format("{0} is walkin'", Name));
}
#endregion
}
Now, due to some freak meteor dust from outer space we need to extend our normal dudes Move() powers to enable him to breathe under water. First let's look at the UnderwaterBreather decorator wrapper. Both the NormalDude and the UnderwaterBreather have the ability to Move() which is the functionality we are extending. Can you see how we are wrapping the NormalDude in the code below?
public class UnderwaterBreather : INormalDude
{
public INormalDude m_NormalDude;
public void WrapDude(INormalDude dude)
{
m_NormalDude = dude;
}
public void BreathUnderwater()
{
Console.WriteLine(string.Format("{0} is breathing underwater.", Name));
}
#region INormalDude Members
public string Name
{
get{ return m_NormalDude.Name; }
set{ m_NormalDude.Name = value;}
}
public void Move()
{
m_NormalDude.Move();
BreathUnderwater();
}
#endregion
}
Due to some freak radation from an industrial strength microwave, our NormalDude will also need the functionality to fly as well. Here's the Flyer wrapper.
public class Flyer : INormalDude
{
public INormalDude m_NormalDude;
public void WrapDude(INormalDude dude)
{
m_NormalDude = dude;
}
#region INormalDude Members
public string Name
{
get{ return m_NormalDude.Name; }
set{ m_NormalDude.Name = value;}
}
public void Move()
{
m_NormalDude.Move();
Fly();
}
#endregion
public void Fly()
{
Console.WriteLine(string.Format("{0} is flying.", Name));
}
}
Last, but not least, we have to wrap it up and implement our UnderwaterBreather and Flyer.
INormalDude Mark =
new NormalDude();
Mark.Name = "Mark";
Mark.Move();
Console.WriteLine();
UnderwaterBreather SuperpowerWrapperA = new UnderwaterBreather();
Flyer SuperpowerWrapperB = new Flyer();
SuperpowerWrapperA.WrapDude(Mark);
Mark = SuperpowerWrapperA;
Mark.Move();
Console.WriteLine();
SuperpowerWrapperB.WrapDude(SuperpowerWrapperA);
Mark = SuperpowerWrapperB;
Mark.Move();
Here are the results:
In Conclusion
Life may be a bit difficult for Mark from this point onwards because every time he tries to move he walks, flies, and breathes underwater at the same time, but that's the price for having superpowers using the decorator pattern in C# world.
Next time we'll look at the morphing powers gained from wrapping objects with the Adapter Pattern.
Until then,
-Only use your powers for good