Yet Another Lesson about Design Patterns

• Download DecoratorPattern.zip - 79.5 KB

Introduction                                    

I am back today with a new old topic: Design Patterns! So this started with an article posted by a good friend of mine about his way of implementing the factory pattern.

Although there is nothing to approach about his way, something kept itching me to write a second article about another design pattern that might fit in this situation as well.

Let’s start by reviewing the task:

The Straw hats pirates (the pirate crew in the one piece anime) contacted my company to write a software to automate pizza preparation. Sanji explained that in order to prepare pizza, we need to:

1. Prepare the pizza dough
2. Prepare the sauce
3. Add pizza sauce and pizza ingredients according to each person’s desires
4. Put the pizza in the oven

In order to complete the task, my friend wrote a Pizza maker base class where inherited classes redefine the AddIngredient method to suit each person’s choices.

For example, if the person is Nami, then ingredients will be cheese and olives. To add his own touch, my friend added a configuration section to make class adding totally on the fly. There is no doubt that the solution is flexible and neat but what happens when more people join in the team? Or when current crew feels like tasting something new? Are we going to create sub classes for each possibility like this:

It’s sure not a good solution because with 3 ingredients (Olive, cheese and meat), we can have up to 7 different combinations (result = n! / [(n-k)! k!] Where n is total number of ingredients and k is the number of the picked ingredients), Imagine what will happen with 4 or 5 ingredients => explosion in number of sub classes.

What should we do then? It’s time to introduce the Decorator Pattern!

The decorator pattern attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

Don’t worry if you don’t understand this, I myself didn’t when I first read it but this example will help clear things for us.

Component: is the father of all, can exist on his own or equipped with decorators.

ConcreteComponent: son of component, can do more cool stuff than his old father.

Decorator: sort of the mother of all decorators, it teaches them the ABCs of life without precising how to act.

ConcreteDecorator: the real deal where decorator operations are defined.

Let’s put this in action and see what we get:

Explanation

Our main goal is to treat all pizza objects the same (this is why everything inherits from Pizza class) and provide a mecanism to decorate our objects in a way that makes them different from one another.

The Pizza here is your component, it’s the base class of the object you want to decorate.

    public class Pizza
    {
        public void PreparePizza()
        {
        }
 
        private void AddSauce()
        {
        }
 
        public virtual void MakeDough()
        {
        }
 
        private void PutInOven()
        {
        }
 
        private void PrepareSauce()
        {
        }
 
        public virtual string GetIngredients()
        {
            return "Pizza with ";
        }
    } 

Three classes derive directly from Pizza: the first two (CrustyDoughPizza and ThickDoughPizza) are considered ConcreteComponents since they extend Pizza’s behavior (Exp: creates a different more delicious dough).

    public class ThickDoughPizza : Pizza
    {
        public override void MakeDough()
        {
            //Make thick dough
        }
 
        public override string GetIngredients()
        {
            return "Thick Dough Pizza with ";
        }
    } 

    public class CrustyDoughPizza : Pizza
    {
        public override void MakeDough()
        {
            //Make CrustyDough
        }
 
        public override string GetIngredients()
        {
            return "Crusty Dough Pizza with ";
        }
    } 

    public abstract class PizzaIngredient : Pizza
    {
        public Pizza MyPizza {get; set;}
        public override abstract string GetIngredients();
    }  

    public class Cheese : PizzaIngredient
    {
        public Cheese(Pizza pizza)
        {
            MyPizza = pizza;
        }
 
        public override string GetIngredients()
        {
            return MyPizza.GetIngredients() + " Cheese";
        }
     }  

   public class Olive : PizzaIngredient
    {
        public Olive(Pizza pizza)
        {
            MyPizza = pizza;
        }
 
        public override string GetIngredients()
        {
            return MyPizza.GetIngredients() + " Olive";
        } 
    }

       public class Meat : PizzaIngredient
    {
        public Meat(Pizza pizza)
        {
            MyPizza = pizza;
        }
        public override string GetIngredients()
        {
            return MyPizza.GetIngredients() + " Meat";
        }
    }

CrustyDoughPizza myPizza = new CrustyDoughPizza();
//Decorate the pizza with olive
Olive olivePizza = new Olive(myPizza);
var pizzaIngredients = olivePizza.GetIngredients();
//expected answer = Crusty pizza with olive

ThickDoughPizza myPizza = new ThickDoughPizza();
//Decorate the pizza with Meat
Meat pizzaWithMeat = new Meat(myPizza);
//Decorate the pizza with cheese
Cheese pizzaWithCheese = new Cheese(pizzaWithMeat);
var pizzaIngredients = pizzaWithCheese.GetIngredients();
//expected answer = Crusty pizza with meat cheese