Design Patterns #6 - The Decorator Pattern

The Decorator Pattern is a simple pattern that allows the developer to add responsibilities to an object dynamically. This pattern is useful for extending classes that are locked by use of the "sealed" keyword. The UML diagram for this pattern looks something like this..

An example implimentation would be similar to...

using System;
using System.Collections.Generic;
using System.Text;

namespace garyshort.org.patterns.decorator
{
    //GS - Define our decorator
    public class DecoratoredDateTime
    {
        protected DateTime _itemToDecorate;

        /// <summary>
        /// GS - Construct the decorator passing the object to decorate
        /// </summary>
        /// <param name="aDateTime">DateTime</param>
        public DecoratoredDateTime(DateTime aDateTime)
        {
            _itemToDecorate = aDateTime;
        }

        /// <summary>
        /// GS - Answer whether or not the decorated DateTime 
        /// is a holiday or not
        /// </summary>
        public bool isHoliday
        {
            get
            {
                //GS - Simulate a database lookup or similar here
                Random rnd = new Random();
                return (rnd.Next() % 2) == 0;
            }
        }

        /// <summary>
        /// GS - Answer the short date string of the 
        /// underlying DateTime
        /// </summary>
        /// <returns>string</returns>
        public string ToShortDateString()
        {
            return _itemToDecorate.ToShortDateString();
        }
    }
    
    /// <summary>
    /// GS - Demonstrate adding the knowledge of whether or not a  
    /// DateTime is a holiday to the DateTime struct
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            //GS - Create a DateTime
            DateTime aDateTime = DateTime.Now;

            //GS - Create the decorator so we can add behaviour to 
            //the DateTime
            DecoratoredDateTime aDecoratedDateTime = 
                new DecoratoredDateTime(aDateTime);

            //GS - Ask the decorated DateTime if it is a holiday 
            //date or not
            if (aDecoratedDateTime.isHoliday)
            {
                Console.WriteLine(aDecoratedDateTime.ToShortDateString() +
                    " is a holiday");
            }

            else
            {
                Console.WriteLine(aDecoratedDateTime.ToShortDateString() + 
                    " is not a holiday");
            }

            //GS - Wait for the user to press a key before closing 
            //the DOS box
            Console.Read();
        }
    }
}

Update: Of course the real power of this pattern lies in implementing interfaces so that multiple decorators can be applied to a decorated class. I didn't include that here, for brevity, but there is a good example provided by Greg.

Technorati tags: C#, Design Patterns, The Decorator Pattern

Print | posted on Tuesday, June 26, 2007 10:06 AM

Comments on this post

#

@Greg, I've updated my entry to link to your fuller example using interfaces.

Left by Gary Short on Jul 06, 2007 10:07 AM

@Gary - Thanks for the plug! I cleaned up the code I posted in your comments and posted it to my own blog. The entry is at: http://samuraiprogrammer.com/community/blogs/greg/archive/2007/07/05/Design-Pattern_3A00_--Decorator-Pattern.aspx

If you'd like to update your entry.

Thanks!
Greg

Left by Greg on Jul 05, 2007 4:07 PM

@Greg - thanks, yep your example looks like what i was expecting to see. Being able to combine decorators as in your example is where the real power of the decorator pattern comes from. It would be nice if the original article could be updated to include some mention/example of this.

Left by Stephen on Jul 05, 2007 8:07 AM

@Stephen, done! @Greg, thanks for the example, I've pointed to your comment in the main article.

Left by Gary Short on Jul 05, 2007 8:07 AM

@Stephen, no you understand the pattern correctly. The full implementation would declare an interface that both the original and the decorator would implement. I did not implement the pattern this way in this post because the post was already fairly long and commentors have said in the past that short posts are better so I decided not to write and implement the interfaces. I think - as Greg says - you still get the spirit of the pattern from this post.

@Stephen - I think Gary is following the pattern in spirit, if not in exact implementation.

I've seen the Decorator Pattern used a great deal in financial applications. It provides a nice way of adding fees and taxes and what-not at run-time, without muddy'ing up your "Calculate()" method with a lot of conditional expressions. For example:

'// Start with the interface
Public Interface IMortgageBill

Function Calculate() As Decimal

End Interface

'// Then create an abstract class, implementing the Interface.
Public MustInherit Class AMortgageBillDecorator
Implements IMortgageBill

Protected _bill As IMortgageBill

Public Sub New(ByVal decoratedBill As IMortgageBill)
_bill = decoratedBill
End Sub

Public MustOverride Function Calculate() _
As Decimal Implements IMortgageBill.Calculate
End Class

'// Then you have a base class - something that you will want to
'// decorate.
Public Class RegularPayment
Implements IMortgageBill

Public Function Calculate() As Decimal Implements IMortgageBill.Calculate
Return New Decimal(5)
End Function
End Class

'// Then you can create an overabundance of decorators - here's
'// two.

'// The LateMortgageBillDecorator
Public Class LatePaymentDecorator
Inherits AMortgageBillDecorator

Public Sub New(ByVal decoratedBill As IMortgageBill)
MyBase.New(decoratedBill)
End Sub

Public Overrides Function Calculate() As Decimal
Return Me._bill.Calculate + New Decimal(5)
End Function
End Class

'// And the California Tax Decorator
Public Class CaliforniaTaxDecorator
Inherits AMortgageBillDecorator

Public Sub New(ByVal decoratedBill As AMortgageBillDecorator)
MyBase.New(decoratedBill)
End Sub

Public Overrides Function Calculate() As Decimal
Return Me._bill.Calculate() + New Decimal(5)
End Function
End Class

'// Then you simply write the code to instantiate these guys:
Sub Main()
Dim payment As IMortgageBill

payment = New RegularMortgageBill()

If True = True Then
'// If user paid late last month.
payment = New LatePaymentDecorator(payment)
End If

If True = True Then
'// If user is in California
payment = New CaliforniaTaxDecorator(payment)
End If

System.Console.WriteLine("Payment: " & _
payment.Calculate().ToString)
System.Console.ReadLine()

End Sub

As you can see - this is very powerful stuff.

Great post Gary!

- Greg

Left by Greg on Jul 05, 2007 6:07 AM

I don't think you've understood the Decorator pattern correctly (or possibly I don't?).

I thought that the Decorator class should implement the same interface as the object it wraps - this allows the client to use either the original object or a decorated version of the object interchangably. It also allows multiple decorators to be combined in any combination.

See http://en.wikipedia.org/wiki/Decorator_pattern for more details.

Left by Stephen on Jul 05, 2007 2:07 AM

Cheers mate!

Left by Gary Short on Jul 03, 2007 3:07 PM

Dzoned, finally.

Left by Barry Carr on Jul 03, 2007 3:07 PM

garyshort.org

Archives

Post Categories

Design Patterns #6 - The Decorator Pattern

Comments on this post

#

#

#

#

#

#

#

#

#

Your comment: