（35）C#设计模式—— 组合模式（Composite Pattern）

引言

在软件开发过程中，我们经常会遇到处理简单对象和复合对象的情况，例如对操作系统中目录处理就是这样的一个例子，因为目录可以包括单独的文件，也可以包括文件夹，文件夹是由文件组成的，由于简单对象和复合对象在功能上的区别，导致在操作过程中必须区分简单对象和复合对象，这样就会导致客户调用带来不必要的麻烦。然而作为客户，希望能够始终一致地对待简单对象和复合对象。这样就可以采用组合模式

组合模式详细介绍

定义：组合模式允许你将对象组合成树形结构来表现“部分-整体”的层次结构，使得客户以一致的方式处理单个对象及对象的组合。组合模式最关键的地方是——简单对象和复合对象必须同时实现相同的接口。这就是组合模式能够将组合对象和简单对象进行一致处理的原因。下面用绘制的例子来介绍组合模式。图形可以由一些基本图形元素组成，也可以由一些复杂图形组成，为了使客户对基本图形和复杂图形的调用保持一致，使用组合模式。

代码实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _27CompositePatternDemo
{
    /// <summary>
    /// 测试类
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            ComplexGraphics complexGraphics = new ComplexGraphics("一个复杂图形和两条线段组成的复杂图形");
            complexGraphics.Add(new Line("线段A"));
            ComplexGraphics CompositeCG = new ComplexGraphics("一个圆和一条线组成的复杂图形");
            CompositeCG.Add(new Circle("圆"));
            CompositeCG.Add(new Circle("线段B"));
            complexGraphics.Add(CompositeCG);
            Line l = new Line("线段C");
            complexGraphics.Add(l);

            // 显示复杂图形的画法
            Console.WriteLine("复杂图形的绘制如下：");
            Console.WriteLine("---------------------");
            complexGraphics.Draw();
            Console.WriteLine("复杂图形绘制完成");
            Console.WriteLine("---------------------");
            Console.WriteLine();

            // 移除一个组件再显示复杂图形的画法
            complexGraphics.Remove(l);
            Console.WriteLine("移除线段C后，复杂图形的绘制如下：");
            Console.WriteLine("---------------------");
            complexGraphics.Draw();
            Console.WriteLine("复杂图形绘制完成");
            Console.WriteLine("---------------------");
            Console.Read();
        }
    }
    /// <summary>
    /// 图形抽象类
    /// </summary>
    /// 
    public abstract class Graphics
    {
        public string Name { get; set; }
        public Graphics(string name)
        {
            this.Name = name;
        }
        public abstract void Draw();
        public abstract void Add(Graphics g);
        public abstract void Remove(Graphics g);
    }
    /// <summary>
    /// 简单图形——线
    /// </summary>
    /// 
    public class Line : Graphics
    {
        public Line(string name) : base(name)
        {
        }

        public override void Add(Graphics g)
        {
            throw new Exception("不能向简单图形Line添加其他图形");
        }

        public override void Draw()
        {
            Console.WriteLine("画   " + Name);
        }

        public override void Remove(Graphics g)
        {
            throw new Exception("不能向简单图形Line移除其他图形");
        }
    }
    /// <summary>
    /// 简单图形类——圆
    /// </summary>
    /// 
    public class Circle : Graphics
    {
        public Circle(string name) : base(name)
        {
        }

        public override void Add(Graphics g)
        {
            throw new Exception("不能向简单图形Circle添加其他图形");
        }

        public override void Draw()
        {
            Console.WriteLine("画  " + Name);
        }

        public override void Remove(Graphics g)
        {
            throw new Exception("不能向简单图形Circle移除其他图形"); 
        }
    }

    /// <summary>
    /// 复杂图形：有一些简单图形组成，这里假设该复杂图形由一个圆，两条线组成的复杂图形
    /// </summary>
    /// 
    public class ComplexGraphics : Graphics
    {
        private List<Graphics> complexGraphicsList = new List<Graphics>();
        public ComplexGraphics(string name) : base(name)
        {
        }
        public override void Draw()
        {
            foreach (Graphics item in complexGraphicsList)
            {
                item.Draw();
            }
        }

        public override void Add(Graphics g)
        {
            complexGraphicsList.Add(g);
        }



        public override void Remove(Graphics g)
        {
            complexGraphicsList.Remove(g);
        }
    }


}

由于基本图形对象不存在Add和Remove方法，上面的实现直接通过抛出一个异常来解决这样的问题的，但是我们想用一种更安全的方式来解决——因为基本图形不存在这样的方法，我们是不是可以删除这些方法？为了移除这些方法，我们不得不修改Graphics接口，我们把管理子对象的方法声明放在复合图形对象里面，这样简单对象Line、Circle使用这些方法时就会在编译时出错，这样的一种实现方式我们成为安全式的组合模式，然而上面的实现方式为透明式的组合模式。

//此方式实现的组合模式把管理子对象的方法声明在树枝构建ComplexGraphics类中
    //这样 如果叶子节点Line。Circle使用了Add、Remove方法时，就能在编译期间出错
    //但是这样方式虽然解决了透明模式的问题，但是它使得叶子节点和树枝构建具有不一样的接口
    //所以这两种方式实现的组合模式各有优缺点，具体使用哪个，可以根据实际情况而定
    class Program
    {
        static void Main(string[] args)
        {
            ComplexGraphics complexGraphics = new ComplexGraphics("一个复杂图形和两条线段组成的复杂图形");
            complexGraphics.Add(new Line("线段A"));
            ComplexGraphics CompositeCG = new ComplexGraphics("一个圆和一条线组成的复杂图形");
            CompositeCG.Add(new Circle("圆"));
            CompositeCG.Add(new Circle("线段B"));
            complexGraphics.Add(CompositeCG);
            Line l = new Line("线段C");
            complexGraphics.Add(l);

            // 显示复杂图形的画法
            Console.WriteLine("复杂图形的绘制如下：");
            Console.WriteLine("---------------------");
            complexGraphics.Draw();
            Console.WriteLine("复杂图形绘制完成");
            Console.WriteLine("---------------------");
            Console.WriteLine();

            // 移除一个组件再显示复杂图形的画法
            complexGraphics.Remove(l);
            Console.WriteLine("移除线段C后，复杂图形的绘制如下：");
            Console.WriteLine("---------------------");
            complexGraphics.Draw();
            Console.WriteLine("复杂图形绘制完成");
            Console.WriteLine("---------------------");
            Console.Read();
        }
    }

    public abstract class Graphics
    {
        public string Name { get; set; }
        public Graphics(string name)
        {
            this.Name = name;
        }
        public abstract void Draw();
        //移除了Add和Remove方法，把管理子对象的方法放到了ComplexGraphics类中进行管理
    }
    /// <summary>
    /// 简单图形
    /// </summary>
    public class Line : Graphics
    {
        public Line(string name) : base(name)
        {
        }

        public override void Draw()
        {
            Console.WriteLine("画     " + Name);
        }
    }

    public class Circle : Graphics
    {
        public Circle(string name) : base(name)
        {
        }

        public override void Draw()
        {
            Console.WriteLine("画    " + Name);
        }
    }
    /// <summary>
    /// 复杂图形类
    /// </summary>
    public class ComplexGraphics : Graphics
    {
        private List<Graphics> complexGraphicsList = new List<Graphics>();

        public ComplexGraphics(string name) : base(name)
        {
        }

        public override void Draw()
        {
            foreach (Graphics g in complexGraphicsList)
            {
                g.Draw();
            }
        }
        public void Add(Graphics g)
        {
            complexGraphicsList.Add(g);
        }
        public void Remove(Graphics g)
        {
            complexGraphicsList.Remove(g);
        }
    }

组合模式中涉及到的三个角色:

• 抽象构件：这是一个抽象角色。上面实现中Graphics充当这个角色。它给参加组合的对象定义出了公共接口和默认行为，可以用来管理所有的子对象。在安全式的组合模式里，构件角色并不定义出管理子对象的方法，这一定义有树枝结构对对象给出。
• 树叶构件：树叶对象是没有下级子对象的对象，上面实现中Line和Circle充当这个角色，定义出参加组合的原始对象的行为
• 树枝构件：代表参加组合的有下级子对象的对象，上面实现中ComplexGraphics充当这个角色，树枝对象给出所有管理子对象的方法实现，如Add、Remove

组合模式的优缺点

优点：

1. 组合模式使得客户端代码可以一致地处理对象和对象容器，无需关系处理的单个对象，还是组合的对象容器
2. 将“客户端代码与复杂的对象容器结构”解耦
3. 可以更容易地往组合对象中加入新的构件

缺点：使得设计更加复杂，客户端需要花更多时间理清类之间的层关系。

注意的问题：

1. 有时候系统需要遍历一个树枝结构的子构件很多次，这时候可以考虑把遍历子构件的结构存储在父构件里面作为缓存。
2. 客户端尽量不要直接调用树叶类中的方法，而是借用其父类的多态性完成调用，这样可以增加代码的复用性。

使用场景

• 需要表示一个对象整体或部分的结构层次
• 希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

总结

组合模式解耦了客户程序与复杂元素内部结构，从而是客户端可以像处理简单元素一样来处理复杂元素。