装饰者模式(Decorator Pattern)

傷城~ 2022-04-12 11:57 172阅读 0赞

[设计模式 - 吕震宇][-]

[.NET设计模式系列文章][.NET]

[薛敬明的专栏][Link 1]

[乐在其中设计模式(C\#)][C]

# [C\#设计模式（12）－Decorator Pattern][C_12_Decorator Pattern]    #

## 一、 装饰（Decorator）模式 ##

装饰（Decorator）模式又名包装（Wrapper）模式\[GOF95\]。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。

**引言**

孙悟空有七十二般变化，他的每一种变化都给他带来一种附加的本领。他变成鱼儿时，就可以到水里游泳；他变成雀儿时，就可以在天上飞行。而不管悟空怎么变化，在二郎神眼里，他永远是那只猢狲。

装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不使用创造更多子类的情况下，将对象的功能加以扩展。

##    二、 装饰模式的结构 ##

装饰模式使用原来被装饰的类的一个子类的实例，把客户端的调用委派到被装饰类。装饰模式的关键在于这种扩展是完全透明的。

在孙猴子的例子里，老孙变成的鱼儿相当于老孙的子类，这条鱼儿与外界的互动要通过"委派"，交给老孙的本尊，由老孙本尊采取行动。

装饰模式的类图如下图所示：

![Pic64.gif][]

在装饰模式中的各个角色有：

*  抽象构件（Component）角色：给出一个抽象接口，以规范准备接收附加责任的对象。
 *  具体构件（Concrete Component）角色：定义一个将要接收附加责任的类。
 *  装饰（Decorator）角色：持有一个构件（Component）对象的实例，并定义一个与抽象构件接口一致的接口。
 *  具体装饰（Concrete Decorator）角色：负责给构件对象"贴上"附加的责任。

##    三、 装饰模式示例性代码 ##

以下示例性代码实现了装饰模式：

![None.gif][] //  Decorator pattern -- Structural example    
![None.gif][] using  System;  
![None.gif][]  
![None.gif][] //  "Component"   
![None.gif][] abstract  class  Component  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Methods  
![InBlock.gif][]abstractpublicvoid Operation();  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  "ConcreteComponent"   
![None.gif][] class  ConcreteComponent : Component  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Methods  
![InBlock.gif][]overridepublicvoid Operation()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] Console.WriteLine("ConcreteComponent.Operation()");  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  "Decorator"   
![None.gif][] abstract  class  Decorator : Component  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Fields  
![InBlock.gif][]protected Component component;  
![InBlock.gif][]  
![InBlock.gif][]// Methods  
![InBlock.gif][]publicvoid SetComponent( Component component )  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]this.component = component;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]overridepublicvoid Operation()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]if( component !=null )  
![InBlock.gif][] component.Operation();  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  "ConcreteDecoratorA"   
![None.gif][] class  ConcreteDecoratorA : Decorator  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Fields  
![InBlock.gif][]privatestring addedState;  
![InBlock.gif][]  
![InBlock.gif][]// Methods  
![InBlock.gif][]overridepublicvoid Operation()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]base.Operation();  
![InBlock.gif][] addedState ="new state";  
![InBlock.gif][] Console.WriteLine("ConcreteDecoratorA.Operation()");  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  "ConcreteDecoratorB"   
![None.gif][] class  ConcreteDecoratorB : Decorator  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Methods  
![InBlock.gif][]overridepublicvoid Operation()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]base.Operation();  
![InBlock.gif][] AddedBehavior();  
![InBlock.gif][] Console.WriteLine("ConcreteDecoratorB.Operation()");  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]void AddedBehavior()  
![ExpandedSubBlockStart.gif][]\{  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![ExpandedBlockStart.gif][] ///<summary>  
![InBlock.gif][]/// Client test  
![ExpandedBlockEnd.gif][]///</summary>  
![None.gif][] public  class  Client  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]publicstaticvoid Main( string\[\] args )  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]// Create ConcreteComponent and two Decorators  
![InBlock.gif][] ConcreteComponent c =new ConcreteComponent();  
![InBlock.gif][] ConcreteDecoratorA d1 =new ConcreteDecoratorA();  
![InBlock.gif][] ConcreteDecoratorB d2 =new ConcreteDecoratorB();  
![InBlock.gif][]  
![InBlock.gif][]// Link decorators  
![InBlock.gif][] d1.SetComponent( c );  
![InBlock.gif][] d2.SetComponent( d1 );  
![InBlock.gif][]  
![InBlock.gif][] d2.Operation();  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}

上面的代码在执行装饰时是通过SetComponent方法实现的，在实际应用中，也有通过构造函数实现的，一个典型的创建过程可能如下：

![None.gif][] new  Decorator1(  
![None.gif][] new  Decorator2(  
![None.gif][] new  Decorator3(  
![None.gif][] new  ConcreteComponent()  
![None.gif][] )  
![None.gif][] )  
![None.gif][] )

装饰模式常常被称为包裹模式，就是因为每一个具体装饰类都将下一个具体装饰类或者具体构件类包裹起来。

##    四、 装饰模式应当在什么情况下使用 ##

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

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

## 五、 装饰模式实际应用的例子 ##

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

![None.gif][] //  Decorator pattern -- Real World example    
![None.gif][] using  System;  
![None.gif][] using  System.Collections;  
![None.gif][]  
![None.gif][] //  "Component"   
![None.gif][] abstract  class  LibraryItem  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Fields  
![InBlock.gif][]privateint numCopies;  
![InBlock.gif][]  
![InBlock.gif][]// Properties  
![InBlock.gif][]publicint NumCopies  
![ExpandedSubBlockStart.gif][]\{  
![ExpandedSubBlockStart.gif][]get\{ return numCopies; \}  
![ExpandedSubBlockStart.gif][]set\{ numCopies = value; \}  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]// Methods  
![InBlock.gif][]publicabstractvoid Display();  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  "ConcreteComponent"   
![None.gif][] class  Book : LibraryItem  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Fields  
![InBlock.gif][]privatestring author;  
![InBlock.gif][]privatestring title;  
![InBlock.gif][]  
![InBlock.gif][]// Constructors  
![InBlock.gif][]public Book(string author,string title,int numCopies)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]this.author = author;  
![InBlock.gif][]this.title = title;  
![InBlock.gif][]this.NumCopies = numCopies;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]// Methods  
![InBlock.gif][]publicoverridevoid Display()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] Console.WriteLine( " Book ------ " );  
![InBlock.gif][] Console.WriteLine( " Author: \{0\}", author );  
![InBlock.gif][] Console.WriteLine( " Title: \{0\}", title );  
![InBlock.gif][] Console.WriteLine( " \# Copies: \{0\}", NumCopies );  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  "ConcreteComponent"   
![None.gif][] class  Video : LibraryItem  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Fields  
![InBlock.gif][]privatestring director;  
![InBlock.gif][]privatestring title;  
![InBlock.gif][]privateint playTime;  
![InBlock.gif][]  
![InBlock.gif][]// Constructor  
![InBlock.gif][]public Video( string director, string title,  
![InBlock.gif][]int numCopies, int playTime )  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]this.director = director;  
![InBlock.gif][]this.title = title;  
![InBlock.gif][]this.NumCopies = numCopies;  
![InBlock.gif][]this.playTime = playTime;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]// Methods  
![InBlock.gif][]publicoverridevoid Display()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] Console.WriteLine( " Video ----- " );  
![InBlock.gif][] Console.WriteLine( " Director: \{0\}", director );  
![InBlock.gif][] Console.WriteLine( " Title: \{0\}", title );  
![InBlock.gif][] Console.WriteLine( " \# Copies: \{0\}", NumCopies );  
![InBlock.gif][] Console.WriteLine( " Playtime: \{0\}", playTime );  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  "Decorator"   
![None.gif][] abstract  class  Decorator : LibraryItem  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Fields  
![InBlock.gif][]protected LibraryItem libraryItem;  
![InBlock.gif][]  
![InBlock.gif][]// Constructors  
![InBlock.gif][]public Decorator ( LibraryItem libraryItem )  
![ExpandedSubBlockStart.gif][]\{ this.libraryItem = libraryItem; \}  
![InBlock.gif][]  
![InBlock.gif][]// Methods  
![InBlock.gif][]publicoverridevoid Display()  
![ExpandedSubBlockStart.gif][]\{ libraryItem.Display(); \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![None.gif][] //  "ConcreteDecorator"   
![None.gif][] class  Borrowable : Decorator  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]// Fields  
![InBlock.gif][]protected ArrayList borrowers =new ArrayList();  
![InBlock.gif][]  
![InBlock.gif][]// Constructors  
![InBlock.gif][]public Borrowable( LibraryItem libraryItem )  
![ExpandedSubBlockStart.gif][] : base( libraryItem ) \{\}  
![InBlock.gif][]  
![InBlock.gif][]// Methods  
![InBlock.gif][]publicvoid BorrowItem( string name )  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] borrowers.Add( name );  
![InBlock.gif][] libraryItem.NumCopies\--;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]publicvoid ReturnItem( string name )  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] borrowers.Remove( name );  
![InBlock.gif][] libraryItem.NumCopies\++;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]publicoverridevoid Display()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]base.Display();  
![InBlock.gif][]foreach( string borrower in borrowers )  
![InBlock.gif][] Console.WriteLine( " borrower: \{0\}", borrower );  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]  
![ExpandedBlockStart.gif][] ///<summary>  
![InBlock.gif][]/// DecoratorApp test  
![ExpandedBlockEnd.gif][]///</summary>  
![None.gif][] public  class  DecoratorApp  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]publicstaticvoid Main( string\[\] args )  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]// Create book and video and display  
![InBlock.gif][] Book book =new Book( "Schnell", "My Home", 10 );  
![InBlock.gif][] Video video =new Video( "Spielberg",  
![InBlock.gif][]"Schindler's list", 23, 60 );  
![InBlock.gif][] book.Display();  
![InBlock.gif][] video.Display();  
![InBlock.gif][]  
![InBlock.gif][]// Make video borrowable, then borrow and display  
![InBlock.gif][] Console.WriteLine( " Video made borrowable:" );  
![InBlock.gif][] Borrowable borrowvideo =new Borrowable( video );  
![InBlock.gif][] borrowvideo.BorrowItem( "Cindy Lopez" );  
![InBlock.gif][] borrowvideo.BorrowItem( "Samuel King" );  
![InBlock.gif][]  
![InBlock.gif][] borrowvideo.Display();  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}

##    六、 使用装饰模式的优点和缺点 ##

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

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

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

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

##    七、 模式实现的讨论 ##

大多数情况下，装饰模式的实现都比上面定义中给出的示意性实现要简单。对模式进行简化时需要注意以下的情况：

（1）一个装饰类的接口必须与被装饰类的接口相容。

（2）尽量保持Component作为一个"轻"类，不要把太多的逻辑和状态放在Component类里。

（3）如果只有一个ConcreteComponent类而没有抽象的Component类（接口），那么Decorator类经常可以是ConcreteComponent的一个子类。如下图所示：

![Pic65.gif][]

（4）如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。

##    八、 透明性的要求 ##

**透明的装饰模式**

装饰模式通常要求针对抽象编程。装饰模式对客户端的透明性要求程序不要声明一个ConcreteDecorator类型的变量，而应当声明一个Component类型的变量。换言之，下面的做法是对的：

![None.gif][] Component c  =  new  ConcreteComponent()；  
![None.gif][]Component c1  =  new  ConcreteDecorator1(c)；  
![None.gif][]Component c2  =  new  ConcreteDecorator(c1)；

而下面的做法是不对的：

![None.gif][] ConcreteComponent c  =  new  ConcreteDecorator()；

这就是前面所说的，装饰模式对客户端是完全透明的含义。

用孙悟空的例子来说，必须永远把孙悟空的所有变化都当成孙悟空来对待，而如果把老孙变成的雀儿当成雀儿，而不是老孙，那就被老孙骗了，而这是不应当发生的。

下面的做法是不对的：

![None.gif][] 大圣本尊 c  =  new  大圣本尊()；  
![None.gif][]雀儿 bird  =  new  雀儿 (c)；

**半透明的装饰模式**

然而，纯粹的装饰模式很难找到。装饰模式的用意是在不改变接口的前提下，增强所考虑的类的性能。在增强性能的时候，往往需要建立新的公开的方法。即便是在孙大圣的系统里，也需要新的方法。比如齐天大圣类并没有飞行的能力，而雀儿有。这就意味着雀儿应当有一个新的fly()方法。

这就导致了大多数的装饰模式的实现都是"半透明"（semi-transparent）的，而不是完全"透明"的。换言之，允许装饰模式改变接口，增加新的方法。即声明ConcreteDecorator类型的变量，从而可以调用ConcreteDecorator类中才有的方法：

![None.gif][] 齐天大圣 c  =  new  大圣本尊()；  
![None.gif][]雀儿 bird  =  new  雀儿(c)；  
![None.gif][]bird.fly()；

齐天大圣接口根本没有fly()这个方法，而雀儿接口里有这个方法。

##    九、 装饰模式在.NET中的应用 ##

.net中存在如下类模型：

![Pic66.gif][]

下面的代码段用来将XmlDocument的内容格式输出。我们可以体会Decorator模式在这里所起的作用。

![None.gif][] //  生成ConcreteComponent（内存流ms）   
![None.gif][] MemoryStream ms  =  new  MemoryStream();  
![None.gif][]  
![None.gif][] //  用XmlTextWriter对内存流 ms 进行装饰  
![None.gif][] //  此处使用了半透明的装饰模式   
![None.gif][] XmlTextWriter xtw  =  new  XmlTextWriter(ms, Encoding.UTF8);  
![None.gif][]xtw.Formatting  =  Formatting.Indented;  
![None.gif][]  
![None.gif][] //  对装饰xtw的操作会转而操作本体－内存流ms   
![None.gif][] xmlDoc.Save(xtw);  
![None.gif][]  
![None.gif][] byte \[\] buf  =  ms.ToArray();  
![None.gif][]txtResult.Text  =  Encoding.UTF8.GetString(buf, 0 ,buf.Length);  
![None.gif][]xtw.Close();

--------------------

参考文献：  
阎宏，《Java与模式》，电子工业出版社  
\[美\]James W. Cooper，《C\#设计模式》，电子工业出版社  
\[美\]Alan Shalloway James R. Trott，《Design Patterns Explained》，中国电力出版社  
\[美\]Robert C. Martin，《敏捷软件开发－原则、模式与实践》，清华大学出版社  
\[美\]Don Box, Chris Sells，《.NET本质论 第1卷：公共语言运行库》，中国电力出版社

# [.NET设计模式（10）：装饰模式（Decorator Pattern）][.NET_10_Decorator Pattern] #

### 装饰模式（Decorator Pattern） ###

——.NET设计模式系列之十

Terrylee，2006年3月

**概述**

在软件系统中，有时候我们会使用继承来扩展对象的功能，但是由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响将为最低？这就是本文要讲的Decorator模式。

**意图**

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。\[GOF 《设计模式》\]

**结构图**

![Decorator_02.gif][]

图1 Decorator模式结构图

**生活中的例子**

装饰模式动态地给一个对象添加额外的职责。不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。

![Decorator_01.jpg][]

图2 使用有画框的画作为例子的装饰模式对象图

**装饰模式解说**

在软件开发中，经常会遇到动态地为一个对象而不是整个类增加一些功能的问题，还是以我惯用的记录日志的例子来说明吧（也许在Decorator模式里面用这个例子不是特别合适）。现在要求我们开发的记录日志的组件，除了要支持数据库记录DatabaseLog和文本文件记录TextFileLog两种方式外，我们还需要在不同的应用环境中增加一些额外的功能，比如需要记录日志信息的错误严重级别，需要记录日志信息的优先级别，还有日志信息的扩展属性等功能。在这里，如果我们不去考虑设计模式，解决问题的方法其实很简单，可以通过继承机制去实现，日志类结构图如下：

![Decorator_03.jpg][]

图3

实现代码如下：

public abstractclassLog

public  abstract void Write(string log);

public classDatabaseLog :Log

public  override void Write(string log)

//......记录到数据库中

public classTextFileLog :Log

public  override void Write(string log)

//......记录到文本文件中

需要记录日志信息的错误严重级别功能和记录日志信息优先级别的功能，只要在原来子类DatabaseLog和TextFileLog的基础上再生成子类即可，同时需要引进两个新的接口IError和I Priority，类结构图如下：

![Decorator_04.jpg][]

图4

实现代码如下：

public interfaceIError

void SetError();

public interfaceIPriority

void SetPriority();

public classDBErrorLog :DatabaseLog,IError

public  override void Write(string log)

base.Write(log);

public  void SetError()

//......功能扩展，实现了记录错误严重级别

public classDBPriorityLog :DatabaseLog,IPriority

public  override void Write(string log)

base.Write(log);

public  void SetPriority()

//......功能扩展，实现了记录优先级别

public classTFErrorLog :TextFileLog,IError

public  override void Write(string log)

base.Write(log);

public  void SetError()

//......功能扩展，实现了记录错误严重级别

public classTFPriorityLog :TextFileLog,IPriority

public  override void Write(string log)

base.Write(log);

public  void SetPriority()

//......功能扩展，实现了记录优先级别

此时可以看到，如果需要相应的功能，直接使用这些子类就可以了。这里我们采用了类的继承方式来解决了对象功能的扩展问题，这种方式是可以达到我们预期的目的。然而，它却带来了一系列的问题。首先，前面的分析只是进行了一种功能的扩展，如果既需要记录错误严重级别，又需要记录优先级时，子类就需要进行接口的多重继承，这在某些情况下会违反类的单一职责原则，注意下图中的蓝色区域：

![Decorator_05.jpg][]

图5

实现代码：

public classDBEPLog :DatabaseLog,IError,IPriority

public  override void Write(string log)

SetError();

SetPriority();

base.Write(log);

public  void SetError()

//......功能扩展，实现了记录错误严重级别

public  void SetPriority()

//......功能扩展，实现了记录优先级别

public classTFEPLog :DatabaseLog,IError,IPriority

public  override void Write(string log)

SetError();

SetPriority();

base.Write(log);

public  void SetError()

//......功能扩展，实现了记录错误严重级别

public  void SetPriority()

//......功能扩展，实现了记录优先级别

其次，随着以后扩展功能的增多，子类会迅速的膨胀，可以看到，子类的出现其实是DatabaseLog和TextFileLog两个子类与新增加的接口的一种排列组合关系，所以类结构会变得很复杂而难以维护，正如象李建忠老师说的那样“子类复子类，子类何其多”；最后，这种方式的扩展是一种静态的扩展方式，并没有能够真正实现扩展功能的动态添加，客户程序不能选择添加扩展功能的方式和时机。

现在又该是Decorator模式出场的时候了，解决方案是把Log对象嵌入到另一个对象中，由这个对象来扩展功能。首先我们要定义一个抽象的包装类LogWrapper，让它继承于Log类，结构图如下：

![Decorator_061.jpg][]

图6

实现代码如下：

public abstractclassLogWrapper :Log

private  Log \_log;

public LogWrapper(Log log)

\_log = log;

public  override void Write(string log)

\_log.Write(log);

现在对于每个扩展的功能，都增加一个包装类的子类，让它们来实现具体的扩展功能，如下图中绿色的区域：

![Decorator_071.jpg][]

图7

实现代码如下：

public classLogErrorWrapper :LogWrapper

public LogErrorWrapper(Log \_log)

:base(\_log)

public  override void Write(string log)

SetError(); //......功能扩展

base.Write(log);

public  void SetError()

//......实现了记录错误严重级别

public classLogPriorityWrapper :LogWrapper

public LogPriorityWrapper(Log \_log)

: base(\_log)

public  override void Write(string log)

SetPriority(); //......功能扩展

base.Write(log);

public  void SetPriority()

//......实现了记录优先级别

到这里，LogErrorWrapper类和LogPriorityWrapper类真正实现了对错误严重级别和优先级别的功能的扩展。我们来看一下客户程序如何去调用它：

public classProgram

public  static void Main(string\[\] args)

Log log =  new DatabaseLog();

LogWrapper lew1 =  new LogErrorWrapper(log);

//扩展了记录错误严重级别

lew1.Write("Log Message");

LogPriorityWrapper lpw1 =newLogPriorityWrapper(log);

//扩展了记录优先级别

lpw1.Write("Log Message");

LogWrapper lew2 =  new LogErrorWrapper(log);

LogPriorityWrapper lpw2 =newLogPriorityWrapper(lew2);//这里是lew2

//同时扩展了错误严重级别和优先级别

lpw2.Write("Log Message");

注意在上面程序中的第三段装饰才真正体现出了Decorator模式的精妙所在，这里总共包装了两次：第一次对log对象进行错误严重级别的装饰，变成了lew2对象，第二次再对lew2对象进行装饰，于是变成了lpw2对象，此时的lpw2对象同时扩展了错误严重级别和优先级别的功能。也就是说我们需要哪些功能，就可以这样继续包装下去。到这里也许有人会说LogPriorityWrapper类的构造函数接收的是一个Log对象，为什么这里可以传入LogErrorWrapper对象呢？通过类结构图就能发现，LogErrorWrapper类其实也是Log类的一个子类。

我们分析一下这样会带来什么好处？首先对于扩展功能已经实现了真正的动态增加，只在需要某种功能的时候才进行包装；其次，如果再出现一种新的扩展功能，只需要增加一个对应的包装子类（注意：这一点任何时候都是避免不了的），而无需再进行很多子类的继承，不会出现子类的膨胀，同时Decorator模式也很好的符合了面向对象设计原则中的“优先使用对象组合而非继承”和“开放-封闭”原则。

**.NET中的装饰模式**

1．.NET中Decorator模式一个典型的运用就是关于Stream，它存在着如下的类结构：

![Decorator_081.jpg][]

图8

可以看到， BufferedStream和CryptoStream其实就是两个包装类，这里的Decorator模式省略了抽象装饰角色（Decorator），示例代码如下：

class Program

public  static void Main(string\[\] args)

MemoryStream ms =

new  MemoryStream(new  byte\[\] \{ 100,456,864,222,567\});

//扩展了缓冲的功能

BufferedStream buff =  new BufferedStream(ms);

//扩展了缓冲，加密的功能

CryptoStream crypto =  new CryptoStream(buff);

通过反编译，可以看到BufferedStream类的代码（只列出部分），它是继承于Stream类：

public sealedclassBufferedStream : Stream

// Methods

private BufferedStream();

public BufferedStream(Stream stream);

public BufferedStream(Stream stream,int bufferSize);

// Fields

private  int \_bufferSize;

private Stream \_s;

2．在Enterprise Library中的DAAB中有一个DbCommandWrapper的包装类，它实现了对IDbCommand类的包装并提供了参数处理的功能。结构图如下：

![Decorator_091.jpg][]

图9

示意性代码如下：

public abstractclassDBCommandWrapper :MarshalByRefObject,IDisposable

public classSqlCommandWrapper :DBCommandWrapper

public classOracleCommandWrapper :DBCommandWrapper

**效果及实现要点**

1．Component类在Decorator模式中充当抽象接口的角色，不应该去实现具体的行为。而且Decorator类对于Component类应该透明，换言之Component类无需知道Decorator类，Decorator类是从外部来扩展Component类的功能。

2．Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。我们可以使用一个或者多个Decorator对象来“装饰”一个Component对象，且装饰后的对象仍然是一个Component对象。

3．Decortor模式并非解决“多子类衍生的多继承”问题，Decorator模式的应用要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。

4．对于Decorator模式在实际中的运用可以很灵活。如果只有一个ConcreteComponent类而没有抽象的Component类，那么Decorator类可以是ConcreteComponent的一个子类。

![Decorator_101.jpg][]

图10

如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。

![Decorator_111.jpg][]

图11

5．Decorator模式的优点是提供了比继承更加灵活的扩展，通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合。

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

**适用性**

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

1.需要扩展一个类的功能，或给一个类增加附加责任。

2.需要动态地给一个对象增加功能，这些功能可以再动态地撤销。

3.需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变得不现实。

**总结**

Decorator模式采用对象组合而非继承的手法，实现了在运行时动态的扩展对象功能的能力，而且可以根据需要扩展多个功能，避免了单独使用继承带来的“灵活性差”和“多子类衍生问题”。同时它很好地符合面向对象设计原则中“优先使用对象组合而非继承”和“开放-封闭”原则。

**参考资料**

阎宏，《Java与模式》，电子工业出版社

James W. Cooper，《C\#设计模式》，电子工业出版社

Alan Shalloway James R. Trott，《Design Patterns Explained》，中国电力出版社

MSDN WebCast 《C\#面向对象设计模式纵横谈(10) Decorator装饰模式(结构型模式)》

作者： [TerryLee][]  
出处： [http://terrylee.cnblogs.com][TerryLee]  
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

# 测试输出    #

using System;
    using System.Collections.Generic;
    using System.Text;
    
    namespace DecoratorPatternTest
    {
        // Component
        public abstract class Log
        {
            public Log()
            {
                Console.WriteLine("[Log]:Constructor.");
            }
    
            public abstract void WriteLog(string log);
        }
    
        //Concrete component
        public class DatabaseLog : Log
        {
            public DatabaseLog()
            {
                Console.WriteLine("[DatabaseLog]:Constructor.");
            }
    
            public override void WriteLog(string log)
            {
                Console.WriteLine("[DatabaseLog]:" + log);
            } 
        }
    
        //Concrete component
        public class TextLog : Log
        {
            public TextLog()
            {
                Console.WriteLine("[TextLog]:Constructor.");
            }
    
            public override void WriteLog(string log)
            {
                Console.WriteLine("[TextLog]:" + log);
            }
        }
    
        //Decorator
        public abstract class LogWrapper : Log
        {
            private Log _log;
    
            public LogWrapper(Log log)
            {
                this._log = log;
    
                Console.WriteLine("[LogWrapper]:Constructor.");
            }
    
            public override void WriteLog(string log)
            {
                Console.WriteLine("[LogWrapper]:" + log);           //9,此行屏蔽
                this._log.WriteLog(log);
            }
        }
    
        //Concrete Decorator
        public class LogErrorWrapper : LogWrapper
        {
            public LogErrorWrapper(Log log)
                : base(log)
            {
                Console.WriteLine("[LogErrorWrapper]:Constructor.");
            }
    
            public override void WriteLog(string log)
            {
                Console.WriteLine("[LogErrorWrapper.Error]:" + log);
                base.WriteLog(log);
            }
        }
    
        //Concrete Decorator
        public class LogPriorityWrapper:LogWrapper
        {
            public LogPriorityWrapper(Log log)
                : base(log)
            {
                Console.WriteLine("[LogPriorityWrapper]:Constructor."); 
            }
    
            public override void WriteLog(string log)
            {
                Console.WriteLine("[LogPriorityWrapper.Priority]:" + log); 
                base.WriteLog(log);
            }
        }
        
        class Program
        {
            static void Main(string[] args)
            {
                Log log = new DatabaseLog();                                            //1
                LogWrapper lew1 = new LogErrorWrapper(log);                             //2
                lew1.WriteLog("Log Message Error.");                                    //3
    
                LogPriorityWrapper lpw1 = new LogPriorityWrapper(log);                  //4
                lpw1.WriteLog("Log Message Priority.");                                 //5
    
                LogWrapper lew2 = new LogErrorWrapper(log);                             //6
                LogPriorityWrapper lpw2 = new LogPriorityWrapper(lew2);                 //7
                lpw2.WriteLog("Log Message Error and Priority.");                       //8
    
                Console.Read();
            }
        }
    }

输出情况:(每行对应的输出情况)

![1357711786_7202.png][]

//9,屏蔽下的输出,(红线部分,通过装饰,扩展后的新功能)

![1357711852_5135.png][]

## [乐在其中设计模式(C\#) - 装饰模式(Decorator Pattern)][C_ - _Decorator Pattern] ##

乐在其中设计模式(C\#) - 装饰模式(Decorator Pattern)

作者： [webabcd][]  
  
  
介绍  
动态地给一个对象添加一些额外的职责。就扩展功能而言，它比生成子类方式更为灵活。  
  
  
示例  
有一个Message实体类，某个对象对它的操作有Insert()和Get()方法，现在扩展这个对象的功能。  
![o_Decorator.png][]  
  
  
MessageModel

![None.gif][] using  System;  
![None.gif][] using  System.Collections.Generic;  
![None.gif][] using  System.Text;  
![None.gif][]  
![None.gif][] namespace  Pattern.Decorator  
![ExpandedBlockStart.gif][] \{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// Message实体类  
![ExpandedSubBlockEnd.gif][]///</summary>  
![InBlock.gif][]publicclass MessageModel  
![ExpandedSubBlockStart.gif][]\{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 构造函数  
![InBlock.gif][]///</summary>  
![InBlock.gif][]///<param name="msg">Message内容</param>  
![ExpandedSubBlockEnd.gif][]///<param name="pt">Message发布时间</param>  
![InBlock.gif][]public MessageModel(string msg, DateTime pt)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]this.\_message = msg;  
![InBlock.gif][]this.\_publishTime = pt;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]privatestring \_message;  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// Message内容  
![ExpandedSubBlockEnd.gif][]///</summary>  
![InBlock.gif][]publicstring Message  
![ExpandedSubBlockStart.gif][]\{  
![ExpandedSubBlockStart.gif][]get\{ return \_message; \}  
![ExpandedSubBlockStart.gif][]set\{ \_message = value; \}  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]private DateTime \_publishTime;  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// Message发布时间  
![ExpandedSubBlockEnd.gif][]///</summary>  
![InBlock.gif][]public DateTime PublishTime  
![ExpandedSubBlockStart.gif][]\{  
![ExpandedSubBlockStart.gif][]get\{ return \_publishTime; \}  
![ExpandedSubBlockStart.gif][]set\{ \_publishTime = value; \}  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]

AbstractMessage

SqlMessage

![None.gif][] using  System;  
![None.gif][] using  System.Collections.Generic;  
![None.gif][] using  System.Text;  
![None.gif][]  
![None.gif][] namespace  Pattern.Decorator  
![ExpandedBlockStart.gif][] \{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// Sql方式操作Message（ConcreteComponent）  
![ExpandedSubBlockEnd.gif][]///</summary>  
![InBlock.gif][]publicclass SqlMessage : AbstractMessage  
![ExpandedSubBlockStart.gif][]\{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 获取Message  
![InBlock.gif][]///</summary>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverride List<MessageModel> Get()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] List<MessageModel> l =new List<MessageModel>();  
![InBlock.gif][] l.Add(new MessageModel("SQL方式获取Message", DateTime.Now));  
![InBlock.gif][]  
![InBlock.gif][]return l;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 插入Message  
![InBlock.gif][]///</summary>  
![InBlock.gif][]///<param name="mm">Message实体对象</param>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverridebool Insert(MessageModel mm)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]// 代码略  
![InBlock.gif][]returntrue;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]

XmlMessage

![None.gif][] using  System;  
![None.gif][] using  System.Collections.Generic;  
![None.gif][] using  System.Text;  
![None.gif][]  
![None.gif][] namespace  Pattern.Decorator  
![ExpandedBlockStart.gif][] \{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// Xml方式操作Message（ConcreteComponent）  
![ExpandedSubBlockEnd.gif][]///</summary>  
![InBlock.gif][]publicclass XmlMessage : AbstractMessage  
![ExpandedSubBlockStart.gif][]\{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 获取Message  
![InBlock.gif][]///</summary>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverride List<MessageModel> Get()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] List<MessageModel> l =new List<MessageModel>();  
![InBlock.gif][] l.Add(new MessageModel("XML方式获取Message", DateTime.Now));  
![InBlock.gif][]  
![InBlock.gif][]return l;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 插入Message  
![InBlock.gif][]///</summary>  
![InBlock.gif][]///<param name="mm">Message实体对象</param>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverridebool Insert(MessageModel mm)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]// 代码略  
![InBlock.gif][]returntrue;  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]

AbstractMessageWrapper

![None.gif][] using  System;  
![None.gif][] using  System.Collections.Generic;  
![None.gif][] using  System.Text;  
![None.gif][]  
![None.gif][] namespace  Pattern.Decorator  
![ExpandedBlockStart.gif][] \{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 装饰AbstractMessage（Decorator）  
![ExpandedSubBlockEnd.gif][]///</summary>  
![InBlock.gif][]publicabstractclass AbstractMessageWrapper : AbstractMessage  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]private AbstractMessage \_abstractMessage;  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 构造函数  
![InBlock.gif][]///</summary>  
![ExpandedSubBlockEnd.gif][]///<param name="abstractMessage">AbstractMessage</param>  
![InBlock.gif][]public AbstractMessageWrapper(AbstractMessage abstractMessage)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]this.\_abstractMessage = abstractMessage;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 获取Message  
![InBlock.gif][]///</summary>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverride List<MessageModel> Get()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]return \_abstractMessage.Get();  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 插入Message  
![InBlock.gif][]///</summary>  
![InBlock.gif][]///<param name="mm">Message实体对象</param>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverridebool Insert(MessageModel mm)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]return \_abstractMessage.Insert(mm);  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]

CheckUserWrapper

![None.gif][] using  System;  
![None.gif][] using  System.Collections.Generic;  
![None.gif][] using  System.Text;  
![None.gif][]  
![None.gif][] namespace  Pattern.Decorator  
![ExpandedBlockStart.gif][] \{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 扩展出用户验证的功能（ConcreteDecorator）  
![ExpandedSubBlockEnd.gif][]///</summary>  
![InBlock.gif][]publicclass CheckUserWrapper : AbstractMessageWrapper  
![ExpandedSubBlockStart.gif][]\{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 构造函数  
![InBlock.gif][]///</summary>  
![ExpandedSubBlockEnd.gif][]///<param name="abstractMessage">AbstractMessage</param>  
![InBlock.gif][]public CheckUserWrapper(AbstractMessage abstractMessage)  
![InBlock.gif][] : base(abstractMessage)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 获取Message  
![InBlock.gif][]///</summary>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverride List<MessageModel> Get()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] List<MessageModel> l =base.Get();  
![InBlock.gif][]  
![InBlock.gif][]foreach (MessageModel mm in l)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] mm.Message \+="（经过用户验证）";  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]return l;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 插入Message  
![InBlock.gif][]///</summary>  
![InBlock.gif][]///<param name="mm">Message实体对象</param>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverridebool Insert(MessageModel mm)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]// 在这里扩展功能  
![InBlock.gif][]  
![InBlock.gif][]returnbase.Insert(mm);  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]

CheckInputWrapper

![None.gif][] using  System;  
![None.gif][] using  System.Collections.Generic;  
![None.gif][] using  System.Text;  
![None.gif][]  
![None.gif][] namespace  Pattern.Decorator  
![ExpandedBlockStart.gif][] \{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 扩展出输入验证的功能（ConcreteDecorator）  
![ExpandedSubBlockEnd.gif][]///</summary>  
![InBlock.gif][]publicclass CheckInputWrapper : AbstractMessageWrapper  
![ExpandedSubBlockStart.gif][]\{  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 构造函数  
![InBlock.gif][]///</summary>  
![ExpandedSubBlockEnd.gif][]///<param name="abstractMessage">AbstractMessage</param>  
![InBlock.gif][]public CheckInputWrapper(AbstractMessage abstractMessage)  
![InBlock.gif][] : base(abstractMessage)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 获取Message  
![InBlock.gif][]///</summary>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverride List<MessageModel> Get()  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] List<MessageModel> l =base.Get();  
![InBlock.gif][]  
![InBlock.gif][]foreach (MessageModel mm in l)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] mm.Message \+="（经过输入验证）";  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![InBlock.gif][]return l;  
![ExpandedSubBlockEnd.gif][] \}  
![InBlock.gif][]  
![ExpandedSubBlockStart.gif][]///<summary>  
![InBlock.gif][]/// 插入Message  
![InBlock.gif][]///</summary>  
![InBlock.gif][]///<param name="mm">Message实体对象</param>  
![ExpandedSubBlockEnd.gif][]///<returns></returns>  
![InBlock.gif][]publicoverridebool Insert(MessageModel mm)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][]// 在这里扩展功能  
![InBlock.gif][]  
![InBlock.gif][]returnbase.Insert(mm);  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]

Test

![None.gif][] using  System;  
![None.gif][] using  System.Data;  
![None.gif][] using  System.Configuration;  
![None.gif][] using  System.Collections;  
![None.gif][] using  System.Web;  
![None.gif][] using  System.Web.Security;  
![None.gif][] using  System.Web.UI;  
![None.gif][] using  System.Web.UI.WebControls;  
![None.gif][] using  System.Web.UI.WebControls.WebParts;  
![None.gif][] using  System.Web.UI.HtmlControls;  
![None.gif][]  
![None.gif][] using  Pattern.Decorator;  
![None.gif][]  
![None.gif][] public  partial  class  Decorator : System.Web.UI.Page  
![ExpandedBlockStart.gif][] \{  
![InBlock.gif][]protectedvoid Page\_Load(object sender, EventArgs e)  
![ExpandedSubBlockStart.gif][]\{  
![InBlock.gif][] AbstractMessage message =new SqlMessage();  
![InBlock.gif][]  
![InBlock.gif][] AbstractMessageWrapper amr =new CheckUserWrapper(message);  
![InBlock.gif][]  
![InBlock.gif][] Response.Write(amr.Get()\[0\].Message \+""\+ amr.Get()\[0\].PublishTime.ToString());  
![InBlock.gif][] Response.Write("<br />");  
![InBlock.gif][]  
![InBlock.gif][] AbstractMessageWrapper amr2 =new CheckInputWrapper(message);  
![InBlock.gif][]  
![InBlock.gif][] Response.Write(amr2.Get()\[0\].Message \+""\+ amr2.Get()\[0\].PublishTime.ToString());  
![InBlock.gif][] Response.Write("<br />");  
![InBlock.gif][]  
![InBlock.gif][] AbstractMessageWrapper amr3 =new CheckUserWrapper(message);  
![InBlock.gif][] AbstractMessageWrapper amr4 =new CheckInputWrapper(amr3);  
![InBlock.gif][]  
![InBlock.gif][] Response.Write(amr4.Get()\[0\].Message \+""\+ amr4.Get()\[0\].PublishTime.ToString());  
![InBlock.gif][] Response.Write("<br />");  
![ExpandedSubBlockEnd.gif][] \}  
![ExpandedBlockEnd.gif][]\}   
![None.gif][]

运行结果  
SQL方式获取Message（经过用户验证） 2007-5-13 19:34:01  
SQL方式获取Message（经过输入验证） 2007-5-13 19:34:01  
SQL方式获取Message（经过用户验证）（经过输入验证） 2007-5-13 19:34:01  
  
  
参考  
[http://www.dofactory.com/Patterns/PatternDecorator.aspx][http_www.dofactory.com_Patterns_PatternDecorator.aspx]  
  
  
OK  
[\[源码下载\]][Link 2]

[-]: http://www.cnblogs.com/zhenyulu/category/6930.html
[.NET]: http://www.cnblogs.com/Terrylee/archive/2006/07/17/334911.html
[Link 1]: http://blog.csdn.net/rocket5725/article/category/559017
[C]: http://www.cnblogs.com/webabcd/category/82668.html
[C_12_Decorator Pattern]: http://www.cnblogs.com/zhenyulu/articles/46735.html
[Pic64.gif]: /images/20220412/4619cf49c92b4ff79b3ab38ce00acb7d.png
[None.gif]: /images/20220412/0b15a74b729f4c60a088570e021398b6.png
[ExpandedBlockStart.gif]: /images/20220412/e6c562dbf1d34ea3a125a9e67c2cf9b1.png
[InBlock.gif]: /images/20220412/c64790d7b897429aaf771806c264f4c9.png
[ExpandedBlockEnd.gif]: /images/20220412/bd1d7bfaf02848289b8396c79caed8e0.png
[ExpandedSubBlockStart.gif]: /images/20220412/a1409320f50c4de1abd69d5f4f795bd2.png
[ExpandedSubBlockEnd.gif]: /images/20220412/cf22afd80ae742b6aa3c4a14de01c691.png
[Pic65.gif]: /images/20220412/fff7b0578d2342d4a365d00348d7c6ae.png
[Pic66.gif]: /images/20220412/aeb39b8796004ed6b5c71451417ceed2.png
[.NET_10_Decorator Pattern]: http://www.cnblogs.com/Terrylee/archive/2006/03/01/340592.html
[Decorator_02.gif]: /images/20220412/9eb305603cf74fb0ae45dc75905c1330.png
[Decorator_01.jpg]: /images/20220412/d66ef3138d214c98a0ce39c3ac07821b.png
[Decorator_03.jpg]: /images/20220412/4ce215869f1348099a7772093477cb88.png
[Decorator_04.jpg]: /images/20220412/c5c9f212fecd4b3c837c4e2d71731457.png
[Decorator_05.jpg]: /images/20220412/ab54f5b0bae941f19254284774aa9c78.png
[Decorator_061.jpg]: /images/20220412/94e95e60b2f54f2c9d7783d011a6ec51.png
[Decorator_071.jpg]: /images/20220412/c7c3f4bc0d7344058bcb01a8198e1935.png
[Decorator_081.jpg]: /images/20220412/85f9c3d7563d4528aa0a2422fdece869.png
[Decorator_091.jpg]: /images/20220412/49dc06ff5a944a359c321d3eac8b9942.png
[Decorator_101.jpg]: /images/20220412/c7ae2dc5f90643b58ebc98ec0af1c014.png
[Decorator_111.jpg]: /images/20220412/1950a1c640b8430fb8d23a1bd0b44a0f.png
[TerryLee]: http://terrylee.cnblogs.com
[1357711786_7202.png]: https://img-my.csdn.net/uploads/201301/09/1357711786_7202.png
[1357711852_5135.png]: https://img-my.csdn.net/uploads/201301/09/1357711852_5135.png
[C_ - _Decorator Pattern]: http://www.cnblogs.com/webabcd/archive/2007/05/13/744874.html
[webabcd]: http://webabcd.cnblogs.com/
[o_Decorator.png]: /images/20220412/55f808620be04437a40f1dd65371df8d.png
[http_www.dofactory.com_Patterns_PatternDecorator.aspx]: http://www.dofactory.com/Patterns/PatternDecorator.aspx
[Link 2]: http://files.cnblogs.com/webabcd/Pattern.rar