组合模式(Composite Pattern)

• 组合模式概述

---

定义：组合多个对象形成树形结构以表示具有部分-整体关系的层次结构。组合模式让客户端可以统一对待单个对象和组合对象。又被成为“部分-整体”(Part-Whole)模式，属于对象结构性模式

定义什么的，最枯燥了。简单的来说，就如我们鼠标右击新建文件夹一样，在一个磁盘里，我们可以新建一个文件夹A，也可以新建某个类型的文件a，A和a都在同一目录下，当然，我们也可以点击进入文件夹A，在A中新建新的文件夹B，也可以在A中新建文件b。只要是文件夹，就可以在里面继续新建文件夹和文件，而文件则只能用来放数据，不能在新建了。

当然，也可以通过win+r调出运行，输入cmd(commmand),进入你想查看文件的磁盘，输入tree命令，就可以结构性的查看所有文件。在上述图中可以看出文件结构就如同一棵树，有文件夹，有文件，我们把文件成为叶子(Laef)，因为文件不能再展开了，就如树形结构中叶子是最底层了；把文件夹称为容器(Container)，因为文件夹里既可以文件夹，又可以放文件。当想要查看一个磁盘的所有文件时，可以使用DFS(深度优先搜索)即递归的对每个文件夹进行同样的搜索，一条路走到底，当访问到叶子结点时，再退回去访问别的结点。

• 组合模式结构和实现

---

1. Component(抽象构件):它可以是接口或抽象类，为叶子构件和容器构件对象声明接口。定义了访问管理它的子构件的方法，就是对一个子构件该有的操作都应该在这声明，如创建子构件，删除子构件，打开子构件，重命名子构件，复制子构件.......
2. Leaf(叶子构件):代表一个文件，实现在Component中的行为，即对文件的操作，可以是读文件，写文件，删除文件，复制文件......
3. Composite(容器构件):代表一个文件夹，它提供一个集合放子节点，可以是文件夹，也可以是文件，所以它有一个聚合箭头指向Component，代表可以递归的创建构件

abstract class Component
{
    public abstract void Add(Component c);
    public abstract void Remove(Component c);
    public abstract Component GetChild(int i);
    public abstract void Operation();
}
class Leaf : Component
{
    public override void Add(Component c)
    {
        //throw new NotImplementedException();//这里是报错，叶子文件没有此方法的
    }
    
    public override void Remove(Component c)
    {
        //throw new NotImplementedException();//同上
    }
    
    public override Component GetChild(int i )
    {
        //throw new NotImplementedException();//同上
        return null;
    }
    
    public override void Operation()
    {
        //对文件的可执行方法
    }    
}
class Composite : Component
{
    private IList<Component> list = new List<Component>();//这里通链表容器存放文件夹
    public override void Add(Component c)
    {
        list.Add(c);
    }
    
    public override void Remoce(Component c)
    {
        list.Remove(c);
    }
    
    public override Component GetChild(int i )
    {
        return (Component)list(c);
    }
    
    public override void Operation()
    {
        //递归实现容器中的对文件的方法
        foreach(Component child in list)
        {
            (Component)child.Operation();
        }
    }    
}

• 组合模式的应用

---

 教育机构的OA系统要给各办公室下发公文(IssuedBytheOfficeDoucument)，采用组合模式模拟实现

分析：从图中可以看出，北京总部，湖南分校，长沙叫教学点，湘潭教学点这几个有子构件，所以它们为文件容器，而教务办公室，行政办公室即为叶子，当然，每个叶子是不同的，要区别开。因此我们定义一个抽象机构类(AbstractInstitutions)，其中声明Add，Remove，GetChild和IssuedBytheOfficeDoucument方法。

 abstract class AbstractInstitutions//Component
    {
        public abstract void Add(AbstractInstitutions institutions);
        public abstract void Remove(AbstractInstitutions institutions);
        public abstract AbstractInstitutions GetChild(int i);
        public abstract void IssuedBytheOfficeDoucument();
    }

教务办公室，有自己的名字，即哪一个教务办公室，它只能收到下发的公文

 class AcademicAffairsOffice : AbstractInstitutions//Leaf 教务办公室
    {
        private string name;
        public AcademicAffairsOffice(string name)
        {
            this.name = name;
        }
        public override void Add(AbstractInstitutions institutions)
        {
            Console.WriteLine("Can't realize this method!!!");
        }

        public override void Remove(AbstractInstitutions institutions)
        {
            Console.WriteLine("Can't realize this method!!!");
        }

        public override AbstractInstitutions GetChild(int i)
        {
            Console.WriteLine("Can't realize this method!!!");
            return null;
        }

        public override void IssuedBytheOfficeDoucument()
        {
            Console.WriteLine("issued by the office doucument to the {0}",name);
        }
    }

行政办公室和教务办公室类似的实现

class AdministrationOffice : AbstractInstitutions//Leaf  行政办公室
    {
         private string name;
        public AdministrationOffice(string name)
        {
            this.name = name;
        }

        public override void Add(AbstractInstitutions institutions)
        {
            Console.WriteLine("Can't realize this method!!!");
        }

        public override void Remove(AbstractInstitutions institutions)
        {
            Console.WriteLine("Can't realize this method!!!");
        }

        public override AbstractInstitutions GetChild(int i)
        {
            Console.WriteLine("Can't realize this method!!!");
            return null;
        }

        public override void IssuedBytheOfficeDoucument()
        {
            Console.WriteLine("issued by the office doucument to the {0}", name);
        }
    }

容器类中实现抽象构件中的方法，并且要向下属机构下发公文

class TeachArea : AbstractInstitutions//Composite //教学点
    {
        private string name;
        private IList<AbstractInstitutions> AreaList = new List<AbstractInstitutions>();
       
        public TeachArea(String name)
        {
            this.name = name;
        }

        public override void Add(AbstractInstitutions institutions)
        {
            AreaList.Add(institutions);
        }

        public override void Remove(AbstractInstitutions institutions)
        {
            AreaList.Remove(institutions);
        }

        public override AbstractInstitutions GetChild(int i)
        {
            return (AbstractInstitutions)AreaList[i];
        }

        public override void IssuedBytheOfficeDoucument()
        {
            Console.WriteLine("Issue official documents to the {0}", name);
            foreach (Object obj in AreaList)
            {
                ((AbstractInstitutions)obj).IssuedBytheOfficeDoucument();
            }
        }
    }

Program中，要将所有的机构创建出来，并一一Add到对应的容器中，最后有由北京总部向下发送公文

class Program
    {
        static void Main(string[] args)
        {
            AbstractInstitutions BeijingHeadquarters;
            BeijingHeadquarters = new TeachArea("BeijingHeadquarters");

            AbstractInstitutions BeijingAcademicAffairsOffice;
            BeijingAcademicAffairsOffice = new AcademicAffairsOffice("BeijingAcademicAffairsOffice");
            AdministrationOffice BeijingAdministrationOffice;
            BeijingAdministrationOffice = new AdministrationOffice("BeijingAdministrationOffice");

            AbstractInstitutions HunanPartition;
            HunanPartition = new TeachArea("HunanPartition");

            AbstractInstitutions HunanChangshaArea;
            HunanChangshaArea = new TeachArea("HunanChangshaArea");

            AbstractInstitutions HunanXiangtanArea;
            HunanXiangtanArea = new TeachArea("HunanXiangtanArea");

            AbstractInstitutions HunanAcademicAffairOffice;
            HunanAcademicAffairOffice = new AcademicAffairsOffice("HunanAcademicAffairOffice");
            AbstractInstitutions HunanAdministrationOffice;
            HunanAdministrationOffice = new AdministrationOffice("HunanAdministrationOffice");

            Console.WriteLine();
            AbstractInstitutions ChangshaAcademicAffairOffice;
            ChangshaAcademicAffairOffice = new AcademicAffairsOffice("ChangshaAcademicAffairOffice");

            AbstractInstitutions ChangshaAdministrationOffice;
            ChangshaAdministrationOffice = new AdministrationOffice("ChangshaAdministrationOffice");
            AbstractInstitutions XiangtanAcademicAffairOffice;
            XiangtanAcademicAffairOffice = new AcademicAffairsOffice("XiangtanAcademicAffairOffice");

            AbstractInstitutions XiangtanAdministrationOffice;
            XiangtanAdministrationOffice = new AdministrationOffice("XiangtanAdministrationOffice");

            HunanChangshaArea.Add(ChangshaAcademicAffairOffice);
            HunanChangshaArea.Add(ChangshaAdministrationOffice);

            HunanXiangtanArea.Add(XiangtanAcademicAffairOffice);
            HunanXiangtanArea.Add(XiangtanAdministrationOffice);

            HunanPartition.Add(HunanChangshaArea);
            HunanPartition.Add(HunanXiangtanArea);
            HunanPartition.Add(HunanAcademicAffairOffice);
            HunanPartition.Add(HunanAdministrationOffice);

            BeijingHeadquarters.Add(BeijingAcademicAffairsOffice);
            BeijingHeadquarters.Add(BeijingAdministrationOffice);
            BeijingHeadquarters.Add(HunanPartition);
            BeijingHeadquarters.IssuedBytheOfficeDoucument();
        }
    }

运行结果：

• 透明组合模式和安全组合模式

---

• 透明组合模式

在Component中声明所有的方法，这样满足了一致性的原则，即对叶子和容器对象都是一样的处理，不需用再去判断，这个对象是叶子还是容器啊，如果是容器，可以实现哪些方法，如果是叶子，又只能实现哪些方法。这些判断都不需要。但是，由于叶子也继承了Component的方法，因此不安全，叶子对象不能调用Add，Remove，GetChild的方法，如果运行时调用，会出错，因此要提供错误处理代码(如上述例子中的( Console.WriteLine("Can't realize this method!!!");

• 安全组合模式

Component中没有声明任何方法，而是在Composite中声明并实现，这样做不会因为Leaf调用错误的方法而报错，但缺点是不够透明，即要区别的对待叶子构件和容器构件，但是日常使用是很多的，毕竟安全的往往好很多

上面的例子使用了透明组合模式。

• 组合模式的优缺点和适用环境

---

• 组合模式的优点：

1. 可以清楚的定义分层次的复杂对象，表示对象的全部会部分层次，让客户忽略层次的差异，方便控制
2. 客户端可以一致性的使用一个组合结构或其中单个对象，不必关心处理的是单个对象(叶子文件)还是组合结构(文件夹容器)，简化了客户端代码
3. 增加新的容器构件和叶子构件很方便
4. 为树型结构的面向对象实现了一种灵活的解决方案

• 组合模式的缺点：

1. 在增加新的构件时很难对容器中的构件类型进行控制。如果我希望文件夹里只能放文件时，则需要复杂的实现过程来实现

• 组合模式的适用环境

1. 在具有整体和部分层次的结构中，希望通过一种方式忽略整体与部分的差异，一致的对待它们
2. 在一个使用面向对象语言开发的系统中要处理一个树形结构时
3. 在一个系统总能够分离出叶子和容器对象，而且它们的类型不固定，需要增加一些新的类型