装饰模式（Decorator/Wrapper Pattern）

抽象构件（Component）角色：给出一个抽象接口，以规范准备接收附加责任的对象。

具体构件（Concrete Component）角色：定义一个将要接收附加责任的类。

装饰（Decorator）角色：持有一个构件（Component）对象的实例，并定义一个与抽象构件接口一致的接口。

具体装饰（Concrete Decorator）角色：负责给构件对象"贴上"附加的责任。 

 

// Decorator pattern -- Structural example  
using System;

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

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

// "Decorator"
abstract class Decorator : Component
...{
  // Fields
  protected Component component;

  // Methods
  public void SetComponent( Component component )
  ...{
    this.component = component;
  }

  override public void Operation()
  ...{
    if( component != null )
      component.Operation();
  }
}

// "ConcreteDecoratorA"
class ConcreteDecoratorA : Decorator
...{
  // Fields
  private string addedState;

  // Methods
  override public void Operation()
  ...{
    base.Operation();
    addedState = "new state";
    Console.WriteLine("ConcreteDecoratorA.Operation()");
  }
}

// "ConcreteDecoratorB"
class ConcreteDecoratorB : Decorator
...{
  // Methods
  override public void Operation()
  ...{
    base.Operation();
    AddedBehavior();
    Console.WriteLine("ConcreteDecoratorB.Operation()");
  }

  void AddedBehavior()
  ...{
  }
}

/**//**//**//// <summary>
/// Client test
/// </summary>
public class Client
...{
  public static void Main( string[] args )
  ...{
    // 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();
  }
}

 

在以下情况下应当使用装饰模式：

1. 需要扩展一个类的功能，或给一个类增加附加责任。
2. 需要动态地给一个对象增加功能，这些功能可以再动态地撤销。
3. 需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变得不现实。

装饰模式实际应用的例子,该例子演示了通过装饰模式为图书馆的图书与录像带添加"可借阅"装饰。

 

// Decorator pattern -- Real World example  
using System;
using System.Collections;

// "Component"
abstract class LibraryItem
...{
  // Fields
  private int numCopies;

  // Properties
  public int NumCopies
  ...{
    get...{ return numCopies; }
    set...{ numCopies = value; }
  }

  // Methods
  public abstract void Display();
}

// "ConcreteComponent"
class Book : LibraryItem
...{
  // Fields
  private string author;
  private string title;

  // Constructors
  public Book(string author,string title,int numCopies)
  ...{
    this.author = author;
    this.title = title;
    this.NumCopies = numCopies;
  }

  // Methods
  public override void Display()
  ...{
    Console.WriteLine( " Book ------ " );
    Console.WriteLine( " Author: {0}", author );
    Console.WriteLine( " Title: {0}", title );
    Console.WriteLine( " # Copies: {0}", NumCopies );
  }
}

// "ConcreteComponent"
class Video : LibraryItem
...{
  // Fields
  private string director;
  private string title;
  private int playTime;

  // Constructor
  public Video( string director, string title,
    int numCopies, int playTime )
  ...{
    this.director = director;
    this.title = title;
    this.NumCopies = numCopies;
    this.playTime = playTime;
  }

  // Methods
  public override void Display()
  ...{
    Console.WriteLine( " Video ----- " );
    Console.WriteLine( " Director: {0}", director );
    Console.WriteLine( " Title: {0}", title );
    Console.WriteLine( " # Copies: {0}", NumCopies );
    Console.WriteLine( " Playtime: {0}", playTime );
  }
}

// "Decorator"
abstract class Decorator : LibraryItem
...{
  // Fields
  protected LibraryItem libraryItem;

  // Constructors
  public Decorator ( LibraryItem libraryItem )
  ...{ this.libraryItem = libraryItem; }

  // Methods
  public override void Display()
  ...{ libraryItem.Display(); }
}

// "ConcreteDecorator"
class Borrowable : Decorator
...{
  // Fields
  protected ArrayList borrowers = new ArrayList();

  // Constructors
  public Borrowable( LibraryItem libraryItem )
    : base( libraryItem ) ...{}

  // Methods
  public void BorrowItem( string name )
  ...{
    borrowers.Add( name );
    libraryItem.NumCopies--;
  }

  public void ReturnItem( string name )
  ...{
    borrowers.Remove( name );
    libraryItem.NumCopies++;
  }

  public override void Display()
  ...{
    base.Display();
    foreach( string borrower in borrowers )
      Console.WriteLine( " borrower: {0}", borrower );
  }
}
 
/**//**//**//// <summary>
///  DecoratorApp test
/// </summary>
public class DecoratorApp
...{
  public static void Main( string[] args )
  ...{
    // Create book and video and display
    Book book = new Book( "Schnell", "My Home", 10 );
    Video video = new Video( "Spielberg",
      "Schindler's list", 23, 60 );
    book.Display();
    video.Display();

    // Make video borrowable, then borrow and display
    Console.WriteLine( " Video made borrowable:" );
    Borrowable borrowvideo = new Borrowable( video );
    borrowvideo.BorrowItem( "Cindy Lopez" );
    borrowvideo.BorrowItem( "Samuel King" );

    borrowvideo.Display();
  }
}

 

使用装饰模式主要有以下的优点：

1. 装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。
2. 通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。
3. 这种比继承更加灵活机动的特性，也同时意味着装饰模式比继承更加易于出错。

使用装饰模式主要有以下的缺点：

由于使用装饰模式，可以比使用继承关系需要较少数目的类。使用较少的类，当然使设计比较易于进行。但是，在另一方面，使用装饰模式会产生比使用继承关系更多的对象。更多的对象会使得查错变得困难，特别是这些对象看上去都很相像。