设计模式系列二结构型之（装饰者模式）

1、装饰者模式简介

• 动态地给一个对象添加一些额外的职责。

适用性：

• 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
• 处理那些可以撤消的职责。
• 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

2、生活实例

3、装饰者模式结构

4、示意代码

// "Component"
abstract class Component
{
     public abstract void Operation();
}

// "ConcreteComponent"
class ConcreteComponent : Component
{
     public override void Operation()
    {
         Console.WriteLine("ConcreteComponent.Operation()");
    }
}

// "Decorator"
abstract class Decorator : Component
{
    protected Component component;
    public void SetComponent(Component component)
    {
        this.component = component;
    }
     public override void Operation()
     {
         if (component != null)
         {
             component.Operation();
         }
     }
 }    

// "ConcreteDecoratorA"
class ConcreteDecoratorA : Decorator
{
　　private string addedState;
　　public override void Operation()
　　{
　　　　 base.Operation();
　　　　 addedState = "New State";
　　　　 Console.WriteLine("ConcreteDecoratorA.Operation()");
   }
}
// "ConcreteDecoratorB"
class ConcreteDecoratorB : Decorator
{ 　
　　public override void Operation()
　　{
　　　　base.Operation();
　　　　AddedBehavior();
　　　　Console.WriteLine("ConcreteDecoratorB.Operation()");
　　}
 　void AddedBehavior()
　　{ }
 } 

class MainApp
{
 　　static void Main()
　　 { 　　　　　　// Create ConcreteComponent and two Decorators
　　 　　ConcreteComponent c = new ConcreteComponent();
　　　　 ConcreteDecoratorA d1 = new ConcreteDecoratorA();
 　　　　ConcreteDecoratorB d2 = new ConcreteDecoratorB();
　　　　// Link decorators
 　　　　d1.SetComponent(c);
　　　　 d2.SetComponent(d1);
        d2.Operation();

　　　　 Console.Read(); } }

4、总结

• 装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。
• 装饰对象包含一个真实对象的引用（reference）;
• 装饰对象接受所有来自客户端的请求，把这些请求转发给真实对象；
• 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。

适用场景：

• 需要扩展一个类的功能，或给一个类添加附加职责。
• 需要动态的给一个对象添加功能，这些功能可以再动态的撤销。
• 需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。
• 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。