C#设计模式（11）－Composite Pattern
一、 合成（Composite）模式
合成模式有时又叫做部分－整体模式（Part-Whole）。合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式可以使客户端将单纯元素与复合元素同等看待。
从和尚的故事谈起
这是小时候我奶奶讲的故事：从前有个山，山里有个庙，庙里有个老和尚在给小和尚讲故事，讲的什么故事呢？从前有个山，山里有个庙……。奶奶的故事要循环多少次，根据你多长时间睡着而定。在故事中有山、有庙、有和尚、有故事。因此，故事的角色有两种：一种里面没有其它角色；另一种内部有其它角色。
对象的树结构
一个树结构由两种节点组成：树枝节点和树叶节点。树枝节点可以有子节点，而一个树叶节点不可以有子节点。除了根节点外，其它节点有且只有一个父节点。
注意：一个树枝节点可以不带任何叶子，但是它因为有带叶子的能力，因此仍然是树枝节点，而不会成为叶节点。一个树叶节点永远不可能带有子节点。
二、 合成模式概述
下图所示的类图省略了各个角色的细节。
可以看出，上面的类图结构涉及到三个角色：
- 抽象构件（Component）角色：这是一个抽象角色，它给参与组合的对象规定一个接口。这个角色给出共有接口及其默认行为。
- 树叶构件（Leaf）角色：代表参加组合的树叶对象。一个树叶对象没有下级子对象。
- 树枝构件（Composite）角色：代表参加组合的有子对象的对象，并给出树枝构件对象的行为。
可以看出，Composite类型的对象可以包含其它Component类型的对象。换而言之，Composite类型对象可以含有其它的树枝（Composite）类型或树叶（Leaf）类型的对象。
合成模式的实现根据所实现接口的区别分为两种形式，分别称为安全模式和透明模式。合成模式可以不提供父对象的管理方法，但合成模式必须在合适的地方提供子对象的管理方法（诸如：add、remove、getChild等）。
透明方式
作为第一种选择，在Component里面声明所有的用来管理子类对象的方法，包括add（）、remove（），以及getChild（）方法。这样做的好处是所有的构件类都有相同的接口。在客户端看来，树叶类对象与合成类对象的区别起码在接口层次上消失了，客户端可以同等同的对待所有的对象。这就是透明形式的合成模式。
这个选择的缺点是不够安全，因为树叶类对象和合成类对象在本质上是有区别的。树叶类对象不可能有下一个层次的对象，因此add（）、remove（）以及getChild（）方法没有意义，是在编译时期不会出错，而只会在运行时期才会出错。
安全方式
第二种选择是在Composite类里面声明所有的用来管理子类对象的方法。这样的做法是安全的做法，因为树叶类型的对象根本就没有管理子类对象的方法，因此，如果客户端对树叶类对象使用这些方法时，程序会在编译时期出错。
这个选择的缺点是不够透明，因为树叶类和合成类将具有不同的接口。
这两个形式各有优缺点，需要根据软件的具体情况做出取舍决定。
三、 安全式的合成模式的结构
安全式的合成模式要求管理聚集的方法只出现在树枝构件类中，而不出现在树叶构件中。
这种形式涉及到三个角色：
- 抽象构件(Component)角色：这是一个抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象。在安全式的合成模式里，构件角色并不是定义出管理子对象的方法，这一定义由树枝构件对象给出。
- 树叶构件（Leaf）角色：树叶对象是没有下级子对象的对象，定义出参加组合的原始对象的行为。
- 树枝构件（Composite）角色：代表参加组合的有下级子对象的对象。树枝对象给出所有的管理子对象的方法，如add（）、remove（）、getChild（）等。
四、 安全式的合成模式实现
以下示例性代码演示了安全式的合成模式代码：
//
Composite pattern -- Structural example
using
System;
using
System.Text;
using
System.Collections;
//
"Component"
abstract
class
Component
{
// Fields protected string name; // Constructors public Component( string name )
{ this.name = name;
} // Operation public abstract void Display( int depth );
}
//
"Composite"
class
Composite : Component
{ // Fields private ArrayList children = new ArrayList(); // Constructors public Composite( string name ) : base( name ) {} // Methods public void Add( Component component ) { children.Add( component ); } public void Remove( Component component ) { children.Remove( component ); } public override void Display( int depth ) { Console.WriteLine( new String( '-', depth ) + name ); // Display each of the node's children foreach( Component component in children ) component.Display( depth + 2 ); }}
//
"Leaf"
class
Leaf : Component
{ // Constructors public Leaf( string name ) : base( name ) {} // Methods public override void Display( int depth ) { Console.WriteLine( new String( '-', depth ) + name ); }}
/// <summary>/// Client test/// </summary>
public
class
Client
{ public static void Main( string[] args ) { // Create a tree structure Composite root = new Composite( "root" ); root.Add( new Leaf( "Leaf A" )); root.Add( new Leaf( "Leaf B" )); Composite comp = new Composite( "Composite X" ); comp.Add( new Leaf( "Leaf XA" ) ); comp.Add( new Leaf( "Leaf XB" ) ); root.Add( comp ); root.Add( new Leaf( "Leaf C" )); // Add and remove a leaf Leaf l = new Leaf( "Leaf D" ); root.Add( l ); root.Remove( l ); // Recursively display nodes root.Display( 1 ); }}
五、 透明式的合成模式结构
与安全式的合成模式不同的是，透明式的合成模式要求所有的具体构件类，不论树枝构件还是树叶构件，均符合一个固定的接口。
这种形式涉及到三个角色：
- 抽象构件（Component）角色：这是一个抽象角色，它给参加组合的对象规定一个接口，规范共有的接口及默认行为。
- 树叶构件（Leaf）角色：代表参加组合的树叶对象，定义出参加组合的原始对象的行为。树叶类会给出add（）、remove（）以及getChild（）之类的用来管理子类对对象的方法的平庸实现。
- 树枝构件（Composite）角色：代表参加组合的有子对象的对象，定义出这样的对象的行为。
六、 透明式的合成模式实现
以下示例性代码演示了安全式的合成模式代码：
//
Composite pattern -- Structural example
using
System;
using
System.Text;
using
System.Collections;
//
"Component"
abstract
class
Component
{ // Fields protected string name; // Constructors public Component( string name ) { this.name = name; } // Methods abstract public void Add(Component c); abstract public void Remove( Component c ); abstract public void Display( int depth );}
//
"Composite"
class
Composite : Component
{ // Fields private ArrayList children = new ArrayList(); // Constructors public Composite( string name ) : base( name ) {} // Methods public override void Add( Component component ) { children.Add( component ); } public override void Remove( Component component ) { children.Remove( component ); } public override void Display( int depth ) { Console.WriteLine( new String( '-', depth ) + name ); // Display each of the node's children foreach( Component component in children ) component.Display( depth + 2 ); }}
//
"Leaf"
class
Leaf : Component
{ // Constructors public Leaf( string name ) : base( name ) {} // Methods public override void Add( Component c ) { Console.WriteLine("Cannot add to a leaf"); } public override void Remove( Component c ) { Console.WriteLine("Cannot remove from a leaf"); } public override void Display( int depth ) { Console.WriteLine( new String( '-', depth ) + name ); }}
/// <summary>/// Client test/// </summary>
public
class
Client
{ public static void Main( string[] args ) { // Create a tree structure Composite root = new Composite( "root" ); root.Add( new Leaf( "Leaf A" )); root.Add( new Leaf( "Leaf B" )); Composite comp = new Composite( "Composite X" ); comp.Add( new Leaf( "Leaf XA" ) ); comp.Add( new Leaf( "Leaf XB" ) ); root.Add( comp ); root.Add( new Leaf( "Leaf C" )); // Add and remove a leaf Leaf l = new Leaf( "Leaf D" ); root.Add( l ); root.Remove( l ); // Recursively display nodes root.Display( 1 ); }}
七、 使用合成模式时考虑的几个问题
- 明显的给出父对象的引用。在子对象里面给出父对象的引用，可以很容易的遍历所有父对象。有了这个引用，可以方便的应用责任链模式。
- 在通常的系统里，可以使用享元模式实现构件的共享，但是由于合成模式的对象经常要有对父对象的引用，因此共享不容易实现。
- 有时候系统需要遍历一个树枝结构的子构件很多次，这时候可以考虑把遍历子构件的结果暂时存储在父构件里面作为缓存。
- 关于使用什么数据类型来存储子对象的问题，在示意性的代码中使用了ArrayList，在实际系统中可以使用其它聚集或数组等。
- 客户端尽量不要直接调用树叶类中的方法，而是借助其父类（Component）的多态性完成调用，这样可以增加代码的复用性。
八、 和尚的故事
九、 一个实际应用Composite模式的例子
下面是一个实际应用中的程序，演示了通过一些基本图像元素（直线、园等）以及一些复合图像元素（由基本图像元素组合而成）构建复杂的图形树的过程。
//
Composite pattern -- Real World example
using
System;
using
System.Collections;
//
"Component"
abstract
class
DrawingElement
{ // Fields protected string name; // Constructors public DrawingElement( string name ) { this.name = name; } // Operation abstract public void Display( int indent );}
//
"Leaf"
class
PrimitiveElement : DrawingElement
{ // Constructors public PrimitiveElement( string name ) : base( name ) {} // Operation public override void Display( int indent ) { Console.WriteLine( new String( '-', indent ) + " draw a {0}", name ); }}
//
"Composite"
class
CompositeElement : DrawingElement
{ // Fields private ArrayList elements = new ArrayList(); // Constructors public CompositeElement( string name ) : base( name ) {} // Methods public void Add( DrawingElement d ) { elements.Add( d ); } public void Remove( DrawingElement d ) { elements.Remove( d ); } public override void Display( int indent ) { Console.WriteLine( new String( '-', indent ) + "+ " + name ); // Display each child element on this node foreach( DrawingElement c in elements ) c.Display( indent + 2 ); }}
/// <summary>/// CompositeApp test/// </summary>
public
class
CompositeApp
{ public static void Main( string[] args ) { // Create a tree structure CompositeElement root = new CompositeElement( "Picture" ); root.Add( new PrimitiveElement( "Red Line" )); root.Add( new PrimitiveElement( "Blue Circle" )); root.Add( new PrimitiveElement( "Green Box" )); CompositeElement comp = new CompositeElement( "Two Circles" ); comp.Add( new PrimitiveElement( "Black Circle" ) ); comp.Add( new PrimitiveElement( "White Circle" ) ); root.Add( comp ); // Add and remove a PrimitiveElement PrimitiveElement l = new PrimitiveElement( "Yellow Line" ); root.Add( l ); root.Remove( l ); // Recursively display nodes root.Display( 1 ); }}
合成模式与很多其它模式都有联系，将在后续内容中逐步介绍。
参考文献：
阎宏，《Java与模式》，电子工业出版社
[美]James W. Cooper，《C#设计模式》，电子工业出版社
[美]Alan Shalloway James R. Trott，《Design Patterns Explained》，中国电力出版社
[美]Robert C. Martin，《敏捷软件开发－原则、模式与实践》，清华大学出版社
[美]Don Box, Chris Sells，《.NET本质论 第1卷：公共语言运行库》，中国电力出版社
.NET设计模式（11）：组合模式（Composite Pattern）
组合模式（Composite Pattern）
——.NET设计模式系列之十一
Terrylee，2006年3月
概述
组合模式有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。
意图
将对象组合成树形结构以表示“部分-整体”的层次结构。Composite模式使得用户对单个对象和组合对象的使用具有一致性。[GOF 《设计模式》]
结构图
图1 Composite模式结构图
生活中的例子
组合模式将对象组合成树形结构以表示"部分-整体"的层次结构。让用户一致地使用单个对象和组合对象。虽然例子抽象一些，但是算术表达式确实是组合的例子。算术表达式包括操作数、操作符和另一个操作数。操作数可以是数字，也可以是另一个表达式。这样，2+3和（2+3）+（4*6）都是合法的表达式。
图2 使用算术表达式例子的Composite模式对象图
组合模式解说
这里我们用绘图这个例子来说明Composite模式，通过一些基本图像元素（直线、圆等）以及一些复合图像元素（由基本图像元素组合而成）构建复杂的图形树。在设计中我们对每一个对象都配备一个Draw()方法，在调用时，会显示相关的图形。可以看到，这里复合图像元素它在充当对象的同时，又是那些基本图像元素的一个容器。先看一下基本的类结构图：
图3
图中橙色的区域表示的是复合图像元素。示意性代码：
public
abstract
class
Graphics
{
protected string _name; public Graphics(string name)
{ this._name = name;
} public abstract void Draw();
}
public
class
Picture : Graphics
{ public Picture(string name) : base(name) { } public override void Draw() { //
} public ArrayList GetChilds() { //返回所有的子对象 }}
而其他作为树枝构件，实现代码如下：
public
class
Line:Graphics
{ public Line(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); }}
public
class
Circle : Graphics
{ public Circle(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); }}
public
class
Rectangle : Graphics
{ public Rectangle(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); }}
现在我们要对该图像元素进行处理：在客户端程序中，需要判断返回对象的具体类型到底是基本图像元素，还是复合图像元素。如果是复合图像元素，我们将要用递归去处理，然而这种处理的结果却增加了客户端程序与复杂图像元素内部结构之间的依赖，那么我们如何去解耦这种关系呢？我们希望的是客户程序可以像处理基本图像元素一样来处理复合图像元素，这就要引入Composite模式了，需要把对于子对象的管理工作交给复合图像元素，为了进行子对象的管理，它必须提供必要的Add()，Remove()等方法，类结构图如下：
图4
示意性代码：
public
abstract
class
Graphics
{ protected string _name; public Graphics(string name) { this._name = name; } public abstract void Draw(); public abstract void Add(); public abstract void Remove();}
public
class
Picture : Graphics
{ protected ArrayList picList = new ArrayList(); public Picture(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); foreach (Graphics g in picList) { g.Draw(); } } public override void Add(Graphics g) { picList.Add(g); } public override void Remove(Graphics g) { picList.Remove(g); }}
public
class
Line : Graphics
{ public Line(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); } public override void Add(Graphics g) { } public override void Remove(Graphics g) { }}
public
class
Circle : Graphics
{ public Circle(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); } public override void Add(Graphics g) { } public override void Remove(Graphics g) { }}
public
class
Rectangle : Graphics
{ public Rectangle(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); } public override void Add(Graphics g) { } public override void Remove(Graphics g) { }}
这样引入Composite模式后，客户端程序不再依赖于复合图像元素的内部实现了。然而，我们程序中仍然存在着问题，因为Line，Rectangle，Circle已经没有了子对象，它是一个基本图像元素，因此Add()，Remove()的方法对于它来说没有任何意义，而且把这种错误不会在编译的时候报错，把错误放在了运行期，我们希望能够捕获到这类错误，并加以处理，稍微改进一下我们的程序：
public
class
Line : Graphics
{ public Line(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); } public override void Add(Graphics g) { //抛出一个我们自定义的异常 } public override void Remove(Graphics g) { //抛出一个我们自定义的异常 }}
这样改进以后，我们可以捕获可能出现的错误，做进一步的处理。上面的这种实现方法属于透明式的Composite模式，如果我们想要更安全的一种做法，就需要把管理子对象的方法声明在树枝构件Picture类里面，这样如果叶子节点Line，Rectangle，Circle使用这些方法时，在编译期就会出错，看一下类结构图：
图5
示意性代码：
public
abstract
class
Graphics
{ protected string _name; public Graphics(string name) { this._name = name; } public abstract void Draw();}
public
class
Picture : Graphics
{ protected ArrayList picList = new ArrayList(); public Picture(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); foreach (Graphics g in picList) { g.Draw(); } } public void Add(Graphics g) { picList.Add(g); } public void Remove(Graphics g) { picList.Remove(g); }}
public
class
Line : Graphics
{ public Line(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); }}
public
class
Circle : Graphics
{ public Circle(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); }}
public
class
Rectangle : Graphics
{ public Rectangle(string name) : base(name) { } public override void Draw() { Console.WriteLine("Draw a" + _name.ToString()); }}
这种方式属于安全式的Composite模式，在这种方式下，虽然避免了前面所讨论的错误，但是它也使得叶子节点和树枝构件具有不一样的接口。这种方式和透明式的Composite各有优劣，具体使用哪一个，需要根据问题的实际情况而定。通过Composite模式，客户程序在调用Draw()的时候不用再去判断复杂图像元素中的子对象到底是基本图像元素，还是复杂图像元素，看一下简单的客户端调用：
public
class
App
{ public static void Main() { Picture root = new Picture("Root"); root.Add(new Line("Line")); root.Add(new Circle("Circle")); Rectangle r = new Rectangle("Rectangle"); root.Add(r); root.Draw(); }}
.NET中的组合模式
如果有人用过Enterprise Library2.0，一定在源程序中看到了一个叫做ObjectBuilder的程序集，顾名思义，它是用来负责对象的创建工作的，而在ObjectBuilder中，有一个被称为定位器的东西，通过定位器，可以很容易的找到对象，它的结构采用链表结构，每一个节点是一个键值对，用来标识对象的唯一性，使得对象不会被重复创建。定位器的链表结构采用可枚举的接口类来实现，这样我们可以通过一个迭代器来遍历这个链表。同时多个定位器也被串成一个链表。具体地说就是多个定位器组成一个链表，表中的每一个节点是一个定位器，定位器本身又是一个链表，表中保存着多个由键值对组成的对象的节点。所以这是一个典型的Composite模式的例子，来看它的结构图：
图6
正如我们在图中所看到的，IReadableLocator定义了最上层的定位器接口方法，它基本上具备了定位器的大部分功能。
部分代码：
public
interface
IReadableLocator : IEnumerable
<
KeyValuePair
<
object
,
object
>>
{ //返回定位器中节点的数量 int Count { get; } //一个指向父节点的引用 IReadableLocator ParentLocator { get; } //表示定位器是否只读 bool ReadOnly { get; } //查询定位器中是否已经存在指定键值的对象 bool Contains(object key); //查询定位器中是否已经存在指定键值的对象，根据给出的搜索选项，表示是否要向上回溯继续寻找。 bool Contains(object key, SearchMode options); //使用谓词操作来查找包含给定对象的定位器 IReadableLocator FindBy(Predicate<KeyValuePair<object, object>> predicate); //根据是否回溯的选项，使用谓词操作来查找包含对象的定位器 IReadableLocator FindBy(SearchMode options, Predicate<KeyValuePair<object, object>> predicate); //从定位器中获取一个指定类型的对象 TItem Get<TItem>(); //从定位其中获取一个指定键值的对象 TItem Get<TItem>(object key); //根据选项条件，从定位其中获取一个指定类型的对象 TItem Get<TItem>(object key, SearchMode options); //给定对象键值获取对象的非泛型重载方法 object Get(object key); //给定对象键值带搜索条件的非泛型重载方法object Get(object key, SearchMode options);}
一个抽象基类ReadableLocator用来实现这个接口的公共方法。两个主要的方法实现代码如下：
public
abstract
class
ReadableLocator : IReadableLocator
{ /// <summary> /// 查找定位器，最后返回一个只读定位器的实例 /// </summary> public IReadableLocator FindBy(SearchMode options, Predicate<KeyValuePair<object, object>> predicate) { if (predicate == null) throw new ArgumentNullException("predicate"); if (!Enum.IsDefined(typeof(SearchMode), options)) throw new ArgumentException(Properties.Resources.InvalidEnumerationValue, "options"); Locator results = new Locator(); IReadableLocator currentLocator = this; while (currentLocator != null) { FindInLocator(predicate, results, currentLocator); currentLocator = options == SearchMode.Local ? null : currentLocator.ParentLocator; } return new ReadOnlyLocator(results); } /// <summary> /// 遍历定位器 /// </summary> private void FindInLocator(Predicate<KeyValuePair<object, object>> predicate, Locator results, IReadableLocator currentLocator) { foreach (KeyValuePair<object, object> kvp in currentLocator) { if (!results.Contains(kvp.Key) && predicate(kvp)) { results.Add(kvp.Key, kvp.Value); } } }}
可以看到，在FindBy方法里面，循环调用了FindInLocator方法，如果查询选项是只查找当前定位器，那么循环终止，否则沿着定位器的父定位器继续向上查找。FindInLocator方法就是遍历定位器，然后把找到的对象存入一个临时的定位器。最后返回一个只读定位器的新的实例。
从这个抽象基类中派生出一个具体类和一个抽象类，一个具体类是只读定位器（ReadOnlyLocator），只读定位器实现抽象基类没有实现的方法，它封装了一个实现了IReadableLocator接口的定位器，然后屏蔽内部定位器的写入接口方法。另一个继承的是读写定位器抽象类ReadWriteLocator，为了实现对定位器的写入和删除，这里定义了一个对IReadableLocator接口扩展的接口叫做IReadWriteLocator，在这个接口里面提供了实现定位器的操作：
图7
实现代码如下：
public
interface
IReadWriteLocator : IReadableLocator
{ //保存对象到定位器 void Add(object key, object value); //从定位器中删除一个对象，如果成功返回真，否则返回假 bool Remove(object key); }
从ReadWirteLocator派生的具体类是Locator类，Locator类必须实现一个定位器的全部功能，现在我们所看到的Locator它已经具有了管理定位器的功能，同时他还应该具有存储的结构，这个结构是通过一个WeakRefDictionary类来实现的，这里就不介绍了。[关于定位器的介绍参考了niwalker的Blog]
效果及实现要点
1．Composite模式采用树形结构来实现普遍存在的对象容器，从而将“一对多”的关系转化“一对一”的关系，使得客户代码可以一致地处理对象和对象容器，无需关心处理的是单个的对象，还是组合的对象容器。
2．将“客户代码与复杂的对象容器结构”解耦是Composite模式的核心思想，解耦之后，客户代码将与纯粹的抽象接口——而非对象容器的复内部实现结构——发生依赖关系，从而更能“应对变化”。
3．Composite模式中，是将“Add和Remove等和对象容器相关的方法”定义在“表示抽象对象的Component类”中，还是将其定义在“表示对象容器的Composite类”中，是一个关乎“透明性”和“安全性”的两难问题，需要仔细权衡。这里有可能违背面向对象的“单一职责原则”，但是对于这种特殊结构，这又是必须付出的代价。ASP.NET控件的实现在这方面为我们提供了一个很好的示范。
4．Composite模式在具体实现中，可以让父对象中的子对象反向追溯；如果父对象有频繁的遍历需求，可使用缓存技巧来改善效率。
适用性
以下情况下适用Composite模式：
1．你想表示对象的部分-整体层次结构
2．你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。
总结
组合模式解耦了客户程序与复杂元素内部结构，从而使客户程序可以向处理简单元素一样来处理复杂元素。
参考资料
阎宏，《Java与模式》，电子工业出版社
James W. Cooper，《C#设计模式》，电子工业出版社
Alan Shalloway James R. Trott，《Design Patterns Explained》，中国电力出版社
MSDN WebCast 《C#面向对象设计模式纵横谈(9)：Composite组合模式(结构型模式)》
作者： TerryLee乐在其中设计模式(C#) - 组合模式(Composite Pattern)
作者： webabcd
介绍
将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和复合对象的使用具有一致性。
示例
有一个Message实体类，使其单个对象和复合对象具有一致性。
MessageModel
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Composite
{ /// <summary> /// Message实体类 /// </summary> public class MessageModel { /// <summary> /// 构造函数 /// </summary> /// <param name="msg">Message内容</param> /// <param name="pt">Message发布时间</param> public MessageModel(string msg, DateTime pt) { this._message = msg; this._publishTime = pt; } private string _message; /// <summary> /// Message内容 /// </summary> public string Message { get { return _message; } set { _message = value; } } private DateTime _publishTime; /// <summary> /// Message发布时间 /// </summary> public DateTime PublishTime { get { return _publishTime; } set { _publishTime = value; } } }}
MessageModelComponent
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Composite
{ /// <summary> /// 抽象Message实体构件（Component） /// </summary> public abstract class MessageModelComponent { /// <summary> /// Message实体对象 /// </summary> protected MessageModel _messageModel; /// <summary> /// 名称 /// </summary> protected string _name; /// <summary> /// 构造函数 /// </summary> /// <param name="name">名称</param> /// <param name="mm">Message实体对象</param> public MessageModelComponent(string name, MessageModel mm) { this._name = name; this._messageModel = mm; } /// <summary> /// 构造函数 /// </summary> /// <param name="name">名称</param> public MessageModelComponent(string name) { this._name = name; } /// <summary> /// 添加 /// </summary> /// <param name="mmc">MessageModelComponent</param> public abstract void Add(MessageModelComponent mmc); /// <summary> /// 删除 /// </summary> /// <param name="mmc">MessageModelComponent</param> public abstract void Remove(MessageModelComponent mmc); /// <summary> /// 获取 /// </summary> /// <param name="indent">缩进数</param> /// <returns></returns> public abstract string GetData(int indent); }}
MessageModelLeaf
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Composite
{ /// <summary> /// Message实体树叶（Leaf） /// </summary> public class MessageModelLeaf : MessageModelComponent { /// <summary> /// 构造函数 /// </summary> /// <param name="name">名称</param> /// <param name="mm">Message实体对象</param> public MessageModelLeaf(string name, MessageModel mm) : base(name, mm) { } /// <summary> /// 添加 /// </summary> /// <param name="mmc">MessageModelComponent</param> public override void Add(MessageModelComponent mmc) { throw new Exception("不能添加"); } /// <summary> /// 删除 /// </summary> /// <param name="mmc">MessageModelComponent</param> public override void Remove(MessageModelComponent mmc) { throw new Exception("不能删除"); } /// <summary> /// 获取 /// </summary> /// <param name="indent">缩进数</param> /// <returns></returns> public override string GetData(int indent) { return new String('—', indent) + "树叶名称：" + _name + "；信息内容：" + _messageModel.Message + "<br />"; } }}
MessageModelComposite
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Composite
{ /// <summary> /// Message实体树枝（Composite） /// </summary> public class MessageModelComposite : MessageModelComponent { private List<MessageModelComponent> _list; /// <summary> /// 构造函数 /// </summary> /// <param name="name">名称</param> public MessageModelComposite(string name) : base(name) { _list = new List<MessageModelComponent>(); } /// <summary> /// 添加 /// </summary> /// <param name="mmc">MessageModelComponent</param> public override void Add(MessageModelComponent mmc) { _list.Add(mmc); } /// <summary> /// 删除 /// </summary> /// <param name="mmc">MessageModelComponent</param> public override void Remove(MessageModelComponent mmc) { _list.Remove(mmc); } /// <summary> /// 获取 /// </summary> /// <param name="indent">缩进数</param> /// <returns></returns> public override string GetData(int indent) { string s = new String('—', indent) + "树枝名称：" + _name + "<br />"; foreach (MessageModelComponent mmc in _list) { s += mmc.GetData(indent + 2); } return s; } }}
Test
using
System;
using
System.Data;
using
System.Configuration;
using
System.Collections;
using
System.Web;
using
System.Web.Security;
using
System.Web.UI;
using
System.Web.UI.WebControls;
using
System.Web.UI.WebControls.WebParts;
using
System.Web.UI.HtmlControls;
using
Pattern.Composite;
public
partial
class
Composite : System.Web.UI.Page
{ protected void Page_Load(object sender, EventArgs e) { MessageModelComposite root = new MessageModelComposite("树枝A"); root.Add(new MessageModelLeaf("树叶A", new MessageModel("Message内容A", DateTime.Now))); root.Add(new MessageModelLeaf("树叶B", new MessageModel("Message内容B", DateTime.Now))); MessageModelComposite comp = new MessageModelComposite("树枝B"); comp.Add(new MessageModelLeaf("树叶C", new MessageModel("Message内容C", DateTime.Now))); comp.Add(new MessageModelLeaf("树叶D", new MessageModel("Message内容D", DateTime.Now))); root.Add(comp); root.Add(new MessageModelLeaf("树叶E", new MessageModel("Message内容E", DateTime.Now))); MessageModelLeaf l = new MessageModelLeaf("树叶F", new MessageModel("Message内容F", DateTime.Now)); root.Add(l); root.Remove(l); Response.Write(root.GetData(1)); }}
运行结果
—树枝名称：树枝A
———树叶名称：树叶A；信息内容：Message内容A
———树叶名称：树叶B；信息内容：Message内容B
———树枝名称：树枝B
—————树叶名称：树叶C；信息内容：Message内容C
—————树叶名称：树叶D；信息内容：Message内容D
———树叶名称：树叶E；信息内容：Message内容E
参考
http://www.dofactory.com/Patterns/PatternComposite.aspx
OK
[源码下载]
269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
