Decorator Pattern question C# / java

I was looking at this wikipedia article, and couldn't understand how the hell that was working. A little bit frustrated not being able to understand the code just by looking at it, i dedided to port the code to c# (i'm .net, sorry guys :)). Just some minor modifications were needed (inherits and extends, base for super, etc) and run the app. To my surprise, i got the following output :

Cost: 1 Ingredient: Coffee
Cost: 1 Ingredient: Coffee
Cost: 1 Ingredient: Coffee
Cost: 1 Ingredient: Coffee

Just curious, can any java dev tell me what's different here and why the wikipedia example works (if it does work as they say it does, of course)开发者_运维技巧.

    namespace ConsoleApplication1
{
 class Program
 {
  static void Main(string[] args)
  {

  Coffee sampleCoffee = new SimpleCoffee();
  Console.WriteLine("Cost: " + sampleCoffee.getCost() + " Ingredient: " + sampleCoffee.getIngredient());

        sampleCoffee = new Milk(sampleCoffee);
        Console.WriteLine("Cost: " + sampleCoffee.getCost() + " Ingredient: " + sampleCoffee.getIngredient());

        sampleCoffee = new Sprinkles(sampleCoffee);
        Console.WriteLine("Cost: " + sampleCoffee.getCost() + " Ingredient: " + sampleCoffee.getIngredient());

        sampleCoffee = new Whip(sampleCoffee);
        Console.WriteLine("Cost: " + sampleCoffee.getCost() + " Ingredient: " + sampleCoffee.getIngredient());

   Console.ReadKey();

  }
 }



//The Coffee Interface defines the functionality of Coffee implemented by decorator
public interface Coffee
{

    double getCost(); // returns the cost of coffee

    String getIngredient(); //returns the ingredients mixed with coffee
}

//implementation of simple coffee without any extra ingredients
public class SimpleCoffee : Coffee
{

    double cost;
    String ingredient;

    public SimpleCoffee()
    {
        cost = 1;
        ingredient = "Coffee";
    }

    public double getCost()
    {
        return cost;
    }

    public String getIngredient()
    {
        return ingredient;
    }
}



//abstract decorator class - note that it implements coffee interface
abstract public class CoffeeDecorator : Coffee
{

    protected Coffee decoratedCoffee;
    protected String ingredientSeparator;

    public CoffeeDecorator(Coffee decoratedCoffee)
    {
        this.decoratedCoffee = decoratedCoffee;
        ingredientSeparator = ", ";
    }

 public CoffeeDecorator()
 {

 }

    public double getCost() //note it implements the getCost function defined in interface Coffee
    {
        return decoratedCoffee.getCost();
    }

    public String getIngredient()
    {
        return decoratedCoffee.getIngredient();
    }
}

//Decorator Milk that mixes milk with coffee
//note it extends CoffeeDecorator
public class Milk : CoffeeDecorator
{

    double cost;
    String ingredient;

    public Milk(Coffee decoratedCoffee) : base(decoratedCoffee)
    {
        cost = 0.5;
        ingredient = "Milk";
    }

    public double getCost()
    {
        return base.getCost() + cost;
    }

    public String getIngredient()
    {
        return base.getIngredient() + base.ingredientSeparator + ingredient;
    }
}

//Decorator Whip that mixes whip with coffee
//note it extends CoffeeDecorator
public class Whip : CoffeeDecorator
{

    double cost;
    String ingredient;

 public Whip(Coffee decoratedCoffee)
  : base(decoratedCoffee)
    {
        cost = 0.7;
        ingredient = "Whip";
    }

    public double getCost()
    {
        return base.getCost() + cost;
    }

    public String getIngredient()
    {
        return base.getIngredient() + base.ingredientSeparator + ingredient;
    }
}

//Decorator Sprinkles that mixes sprinkles with coffee
//note it extends CoffeeDecorator
public class Sprinkles : CoffeeDecorator
{

    double cost;
    String ingredient;

    public Sprinkles(Coffee decoratedCoffee) : base(decoratedCoffee)
    {

        cost = 0.2;
        ingredient = "Sprinkles";
    }

    public double getCost()
    {
  return base.getCost() + cost;
    }

    public String getIngredient()
    {
  return base.getIngredient() + base.ingredientSeparator + ingredient;
    }
}

}

---

Yes - methods are virtual by default in Java, but not in C#.

You should have received warnings when compiling your code, talking about the "new" modifier. That should have given you a clue. Currently your Milk (etc) methods are hiding or shadowing those in CoffeeDecorator - they're not being called polymorphically.

You'd need to make the CoffeeDecorator methods virtual with the virtual modifier, and then explicitly override them in Milk (etc) with the override modifier.

// In CoffeeDecorator
public virtual double getCost()
{
    return decoratedCoffee.getCost();
}

// In Milk
public override double getCost()
{
    return base.getCost() + cost;
}

---

You forgot to declare getCost and getIngredient virtual and use the override keyword in the derived verions. The way you did it, you just "overload" the methods.

---

You're hitting CoffeeDecorator's getCost() method rather than the implementing class' getCost() method .. you need to look at how you're overriding the method.

---

It's a bit verbose example but I think I can explain the pattern in 2 lines. Decorator pattern allow you to wrap existing implementation of interface. Other name of the pattern is wrapper.

For example you have interface Foo:

interface Foo {
    public int foo();
}

class SimpleFoo implements Foo {
    public int foo() {
        return 1;
    }
}

The SimpleFoo.foo() always returns 1;

Here is the simple decarator:

class DoubleFoo implements Foo {
    private Foo payload;
    public DoubleFoo(Foo payload) {
        this.payload = payload;
    }
    public int foo() {
        return 2 * payload.foo();
    }
}

DoubleFoo.foo() decorates the payload Foo. It multiplies the result by 2.

Obviously it can also replace the implementation of payload by its own implementation. but it is not a classic case of the pattern.

The most well known example of usage of this pattern is IO in java: streams, readers and writers are all wrappers. For example BufferedReader adds functionality to payload reader: it reads data to buffers.