设计模式之-组合模式

定义：

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

组合模式参与者

• Component：组合中对象的抽象和接口。
• Leaf：在组合中表示叶节点对象，叶节点没有子节点。
• Composite：在组合中表示枝节点对象，用来存储子部件，实现Component类中的所有操作。

组合模式基本代码

Component类：

namespace CompositePattern.BasicStructure
{
    abstract class Component
    {
        protected string Name { get; set; }
        public Component(string name)
        {
            this.Name = name;
        }

        public abstract void Add(Component component);
        public abstract void Remove(Component component);
        public abstract void Display(int depth);
    }
}

Leaf类：

namespace CompositePattern.BasicStructure
{
    /// <summary>
    /// 叶节点对象
    /// </summary>
    class Leaf : Component
    {
        public Leaf(string name) : base(name)
        {

        }
        public override void Add(Component component)
        {
            Console.WriteLine("不能添加一个叶节点");
        }

        public override void Remove(Component component)
        {
            Console.WriteLine("不能删除一个叶节点");
        }
        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + Name);
        }
    }
}

Composite类：

namespace CompositePattern.BasicStructure
{
    /// <summary>
    /// 枝节点对象
    /// </summary>
    class Composite : Component
    {
        private IList<Component> children = new List<Component>();
        public Composite(string name)
            : base(name)
        { }
        public override void Add(Component component)
        {
            children.Add(component);
        }

        public override void Remove(Component component)
        {
            children.Remove(component);
        }
        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + Name);
            foreach (Component component in children)
            {
                component.Display(depth + 2);
            }
        }
    }
}

客户端调用代码：

    static void Main(string[] args)
    {
        try
        {
            {//BasicStructure
                //初始化一个根节点
                Component root = new Composite("root");
                //添加两个叶节点
                root.Add(new Leaf("Leaf A"));
                root.Add(new Leaf("Leaf B"));

                //实例化一个枝节点，为枝节点添加两个叶节点，然后添加至根节点
                Component comp = new Composite("Composite X");
                comp.Add(new Leaf("Composite XA"));
                comp.Add(new Leaf("Composite XB"));
                root.Add(comp);
                //实例化一个枝节点，为枝节点添加两个叶节点，然后添加至根节点
                Component comp2 = new Composite("Composite Y");
                comp2.Add(new Leaf("Composite YA"));
                comp2.Add(new Leaf("Composite YB"));
                root.Add(comp2);

                root.Add(new Leaf("Leaf C"));
                Leaf leaf = new Leaf("Leaf D");
                root.Add(leaf);
                root.Remove(leaf);

                root.Display(1);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        Console.ReadKey();
    }

结果如下：

用组合模式实现公司组织架构管理

场景模拟：某公司分为总公司和分公司，总公司和分公司都分别有相同的部门。

我们可以用层级结构(树形结构)来实现，这就是所谓的"组合模式"

Company(公司抽象)类——Component类

namespace CompositePattern.SituationSimulation
{
    /// <summary>
    /// 公司抽象类
    /// </summary>
    abstract class Company
    {
        protected string Name { get; set; }
        public Company(string name)
        {
            this.Name = name;
        }

        public abstract void Add(Company company);
        public abstract void Remove(Company company);
        public abstract void Show(int depth);
        public abstract void LineOfDuty();//履行职责
    }
}

ConcreteCompany(具体公司)类——Composite类

namespace CompositePattern.SituationSimulation
{
    /// <summary>
    /// 具体公司类
    /// </summary>
    class ConcreteCompany : Company
    {
        private IList<Company> children = new List<Company>();
        public ConcreteCompany(string name)
            : base(name)
        { }
        public override void Add(Company company)
        {
            children.Add(company);
        }

        public override void Remove(Company company)
        {
            children.Remove(company);
        }
        /// <summary>
        /// 递归显示公司组织架构信息
        /// </summary>
        /// <param name="depth"></param>
        public override void Show(int depth)
        {
            Console.WriteLine(new String('-', depth) + Name);
            foreach (Company company in children)
            {
                company.Show(depth + 2);
            }
        }
        public override void LineOfDuty()
        {
            foreach (Company company in children)
            {
                company.LineOfDuty();
            }
        }
    }
}

HRDepartment(人力资源部门)类——Leaf类

namespace CompositePattern.SituationSimulation
{
    /// <summary>
    /// 人力资源部门类
    /// </summary>
    class HRDepartment : Company
    {
        private IList<Company> children = new List<Company>();
        public HRDepartment(string name)
            : base(name)
        { }
        public override void Add(Company company)
        {
        }

        public override void Remove(Company company)
        {
        }
        /// <summary>
        /// 递归显示人力资源部架构信息
        /// </summary>
        /// <param name="depth"></param>
        public override void Show(int depth)
        {
            Console.WriteLine(new String('-', depth) + Name);
            foreach (Company company in children)
            {
                company.Show(depth + 2);
            }
        }

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

DevDepartment(研发部门)类——Leaf类

namespace CompositePattern.SituationSimulation
{
    /// <summary>
    /// 研发部门类
    /// </summary>
    class DevDepartment : Company
    {
        private IList<Company> children = new List<Company>();
        public DevDepartment(string name)
            : base(name)
        { }
        public override void Add(Company company)
        {
        }

        public override void Remove(Company company)
        {
        }
        /// <summary>
        /// 递归显示研发部门架构信息
        /// </summary>
        /// <param name="depth"></param>
        public override void Show(int depth)
        {
            Console.WriteLine(new String('-', depth) + Name);
            foreach (Company company in children)
            {
                company.Show(depth + 2);
            }
        }

        public override void LineOfDuty()
        {
            Console.WriteLine($"{Name}研发管理");
        }
    }
}

客户端调用代码：

    static void Main(string[] args)
    {
        try
        {
            {//SituationSimulation
                Company company = new ConcreteCompany("华夏企业北京总公司");
                company.Add(new HRDepartment("北京总公司人力资源部"));
                company.Add(new HRDepartment("北京总公司研发部"));

                Company company2 = new ConcreteCompany("华夏企业深圳分公司");
                company2.Add(new HRDepartment("深圳分公司人力资源部"));
                company2.Add(new HRDepartment("深圳分公司研发部"));
                company.Add(company2);

                Company company3 = new ConcreteCompany("华夏企业深圳宝安区分公司");
                company3.Add(new HRDepartment("深圳宝安区分公司人力资源部"));
                company3.Add(new HRDepartment("深圳宝安区分公司研发部"));
                company2.Add(company3);

                Company company4 = new ConcreteCompany("华夏企业深圳龙华区分公司");
                company4.Add(new HRDepartment("深圳龙华区分公司人力资源部"));
                company4.Add(new HRDepartment("深圳龙华区分公司研发部"));
                company2.Add(company4);

                Company company5 = new ConcreteCompany("华夏企业上海分公司");
                company5.Add(new HRDepartment("上海分公司人力资源部"));
                company5.Add(new HRDepartment("上海分公司研发部"));
                company.Add(company5);

                company.Show(1);
                Console.WriteLine("职责：");
                company.LineOfDuty();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        Console.ReadKey();
    }

结果如下：

优点：

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

缺点：

• 使得设计更加复杂。客户端需要花更多时间理清类之间的层次关系。（这个是几乎所有设计模式所面临的问题）。

适用环境：

在以下情况下可以使用组合模式：

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

总结：

• 组合模式解耦了客户程序与复杂元素内部结构，从而使客户程序可以像处理简单元素一样来处理复杂元素。
• 如果你想要创建层次结构，并可以在其中以相同的方式对待所有元素，那么组合模式就是最理想的选择。本章使用了一个公司组织架构的例子来举例说明了组合模式的用途。在这个例子中，部门和公司都执行相同的接口(抽象类)，这是组合模式的关键。通过执行相同的接口(抽象类)，你就可以用相同的方式对待部门和公司，从而实现将部门或者公司储存为公司的子级元素。

源代码地址：https://github.com/houzhenhuang/DesignPattern