10 Advanced Windsor Tricks – 4. How to register and use decorators

Here’s part four of (at least) 10 Advanced Windsor Tricks.

The decorator pattern is an old friend from the Gang of Four book and goes back to the earliest days of Object Oriented programming. It’s a very simple but powerful idea. Let’s remember our old friend ThingOne:

public class ThingOne : IThing
{
    public string SayHello(string name)
    {
        return string.Format("ThingOne says hello to {0}", name);
    }
}

A decorator is a class that both implements an interface and has a reference to it. This is so that it can pretend to be something else and intercept any calls made to the wrapped instance. Here’s an IThing decorator:

public class ThingDecorator : IThing
{
    private readonly IThing thing;

    public ThingDecorator(IThing thing)
    {
        this.thing = thing;
    }

    public string SayHello(string name)
    {
        Console.WriteLine("Before calling wrapped IThing");
        var message = thing.SayHello(name);
        Console.WriteLine("After calling wrapped IThing");
        return message;
    }
}

A decorator can do anything it likes before and after the call to the wrapped class including altering its arguments and/or return value. There is much discussion of AOP these days and heavyweight frameworks like PostSharp; indeed Windsor itself is an excellent AOP framework; but often a decorator is a much simpler solution to these kinds of interception requirements. Don’t get me wrong though, I think PostSharp is the bees knees :)

Now we can compose the decorator with the target and allow the decorator to intercept calls to the target:

var thing = new ThingDecorator(new ThingOne());
Console.WriteLine(thing.SayHello("Roger"));

Which will print out:

Before calling wrapped IThing
After calling wrapped IThing
ThingOne says hello to Roger

Windsor makes working with decorators a breeze. You don’t have to explicitly wire up the decorator with a service override, simply order the registrations with the outermost decorator first and Windsor will magically wire them up for you. So to register ThingDecorator and ThingOne just do the following:

var container = new WindsorContainer()
    .Register(
        Component.For<IThing>().ImplementedBy<ThingDecorator>(),
        Component.For<IThing>().ImplementedBy<ThingOne>()
    );

var thing = container.Resolve<IThing>();

Console.WriteLine(thing.SayHello("Roger"));

This prints out the same result as the code above.

Now, let’s introduce a second decorator:

public class ThingDecorator2 : IThing
{
    private readonly IThing thing;

    public ThingDecorator2(IThing thing)
    {
        this.thing = thing;
    }

    public string SayHello(string name)
    {
        return thing.SayHello(name + " has been altered by ThingDecorator2... ha ha ha!");
    }
}

When we register this decorator as well we get just the effect we expect:

public void decorator_should_work_without_any_special_registration()
{
    var container = new WindsorContainer()
        .Register(
            Component.For<IThing>().ImplementedBy<ThingDecorator>(),
            Component.For<IThing>().ImplementedBy<ThingDecorator2>(),
            Component.For<IThing>().ImplementedBy<ThingOne>()
        );

    var thing = container.Resolve<IThing>();

    Console.WriteLine(thing.SayHello("Roger"));
}

This prints out:

Before calling wrapped IThing
After calling wrapped IThing
ThingOne says hello to Roger has been altered by ThingDecorator2... ha ha ha!

It’s nice, in fact it’s cooler than a Shaft and Fonz love child :)