C# 设计模式系列教程-组合模式

1. 概述

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

2. 解决的问题

  当希望忽略单个对象和组合对象的区别,统一使用组合结构中的所有对象(将这种“统一”性封装起来)。

3. 组合模式中的角色

  3.1 组合部件(Component):它是一个抽象角色,为要组合的对象提供统一的接口。

  3.2 叶子(Leaf):在组合中表示子节点对象,叶子节点不能有子节点。

  3.3 合成部件(Composite):定义有枝节点的行为,用来存储部件,实现在Component接口中的有关操作,如增加(Add)和删除(Remove)。

4. 模式解读

  4.1 组合模式的类图

  4.2 组合模式的实现代码

  /// <summary>
  /// 一个抽象构件,声明一个接口用于访问和管理Component的子部件
  /// </summary>
  public abstract class Component
  {
    protected string name;

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

    /// <summary>
    /// 增加一个节点
    /// </summary>
    /// <param name="component"></param>
    public abstract void Add(Component component);

    /// <summary>
    /// 移除一个节点
    /// </summary>
    /// <param name="component"></param>
    public abstract void Remove(Component component);

    /// <summary>
    /// 显示层级结构
    /// </summary>
    public abstract void Display(int level);
  }

  /// <summary>
  /// 叶子节点
  /// </summary>
  public class Leaf : Component
  {
    public Leaf(string name)
      : base(name)
    { }

    /// <summary>
    /// 由于叶子节点没有子节点,所以Add和Remove方法对它来说没有意义,但它继承自Component,这样做可以消除叶节点和枝节点对象在抽象层次的区别,它们具备完全一致的接口。
    /// </summary>
    /// <param name="component"></param>
    public override void Add(Component component)
    {
      Console.WriteLine("Can not add a component to a leaf.");
    }

    /// <summary>
    /// 实现它没有意义,只是提供了一个一致的调用接口
    /// </summary>
    /// <param name="component"></param>
    public override void Remove(Component component)
    {
      Console.WriteLine("Can not remove a component to a leaf.");
    }

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

  /// <summary>
  /// 定义有枝节点的行为,用来存储部件,实现在Component接口中对子部件有关的操作
  /// </summary>
  public class Composite : Component
  {
    public Composite(string name)
      : base(name)
    { }

    /// <summary>
    /// 一个子对象集合,用来存储其下属的枝节点和叶节点
    /// </summary>
    private List<Component> children = new List<Component>();

    /// <summary>
    /// 增加子节点
    /// </summary>
    /// <param name="component"></param>
    public override void Add(Component component)
    {
      children.Add(component);
    }

    /// <summary>
    /// 移除子节点
    /// </summary>
    /// <param name="component"></param>
    public override void Remove(Component component)
    {
      children.Remove(component);
    }

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

      // 遍历其子节点并显示
      foreach (Component component in children)
      {
        component.Display(level+2);
      }
    }
  }

  4.3 客户端代码

  class Program
  {
    static void Main(string[] args)
    {
      // 生成树根,并为其增加两个叶子节点
      Component root = new Composite("Root");
      root.Add(new Leaf("Leaf A in Root"));
      root.Add(new Leaf("Leaf B in Root"));

      // 为根增加两个枝节点
      Component branchX = new Composite("Branch X in Root");
      Component branchY = new Composite("Branch Y in Root");
      root.Add(branchX);
      root.Add(branchY);

      // 为BranchX增加页节点
      branchX.Add(new Leaf("Leaf A in Branch X"));

      // 为BranchX增加枝节点
      Component branchZ = new Composite("Branch Z in Branch X");
      branchX.Add(branchZ);

      // 为BranchY增加叶节点
      branchY.Add(new Leaf("Leaf in Branch Y"));

      // 为BranchZ增加叶节点
      branchZ.Add(new Leaf("Leaf in Branch Z"));

      // 显示树
      root.Display(1);

      Console.Read();
    }
  }

  运行结果

5. 透明方式与安全方式

  5.1 透明方式:在Component中声明所有来管理子对象的方法,其中包括Add,Remove等。这样实现Component接口的所有子类都具备了Add和Remove方法。这样做的好处是叶节点和枝节点对于外界没有区别,它们具备完全一致的接口。

  5.2 安全方式:在Component中不去声明Add和Remove方法,那么子类的Leaf就不需要实现它,而是在Composit声明所有用来管理子类对象的方法。

  5.3 两种方式有缺点:对于透明方式,客户端对叶节点和枝节点是一致的,但叶节点并不具备Add和Remove的功能,因而对它们的实现是没有意义的;对于安全方式,叶节点无需在实现Add与Remove这样的方法,但是对于客户端来说,必须对叶节点和枝节点进行判定,为客户端的使用带来不便。

6. 模式总结

  6.1 优点

    6.1.1 使客户端调用简单,它可以一致使用组合结构或是其中单个对象,简化了客户端代码。

    6.1.2 容易在组合体内增加对象部件。客户端不必因加入了新的部件而更改代码。有利于功能的扩展。

  6.2 缺点

    6.2.1 需要抉择使用透明方式还是安全方式。

    6.2.2 透明方式违背了面向对象的单一职责原则;安全方式增加了客户需要端判定的负担。

  6.3 适用场景

    6.3.1 当想表达对象的部分-整体的层次结构时

    6.3.3 希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象时。

(0)

相关推荐

  • C#列表框、复选列表框、组合框的用法实例

    本文实例讲述了C#列表框.复选列表框.组合框的用法.分享给大家供大家参考.具体分析如下: 功能实现效果如下图所示: 实现代码: 1.声明相关变量存储专业.课程设置及相关信息: 复制代码 代码如下: string gr, msg, xy; string[] spec, cour1, cour2, cour3, cour4, cour5; 2.在Form1类中自定义函数bool checkGR()检查学生信息: 复制代码 代码如下: private bool checkGR() {     bool

  • C#组合函数的使用详解

    如下所示: 复制代码 代码如下: using System;using System.Collections.Generic;using System.Text;namespace ConsoleApplication1{ class Class1    {        static string[] str = { "A", "B", "C", "D", "E" };        static voi

  • c# 组合模式

    结构图: 抽象对象: 复制代码 代码如下: abstract class Component    {        protected string name;        public Component(string name)        {            this.name = name;        }        public abstract void Add(Component c);        public abstract void Remove(Com

  • C#实现图形区域组合操作的方法

    本文实例讲述了C#实现图形区域组合操作的方法.分享给大家供大家参考.具体实现方法如下: using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; namespace advanced_drawing { public parti

  • C#组合模式实例详解

    本文实例讲述了C#组合模式.分享给大家供大家参考.具体如下: Company.cs如下: using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 { public abstract class Company { protected string name; public Company(string name) { t

  • C#实现图形位置组合转换的方法

    本文实例讲述了C#实现图形位置组合转换的方法.分享给大家供大家参考.具体实现方法如下: using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.Drawing.Drawing2D; namespace

  • C#中实现任意List的全组合算法代码

    复制代码 代码如下: using System;using System.Collections.Generic;using System.Linq;using System.Text; namespace 算法{    class 全组合算法    {        [Flags]        public enum PersonType        {            Audit = 1,            Child = 2,            Senior = 4   

  • C#实现组合排列的方法

         C#实现组合排列的方法 最近在做数据分析系统,里面涉及到组合排列的问题,查找了很多的资料,但是感觉很多资料都是比较零散的,达不到项目需求. 后来经过一段的时间的探索,终于实现了组合排列的功能.下面我就来简单说说吧.      需求描述:   要实现的功能就是字符或数字的组合排列.例如:ab 的所有组合为:ab,ba :  ab的所有不重复排列为:ab. 其实这也是彩票中常说的直选和组选.效果图如下:     功能实现 这里就不多说了,直接贴上实现代码吧.       1.窗体界面 窗体

  • C#查找字符串所有排列组合的方法

    本文实例讲述了C#查找字符串所有排列组合的方法.分享给大家供大家参考.具体实现方法如下: // 1. remove first char // 2. find permutations of the rest of chars // 3. Attach the first char to each of those permutations. // 3.1 for each permutation, move firstChar in all indexes // to produce even

  • C# 设计模式系列教程-组合模式

    1. 概述 将对象组合成树形结构以表示"部分-整体"的层次结构.组合模式使得用户对单个对象和组合对象的使用具有一致性. 2. 解决的问题 当希望忽略单个对象和组合对象的区别,统一使用组合结构中的所有对象(将这种"统一"性封装起来). 3. 组合模式中的角色 3.1 组合部件(Component):它是一个抽象角色,为要组合的对象提供统一的接口. 3.2 叶子(Leaf):在组合中表示子节点对象,叶子节点不能有子节点. 3.3 合成部件(Composite):定义有枝

  • Android设计模式系列之组合模式

    Android中对组合模式的应用,可谓是泛滥成粥,随处可见,那就是View和ViewGroup类的使用.在android UI设计,几乎所有的widget和布局类都依靠这两个类. 组合模式,Composite Pattern,是一个非常巧妙的模式.几乎所有的面向对象系统都应用到了组合模式. 1.意图 将对象View和ViewGroup组合成树形结构以表示"部分-整体"的层次结构(View可以做为ViewGroup的一部分). 组合模式使得用户对单个对象View和组合对象ViewGrou

  • 设计模式系列之组合模式及其在JDK和MyBatis源码中的运用详解

    组合模式及其在JDK源码中的运用 前言组合和聚合什么是组合模式示例透明组合模式透明组合模式的缺陷安全组合模式 组合模式角色组合模式在JDK源码中的体现组合模式应用场景享元模式优缺点总结 前言 本文主要会讲述组合模式的用法,并会结合在JDK和MyBatis源码中的运用来进一步理解组合模式. 在编码原则中,有一条是:多用组合,少用继承.当然这里的组合和我们今天要讲的组合模式并不等价,这里的组合其实就是一种聚合,那么聚合和组合有什么区别呢? 组合和聚合 人在一起叫团伙,心在一起叫团队.用这句话来诠释组

  • C# 设计模式系列教程-建造者模式

    1. 概述 将一个复杂对象的构造与它的表示分离,使同样的构建过程可以创建不同的表示,这样的设计模式被称为建造者模式. 2. 建造者模式中的角色 2.1 建造者(Builder):为创建一个产品对象的各个部件指定抽象接口. 2.2 具体建造者(ConcreteBuilder):实现Builder的接口以构造和装配该产品的各个部件,定义并明确它所创建的表示,并 提供一个检索产品的接口. 2.3 指挥者(Director):指挥并构造一个使用Builder接口的对象. 2.4 产品(Product):

  • C# 设计模式系列教程-桥接模式

    1. 概述 将抽象部分(Abstraction)与实现部分(Implementor)分离,使它们可以独立地变化. 2. 解决的问题 在软件系统中,有些类型由于自身的逻辑,它具有两个或多个维度的变化.为了解决这种多维度变化,又不引入复杂度,这就要使用Bridge模式. 3. 模式中的角色 2.1 抽象(Abstraction):定义抽象接口,该接口中包含实现具体行为.具体特征的Implementor接口. 2.2 提炼的抽象(RefinedAbstraction):继承自Abstraction的子

  • C# 设计模式系列教程-命令模式

    1. 概述 将一个请求封装为一个对象(即我们创建的Command对象),从而使你可用不同的请求对客户进行参数化; 对请求排队或记录请求日志,以及支持可撤销的操作. 2. 解决的问题 在软件系统中,行为请求者与行为实现者通常是一种紧耦合的关系,但某些场合,比如需要对行为进行记录.撤销或重做.事务等处理时,这种无法抵御变化的紧耦合的设计就不太合适. 3. 模式中角色 3.1 抽象命令(Command):定义命令的接口,声明执行的方法. 3.2 具体命令(ConcreteCommand):具体命令,实

  • C# 设计模式系列教程-原型模式

    1. 概述 通过复制一个已经存在的实例来创建一个新的实例.被复制的实例被称为原型,这个原型是可定制的. 2. 模式中的角色 2.1 抽象原型类(Abstract Prototype):提供一个克隆接口 2.2 具体原型类(Concrete Prototype): 及实现了克隆接口的具体原型类 3. 实例:求职网站上现在都支持多份简历,如果每创建一份简历都要从头至尾地填写一遍,那也是非常让人沮丧的事.其实针对我们的求职岗位的不同,不同的简历可能只要修改局部内容就可以了,而不用全部重新构建一份新的简

  • C# 设计模式系列教程-模板方法模式

    1. 概述 定义一个操作中的算法的骨架,而将步骤延迟到子类中.模板方法使得子类可以不改变一个算法的结构即可重定义算法的某些特定步骤. 2. 模式中的角色 2.1 抽象类(AbstractClass):实现了模板方法,定义了算法的骨架. 2.2 具体类(ConcreteClass):实现抽象类中的抽象方法,已完成完整的算法. 3. 模式解读 3.1 模板方法类图 3.2 模板方法模式代码实现 /// <summary> /// 抽象类 /// </summary> public ab

  • C# 设计模式系列教程-状态模式

    1. 概述 当一个对象的内在状态改变时允许改变其行为,这个对象看起来像是改变了其类. 2. 解决的问题 主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况.把状态的判断逻辑转移到表示不同的一系列类当中,可以把复杂的逻辑判断简单化. 3. 模式中的角色 3.1 上下文环境(Context):它定义了客户程序需要的接口并维护一个具体状态角色的实例,将与状态相关的操作委托给当前的Concrete State对象来处理. 3.2 抽象状态(State):定义一个接口以封装使用上下文环境的的一

  • C# 设计模式系列教程-代理模式

    1. 概述 为其它对象提供一种代理以控制对这个对象的访问. 解决的问题:如果直接访问对象比较困难,或直接访问会给使用者或系统带来一系列问题.这样对于客户端(调用者)来说,就不需要直接与真实对象进行交互,解除了调用者与真实对象的耦合. 2. 模式中的角色 2.1 抽象实体(Subject):定义了真实实体(RealSubject)和代理(Proxy)的公共接口,这样就在任何时候使用真实实体(RealSubject)的地方使用代理(Proxy). 2.2 代理(Proxy):保存一个引用使得代理可以

随机推荐