组合模式（Composite Pattern）

组合模式（Composite Pattern）：
将对象组合成树形结构以表示“部分”-“整体”的层次结构。组合模式使得用户对单个对象的处理和组合复杂的对象处理
具有一致性。

/// <summary>
    /// Component为组合对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。
    /// 声明一个接口用于访问和管理Component的子部件
    /// </summary>
    abstract class Component
    {
        protected string name;

        public Component(string name)
        {
            this.name = name;
        }

        //通过Add和Remove方法来提供增加或移除树叶或树枝的功能
        public abstract void Add(Component c);
        public abstract void Remove(Component c);
        public abstract void Display(int depth);

    }

    /// <summary>
    /// Leaf在组合模式中表示叶节点对象，叶节点没有子节点
    /// </summary>
    class Leaf : Component
    {
        public Leaf(string name)
            : base(name)
        {

        }

        public override void Add(Component c)
        {
            Console.WriteLine("叶节点没有子节点，不能添加！");
        }

        public override void Remove(Component c)
        {
            Console.WriteLine("叶节点没有子节点，不能移除！");
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
        }
    }

    /// <summary>
    /// Composite定义有子节点的行为，用来存储子部件，在Component接口中实现与子部件有关的操作
    /// 可能由多个不同的Leaf组合而成
    /// </summary>
    class Composite : Component
    {
        private List<Component> child = new List<Component>();

        public Composite(string name)
            : base(name)
        {

        }

        public override void Add(Component c)
        {
            child.Add(c);
        }

        public override void Remove(Component c)
        {
            if(child.Contains(c))
            {
                child.Remove(c);
            }
        }

        /// <summary>
        /// 显示其枝节点名称，并对其下级进许遍历
        /// </summary>
        /// <param name="depth"></param>
        public override void Display(int depth)
        {
            Console.WriteLine(new String('-',depth),name);
            foreach (Component c in child)
            {
                c.Display(depth + 2);
            }
        }
    }

    /// <summary>
    /// 客户端引用
    /// </summary>
    class Program
    {
        static void Main()
        {
            //任意组合，但处理对于客户来说都是一样的
            Composite root = new Composite("root");
            root.Add(new Leaf("LeafA"));
            root.Add(new Leaf("LeafB"));

            Composite comp = new Composite("CompositeX");
            comp.Add(new Leaf("LeafXA"));
            comp.Add(new Leaf("LeafXB"));

            root.Add(comp);

            Composite comp2 = new Composite("CompositeXY");
            comp2.Add(new Leaf("LeafXYA"));
            comp2.Add(new Leaf("LeafXYB"));

            comp.Add(comp2);

            root.Add(new Leaf("LeafC"));

            root.Display(1);
        }

    }

 透明方式：在Component中声明所有用来管理子对象的方法，其中包括Add、Remove等。这样实现Component接口的所有
 子类都具备了Add和Remove方法，这样做的好处就是叶节点和枝节点对于外界来说没有区别，它们具有完全一致的接口，
 但问题是因为Leaf叶节点本身不具备Add和Remove方法的功能，所以有时会出现异常错误(最好抛出异常信息),而且实现
 也就没有意义了。

 安全方式：在Component接口中不声明Add和Remove方法，那么在Leaf中也就不需要去实现它，而是在Composite声明所有
 用来管理子类的方法，这样就不会出现透明方式中所提到的问题，但由于不够透明，所以树节点和叶节点将不具备相同
 的接口，客户端调用需要做相应的判断，带来了不便。

 优势和缺陷：
 组合模式可以清楚的定义分层次的复杂对象，表示对象的全部或部分层次，使得增加新部件也更容易，因为它让客户忽略
 了层次的不同性，而它的结构又是动态的，提供了对象管理的灵活接口。主要用于对树结构的控制。例如人力资源系统的
 组织架构及ERP系统的BOM设计中。组合模式的缺陷是使得设计变得更加抽象。对象的商业规则如果很复杂，则实现组合模式
 具有很大的挑战性，并且，不是所有的方法都与野节点子类有关联。

 应用场景：
 (1)想表示一个对象整体或部分层次
 (2)想让客户能够忽略不同对象的层次变化
 (3)对象的结构是动态的并且复杂程度不一样，但客户需要一致地处理它们。

 实例应用：公司管理系统

 

/// <summary>
    /// Component：抽象接口
    /// </summary>
    public abstract class Company
    {
        protected string name;

        public Company(string name)
        {
            this.name = name;
        }

        public abstract void Add(Company c);
        public abstract void Remove(Company c);
        public abstract void Display(int depth);
        public abstract void LineOfDuty();//履行的职责，不同的部门不一样
    }

    class ConcreteCompany : Company
    {
        private IList<Company> child = new List<Company>();

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

        public override void Add(Company c)
        {
            child.Add(c);
        }

        public override void Remove(Company c)
        {
            if (child.Contains(c))
            {
                child.Remove(c);
            }
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth)+ name);

            foreach (Company c in child)
            {
                c.Display(depth+2);
            }
        }

        public override void LineOfDuty()
        {
            foreach (Company c in child)
            {
                c.LineOfDuty();
            }
        }
    }

    /// <summary>
    /// 人力资源部:叶节点
    /// </summary>
    public class HRDepartMent : Company
    {
        public HRDepartMent(string name)
            : base(name)
        {

        }

        public override void Add(Company c)
        {
           
        }

        public override void Remove(Company c)
        {
           
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth)+ name);
        }

        public override void LineOfDuty()
        {
            Console.WriteLine("{0}员工招聘培训管理", name);
        }
    }

    /// <summary>
    /// 财务部
    /// </summary>
    public class FinalceDepartment : Company
    {
        public FinalceDepartment(string name)
            : base(name)
        {

        }
        public override void Add(Company c)
        {
           
        }

        public override void Remove(Company c)
        {
           
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth)+name);
        }

        public override void LineOfDuty()
        {
            Console.WriteLine("{0}公司财务收支管理", name);
        }
    }

    public class Program
    {
        public static void Main()
        {
            ConcreteCompany root = new ConcreteCompany("北京总公司");
            root.Add(new HRDepartMent("总公司人力资源部"));
            root.Add(new FinalceDepartment("总公司财务部"));

            ConcreteCompany comp = new ConcreteCompany("上海分公司");
            comp.Add(new HRDepartMent("上海分公司人力资源部"));
            comp.Add(new FinalceDepartment("上海分公司财务部"));

            root.Add(comp);

            ConcreteCompany comp1 = new ConcreteCompany("南京办事处");
            comp1.Add(new HRDepartMent("南京办事处人力资源部"));
            comp1.Add(new FinalceDepartment("南京办事处财务部"));

            comp.Add(comp1);

            ConcreteCompany comp2 = new ConcreteCompany("杭州办事处");
            comp2.Add(new HRDepartMent("杭州办事处人力资源部"));
            comp2.Add(new FinalceDepartment("杭州办事处财务部"));

            comp.Add(comp2);

            Console.WriteLine("\n 公司结构图");
            root.Display(1);
            Console.WriteLine("\n 职责");
            root.LineOfDuty();
        }
    }