Reader Level:
Articles

Wrapper Patterns in C#, Part IV: The Adapter Pattern

By Matthew Cochran on February 16, 2006
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.
  • 0
  • 0
  • 39653
Download Files:
 

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 IV. The Adapter

In our journey through this series we learned how to manifest superpowers with two wrapper-type GOF design patterns.  In part II we looked at the Proxy pattern to reveal protection powers.  In part III we looked at the Decorator to add functional powers.  In this final section we are going to look at the Adapter pattern to see how to implement morphing powers.

Let's start with an INormalDude contract...

public interface INormalDude

{

          string Name { get; set; }

          void Eat();

          void Talk();

}

...and the NormalDude class:

public class NormalDude : INormalDude

{

          private string m_name;

          private string m_thingToSay;

          public string ThingToSay

          {

                    get { return m_thingToSay; }

                    set { m_thingToSay = value; }

          }

          #region INormalDude Members

          public string Name

          {

                    get { return m_name; }

                    set { m_name = value; }

          }

          public void Eat()

          {

                    Console.WriteLine(string.Format("{0}: Please pass the mayo.", m_name));

          }

          public void Talk()

          {

                    Console.WriteLine(string.Format("{0}: {1}", m_name, m_thingToSay));

          }

          #endregion

}


Using our C# wrapping powers we will give our NormalDude the superpower to morph so that wolves think that he is one of them.

Here is our IWolf contract...

public interface IWolf

{

          string FoodSource { get; set; }

          void Devour();

          void Howl();

}

...and the Wolf class:

public class Wolf : IWolf

{

          private string m_foodSource;

          #region IWolf Members

          public string FoodSource

          {

                    get { return m_foodSource; }

                    set { m_foodSource = value; }

          }

          public void Devour()

          {

                    Console.WriteLine(string.Format("Wolf: This wolf is devouring {0}.", m_foodSource));

          }

          public void Howl()

          {

                    Console.WriteLine("Wolf: Aaaaaaaaaaaarrrrrrrrrrrooooooooooooo!");

          }

          #endregion

}

Now we need to wrap our Normal dude so that he implements the IWolf interface.  Do you see how we are wrapping the NormalDude in the code below and then expressing some of his functionality through the IWolf interface?

public class DudeWolfAdapter : INormalDude, IWolf

{

          private INormalDude m_dude;

          private string m_foodSource;

          public DudeWolfAdapter(INormalDude dude)

          {

          m_dude = dude;

          }

          #region INormalDude Members

          public string Name

          {

                    get { return m_dude.Name; }

                    set { m_dude.Name = value; }

          }

          public void Eat()

          {

                    m_dude.Eat();

          }

          public void Talk()

          {

                    m_dude.Talk();

          }

          #endregion

          #region IWolf Members

          public string FoodSource

          {

                    get { return m_foodSource; }

                    set { m_foodSource = value; }

          }

          public void Devour()

          {

                    m_dude.Eat();

                    Console.WriteLine(string.Format("{0}: Is there any way we can get this cooked?", Name));

          }

          public void Howl()

          {

                    m_dude.Talk();

          }

          #endregion

}

Here are our results:

wrapper4-1.gif

In Conclusion

Although Super Bill has not quite adapted the social graces required by the pack, he can still blend in. This sample show us how we can use our C# wrapping powers to change the way objects look so we can disguise them as anything.

Wrap Up

The three patterns we looked at all utilize a basic wrapping pattern and are pretty much the same except for the functionality they provide.

The Proxy is a wrapper that limits access to an object or can be utilized as a stand-in to be used in place of the object.  The Decorator is a wrapper that adds additional functionality to an object.  And finally, the Adapter is a wrapper that helps one object integrate with any other object's interface.

One thing we need to be careful of is to only use wrappers where they are needed because our code can become increasingly complex and difficult to maintain (especially by other more junior developers from non OOP backgrounds who don't fully understand patterns).  We should always look at all the ways we have to give our objects super powers.   If there is a simpler way to achieve the same result, it is probably a better route to take.
 
I hope you enjoyed this series and have a better understanding of wrappers and specifically the Proxy, Decorator, and Adapter patterns.

Until next time,

-Only use your powers for good

COMMENT USING

Trending up