Decorator Pattern Using Composition Instead of Inheritance

Question

My previous understanding of the decorator pattern was that you inherit Window with WindowDecorator, then in the overridden methods, do some additional work before calling the Window's implementation of said methods. Similar to the following:

public class Window
{
    public virtual void Open()
    {
        // Open the window
    }
}

public class LockableWindow : Window // Decorator
{
    public virtual void Open()
    {
        // Unlock the window
        base.Open();
    }
}

However this essentially hardcodes the decoration, so how would this be refactored to use composition instead of inheritance?

score 7 · Accepted Answer · edited Apr 14 '16 at 21:14

7

Sorry, my C# is a a bit (OK, very) rusty, so there may be a few syntax errors, but the basic idea is right.

public interface IWindow
{
    void Open();
}

public class Window : IWindow
{
    public virtual void Open()
    {
        // Open the window
    }
}

public class LockableWindow : IWindow
{
    private IWindow _wrappedWindow;

    public LockableWindow(IWindow wrappedWindow)
    {
        _wrappedWindow = wrappedWindow;
    }

    public virtual void Open()
    {
        // TODO Unlock window if necessary
        _wrappedWindow.open();
    }
}

The key thing to notice is the new IWindow interface; that's what allows you to keep using polymorphism.

edited Apr 14 '16 at 21:14

Community

1
1

answered May 06 '09 at 11:32

Hank Gay

70,339
36
160
222

Not that rusty, though virtual is not necessary to implement the interface method – Peter Lillevold May 06 '09 at 11:37
Thanks. I haven't written any since .Net 1.0, actually. It's just that this question didn't need any of the new language features. – Hank Gay May 06 '09 at 11:39

score 1 · Answer 2 · answered May 06 '09 at 11:21

The point of the Decorator pattern is to enhance an object with some functionality (e.g. adding buffering to a stream) in a way that's transparent to the caller. In order to use it most effectively, you want to be able to swap in the decorated implementation without refactoring code, which basically implies that you need to maintain the inheritance hierarchy.

What's your actual concern, i.e. what does "this hard-codes the decoration" really mean? What kind of problems do you envision wanting to solve? It may be that decoration is not quite the right approach...

score 0 · Answer 3 · edited Aug 03 '18 at 17:45

My understanding of the decorator pattern is that it is intended to allow a run-time enhancement of an object's capabilities. In the wikipedia explanation, they focus on a component stack for this purpose.

I don't speak C# at all, so this is (obviously) php-ish. It seems that the correct idea would be:

class image{

     function open(){ ... }

} //end of class

class decoratedImage extends image{

     private goodies=array(); //the alleged 'component stack'

     function addGoodie($item){
          $this->goodies[]=$item;
     }

     function open()}{

          parent::open();
          foreach ($this->goodies as $componentClassName){

               $component=new $componentClassName();
               $component->apply($this);

          }

     }

} //end of class

Oh Experienced Ones, please explain the disconnect.

score 0 · Answer 4 · answered May 06 '09 at 11:32

You simply have your LockableWindow define a constructor that takes an instance of the type, Window, that it will decorate. You could also do it via properties.

public class Window
{    
  public virtual void Open()    
  {        
   // Open the window    
  }
}

public class LockableWindow // Decorator
{    
  private Window window;

  public LockableWindow(Window w)
  {
     window = w;
  }      

  public virtual void Open()    
  {        
    // Unlock the window        
    window.Open();    
  }
}

One issue here is that LockableWindow isn't polymorphic to Window. Edit: Just noticed that this was true in the OP. — Michael Blackburn, Sep 15 '11 at 21:18

Decorator Pattern Using Composition Instead of Inheritance

4 Answers4

Linked