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)     {         //抛出一个我们自定义的异常     } }

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

public interface IReadableLocator : IEnumerable> {     //返回定位器中节点的数量     int Count { get; }       //一个指向父节点的引用     IReadableLocator ParentLocator { get; }       //表示定位器是否只读     bool ReadOnly { get; }       //查询定位器中是否已经存在指定键值的对象     bool Contains(object key);       //查询定位器中是否已经存在指定键值的对象，根据给出的搜索选项，表示是否要向上回溯继续寻找。     bool Contains(object key, SearchMode options);       //使用谓词操作来查找包含给定对象的定位器     IReadableLocator FindBy(Predicate> predicate);       //根据是否回溯的选项，使用谓词操作来查找包含对象的定位器     IReadableLocator FindBy(SearchMode options, Predicate> predicate);       //从定位器中获取一个指定类型的对象     TItem Get();       //从定位其中获取一个指定键值的对象     TItem Get(object key);       //根据选项条件，从定位其中获取一个指定类型的对象     TItem Get(object key, SearchMode options);       //给定对象键值获取对象的非泛型重载方法     object Get(object key);       //给定对象键值带搜索条件的非泛型重载方法 object Get(object key, SearchMode options); }

一个抽象基类ReadableLocator用来实现这个接口的公共方法。两个主要的方法实现代码如下：

public abstract class ReadableLocator : IReadableLocator {     /**////     /// 查找定位器，最后返回一个只读定位器的实例     ///     public IReadableLocator FindBy(SearchMode options, Predicate> 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);     }       /**////     /// 遍历定位器     ///     private void FindInLocator(Predicate> predicate, Locator results,                                         IReadableLocator currentLocator)     {         foreach (KeyValuePair kvp in currentLocator)         {             if (!results.Contains(kvp.Key) && predicate(kvp))             {                 results.Add(kvp.Key, kvp.Value);             }         }     } }

实现代码如下：