设计模式CompositeStructure标签03标签04标签05

C#09：(结构型模式)Composite 组合模式.pdf

说明：

  • 组合模式
  • 结构型模式

视频

点击查看【bilibili】

动机 —Motivate

组合模式有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

意图 —Intent

  1. 将对象组合成树形结构以表示“部分-整体”的层次结构。Composite模式使得用户对单个对象和组合对象的使用具有一致性。                                                -----------《设计模式》GOF<br />

结构图(Struct):

P09.组合模式-Composite--Structure - 图1

生活中的例子：

P09.组合模式-Composite--Structure - 图2

适用性：

  1. 1．你想表示对象的部分-整体层次结构<br />    2．你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。代码实现：<br />    这里我们用绘图这个例子来说明Composite模式，通过一些基本图像元素（直线、圆等）以及一些复合图像元素（由基本图像元素组合而成）构建复杂的图形树。在设计中我们对每一个对象都配备一个Draw()方法，在调用时，会显示相关的图形。可以看到，这里复合图像元素它在充当对象的同时，又是那些基本图像元素的一个容器。先看一下基本的类结构图：<br />             ![](https://cdn.nlark.com/yuque/0/2021/jpeg/446847/1615447856728-1ed37a2b-2870-43fb-ade5-4ba27b9ace05.jpeg#align=left&display=inline&height=176&margin=%5Bobject%20Object%5D&originHeight=176&originWidth=586&size=0&status=done&style=none&width=586)<br />图中橙色的区域表示的是复合图像元素。<br />示意性代码：
  1. public abstract class Graphics
  2. {
  3.     protected string _name;
  5.     public Graphics(string name)
  6.     {
  7.         this._name = name;
  8.     }
  9.     public abstract void Draw();
  10. }
  12. public class Picture : Graphics
  13. {
  14.     public Picture(string name)
  15.         : base(name)
  16.     { }
  17.     public override void Draw()
  18.     {
  19.         //
  20.     }
  22.     public ArrayList GetChilds()
  23.     { 
  24.         //返回所有的子对象
  25.     }
  26. }

而其他作为树枝构件，实现代码如下：

  1. public class Line:Graphics
  2. {
  3.     public Line(string name)
  4.         : base(name)
  5.     { }
  7.     public override void Draw()
  8.     {
  9.         Console.WriteLine("Draw a" + _name.ToString());
  10.     }
  11. }
  13. public class Circle : Graphics
  14. {
  15.     public Circle(string name)
  16.         : base(name)
  17.     { }
  19.     public override void Draw()
  20.     {
  21.         Console.WriteLine("Draw a" + _name.ToString());
  22.     }
  23. }
  25. public class Rectangle : Graphics
  26. {
  27.     public Rectangle(string name)
  28.         : base(name)
  29.     { }
  31.     public override void Draw()
  32.     {
  33.         Console.WriteLine("Draw a" + _name.ToString());
  34.     }
  35. }
  1. 现在我们要 对该图像元素进行处理：在客户端程序中，需要判断返回对象的具体类型到底是基本图像元素，还是复合图像元素。如果是复合图像元素，我们将要用递归去处理， 然而这种处理的结果却增加了客户端程序与复杂图像元素内部结构之间的依赖，那么我们如何去解耦这种关系呢？我们希望的是客户程序可以像处理基本图像元素一 样来处理复合图像元素，这就要引入Composite模式了，需要把对于子对象的管理工作交给复合图像元素，为了进行子对象的管理，它必须提供必要的Add()，Remove()等方法，类结构图如下：<br />![](https://cdn.nlark.com/yuque/0/2021/jpeg/446847/1615447856731-51340252-97fb-4d7e-8d9c-aa868ca9e68d.jpeg#align=left&display=inline&height=236&margin=%5Bobject%20Object%5D&originHeight=236&originWidth=607&size=0&status=done&style=none&width=607)

示意代码：

  1. public abstract class Graphics
  2. {
  3.     protected string _name;
  5.     public Graphics(string name)
  6.     {
  7.         this._name = name;
  8.     }
  9.     public abstract void Draw();
  10.     public abstract void Add();
  11.     public abstract void Remove();
  12. }
  14. public class Picture : Graphics
  15. {
  16.     protected ArrayList picList = new ArrayList();
  18.     public Picture(string name)
  19.         : base(name)
  20.     { }
  21.     public override void Draw()
  22.     {
  23.         Console.WriteLine("Draw a" + _name.ToString());
  25.         foreach (Graphics g in picList)
  26.         {
  27.             g.Draw();
  28.         }
  29.     }
  31.     public override void Add(Graphics g)
  32.     {
  33.         picList.Add(g);
  34.     }
  35.     public override void Remove(Graphics g)
  36.     {
  37.         picList.Remove(g);
  38.     }
  39. }
  41. public class Line : Graphics
  42. {
  43.     public Line(string name)
  44.         : base(name)
  45.     { }
  47.     public override void Draw()
  48.     {
  49.         Console.WriteLine("Draw a" + _name.ToString());
  50.     }
  51.     public override void Add(Graphics g)
  52.     { }
  53.     public override void Remove(Graphics g)
  54.     { }
  55. }
  57. public class Circle : Graphics
  58. {
  59.     public Circle(string name)
  60.         : base(name)
  61.     { }
  63.     public override void Draw()
  64.     {
  65.         Console.WriteLine("Draw a" + _name.ToString());
  66.     }
  67.     public override void Add(Graphics g)
  68.     { }
  69.     public override void Remove(Graphics g)
  70.     { }
  71. }
  73. public class Rectangle : Graphics
  74. {
  75.     public Rectangle(string name)
  76.         : base(name)
  77.     { }
  79.     public override void Draw()
  80.     {
  81.         Console.WriteLine("Draw a" + _name.ToString());
  82.     }
  83.     public override void Add(Graphics g)
  84.     { }
  85.     public override void Remove(Graphics g)
  86.     { }
  87. }
  1. 这样引入Composite模式后，客户端程序不再依赖于复合图像元素的内部实现了。然而，我们程序中仍然存在着问题，因为Line，Rectangle，Circle已经没有了子对象，它是一个基本图像元素，因此Add()，Remove()的方法对于它来说没有任何意义，而且把这种错误不会在编译的时候报错，把错误放在了运行期，我们希望能够捕获到这类错误，并加以处理，稍微改进一下我们的程序：
  1. public class Line : Graphics
  2. {
  3.     public Line(string name)
  4.         : base(name)
  5.     { }
  7.     public override void Draw()
  8.     {
  9.         Console.WriteLine("Draw a" + _name.ToString());
  10.     }
  11.     public override void Add(Graphics g)
  12.     { 
  13.         //抛出一个我们自定义的异常
  14.     }
  15.     public override void Remove(Graphics g)
  16.     {
  17.         //抛出一个我们自定义的异常
  18.     }
  19. }
  1. 这样改进以后，我们可以捕获可能出现的错误，做进一步的处理。上面的这种实现方法属于透明式的Composite模式，如果我们想要更安全的一种做法，就需要把管理子对象的方法声明在树枝构件Picture类里面，这样如果叶子节点Line，Rectangle，Circle使用这些方法时，在编译期就会出错，看一下类结构图：<br />![](https://cdn.nlark.com/yuque/0/2021/jpeg/446847/1615447856755-13567e47-4dcf-4e3f-bbb7-371bb54daa7e.jpeg#align=left&display=inline&height=198&margin=%5Bobject%20Object%5D&originHeight=198&originWidth=607&size=0&status=done&style=none&width=607)<br />示意代码：
  1. public abstract class Graphics
  2. {
  3.     protected string _name;
  5.     public Graphics(string name)
  6.     {
  7.         this._name = name;
  8.     }
  9.     public abstract void Draw();
  10. }
  12. public class Picture : Graphics
  13. {
  14.     protected ArrayList picList = new ArrayList();
  16.     public Picture(string name)
  17.         : base(name)
  18.     { }
  19.     public override void Draw()
  20.     {
  21.         Console.WriteLine("Draw a" + _name.ToString());
  23.         foreach (Graphics g in picList)
  24.         {
  25.             g.Draw();
  26.         }
  27.     }
  29.     public void Add(Graphics g)
  30.     {
  31.         picList.Add(g);
  32.     }
  33.     public void Remove(Graphics g)
  34.     {
  35.         picList.Remove(g);
  36.     }
  37. }
  39. public class Line : Graphics
  40. {
  41.     public Line(string name)
  42.         : base(name)
  43.     { }
  45.     public override void Draw()
  46.     {
  47.         Console.WriteLine("Draw a" + _name.ToString());
  48.     }
  49. }
  51. public class Circle : Graphics
  52. {
  53.     public Circle(string name)
  54.         : base(name)
  55.     { }
  57.     public override void Draw()
  58.     {
  59.         Console.WriteLine("Draw a" + _name.ToString());
  60.     }
  61. }
  63. public class Rectangle : Graphics
  64. {
  65.     public Rectangle(string name)
  66.         : base(name)
  67.     { }
  69.     public override void Draw()
  70.     {
  71.         Console.WriteLine("Draw a" + _name.ToString());
  72.     }
  73. }
  1. 这种方式属于安全式的Composite模式，在这种方式下，虽然避免了前面所讨论的错误，但是它也使得叶子节点和树枝构件具有不一样的接口。这种方式和透明式的Composite各有优劣，具体使用哪一个，需要根据问题的实际情况而定。通过Composite模式，客户程序在调用Draw()的时候不用再去判断复杂图像元素中的子对象到底是基本图像元素，还是复杂图像元素，看一下简单的客户端调用：
  1. public class App
  2. {
  3.     public static void Main()
  4.     {
  5.         Picture root = new Picture("Root");
  7.         root.Add(new Line("Line"));
  8.         root.Add(new Circle("Circle"));
  10.         Rectangle r = new Rectangle("Rectangle");
  11.         root.Add(r);
  13.         root.Draw();
  14.     }
  15. }

Composite模式实现要点：

  1. Composite模式采用树形结构来实现普遍存在的对象容器，从而将“一对多”的关系转化“一对一”的关系，使得客户代码可以一致地处理对象和对象容器，无需关心处理的是单个的对象，还是组合的对象容器。
  2. 将“客户代码与复杂的对象容器结构”解耦是Composite模式的核心思想，解耦之后，客户代码将与纯粹的抽象接口——而非对象容器的复内部实现结构——发生依赖关系，从而更能“应对变化”。
  3. Composite模式中，是将“Add和Remove等和对象容器相关的方法”定义在“表示抽象对象的Component类”中，还是将其定义在“表示对象容器的Composite类”中，是一个关乎“透明性”和“安全性”的两难问题，需要仔细权衡。这里有可能违背面向对象的“单一职责原则”，但是对于这种特殊结构，这又是必须付出的代价。ASP.NET控件的实现在这方面为我们提供了一个很好的示范。
  4. Composite模式在具体实现中，可以让父对象中的子对象反向追溯；如果父对象有频繁的遍历需求，可使用缓存技巧来改善效率。
  • 本文作者：GeekPower - Felix Sun
  • 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！