What does it mean to decorate a class or parameter?

Question

What does it mean to Decorate or add an attribute to a class or parameter?
What's the purpose and when would I do this?

Links to resources and direct answers are welcome.

Solution 1

When You add decorator in C# it is like adding a property to the class/method. There will be an attribute attached to it.

If You write Unit test You will meet a simple decorator TestMethod like that:

[TestMethod]
public void TestMethod1()
{
}

The framework will use the decorators to check what test methods are in the test set.

You can check on the attribute here

There is another nice to read article about Writing Custom Attributes

Decorators are not limited to the '[ ]' form of decorators. There is also a design pattern for that, that was already mentioned before by others.

Solution 2

Decorator was one of the original 23 patterns described in the Gang of Four "Design Patterns" book. They describe it well here.

Summary:

Decorator : Add additional functionality to a class at runtime where subclassing would result in an exponential rise of new classes

Patterns are language agnostic. They are descriptions of solutions to common problems in object-oriented programming. It's possible, even preferred, to discuss them without reference to a particular language. The examples in the original book were written in C++ and Smalltalk. Neither Java nor C# existed when the book was first published in 1995.

Solution 3

Decorating a class means adding functionality to an existing class. For example, you have a class SingingPerson that has a talent of singing.

public class SingingPerson
{
    public string Talent = "I can sing";
    public string DoTalent()
    {
        return Talent;
    }
}

Later on, you decided that the SingingPerson class should also be able to dance but don't want to alter the existing class structure. What you do is you decorate the SingingPerson class by creating another class which contains the added functionality. This new class that you will be creating takes in a SinginPerson object.

public class SingingAndDancingPerson {
    SingingPerson person;
    public string Talent { get; set; }
    public SingingAndDancingPerson(SingingPerson person)
    {
        this.person = person;
    }

    public string DoTalent()
    {
        this.Talent = person.Talent;
        this.Talent += " and dance";
        return this.Talent;
    }
}

When you try to create instances of these classes the output will be the following:

 SingingPerson person1 = new SingingPerson();
        Console.WriteLine("Person 1: " + person1.DoTalent());
        SingingAndDancingPerson person2 = new SingingAndDancingPerson(person1);
        Console.WriteLine("Person 2: " + person2.DoTalent());
        Console.ReadLine();

Comments

[TaW]

But it also means to not subclass, no?

[jmc]

@TaW what do you mean by to not subclass?

[CodingYoshi]

This answer is very misleading. Please see this.

[ntohl]

IMHO Attributes in C# is a form of decorator pattern implementation. with this UML class diagram, the reconciliation is the Decorator class is System.Attribute, the ConcreteDecoratorA is Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttri‌​bute, and the operation is making the method visible to the test runner framework. Because design patterns meant to be for being on the same page when we talk about a thing, it's wrong to say Attributes and Decorators are entirely different concepts.

[ntohl]

The only thing, that is missing from "Attach additional responsibilities to an object dynamically", that it's not runtime. Tho this comment, and the following answers also states my thought about the problem. Since you have to define Decorators design time, the main advantage is reusability, which is the key concept behind Attributes as well. Attaching it runtime is still possible

[CodingYoshi]

So what you are saying is if we decorate a property with [DataMember], we just implemented Decorator Pattern?

[ntohl]

We used an implementation of the Decorator Pattern, which's addedState (from the same UML) is used inside WCF's serialization methods with reflection. And IMHO we should always consider implementing an Attribute if we need a decorator in C#, because of the support of the language.

[Robert Synoradzki]

For this example to be correct, decorating class must be assignable to the decorated type, either by being derived from it, it implementing the same interface. The whole idea of decorating is to be able to: IComputer pc = new Computer().AddMouse().AddKeyboard(); if(deluxe) pc = pc.AddRGBLighting(); This won't work when decorators are external classes.

[RBT]

GoF provided a catalog of 23 patterns and not 26. Kindly correct me if I'm wrong - circle.visual-paradigm.com/catalog