首页 > 其他分享 >第10章 组合模式(Composite Pattern)

第10章 组合模式(Composite Pattern)

时间:2023-06-11 14:07:08浏览次数:44  
标签:10 定位器 name Composite Pattern void Draw Graphics public


组合模式(Composite Pattern)

——.NET设计模式系列之十一

Terrylee,2006年3月

概述

组合模式有时候又叫做部分-整体模式,它使我们树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

意图

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

结构图

第10章 组合模式(Composite Pattern)_library

图1 Composite模式结构图

生活中的例子

组合模式将对象组合成树形结构以表示"部分-整体"的层次结构。让用户一致地使用单个对象和组合对象。虽然例子抽象一些,但是算术表达式确实是组合的例子。算术表达式包括操作数、操作符和另一个操作数。操作数可以是数字,也可以是另一个表达式。这样,2+3和(2+3)+(4*6)都是合法的表达式。

第10章 组合模式(Composite Pattern)_library_02

图2 使用算术表达式例子的Composite模式对象图

组合模式解说

这里我们用绘图这个例子来说明Composite模式,通过一些基本图像元素(直线、圆等)以及一些复合图像元素(由基本图像元素组合而成)构建复杂的图形树。在设计中我们对每一个对象都配备一个Draw()方法,在调用时,会显示相关的图形。可以看到,这里复合图像元素它在充当对象的同时,又是那些基本图像元素的一个容器。先看一下基本的类结构图:

第10章 组合模式(Composite Pattern)_newline_03

图3

图中橙色的区域表示的是复合图像元素。示意性代码:

public abstract class Graphics
  
{
  
    protected string _name;
  

    public Graphics(string name)
  
    
  
{
  
        this._name = name;
  
    }
  
    public abstract void Draw();
  
}
  

public class Picture : Graphics
  
{
  
    public Picture(string name)
  
        : base(name)
  
    
  
{ }
  
    public override void Draw()
  
    
  
{
  
        //
  

    }
  

    public ArrayList GetChilds()
  
    
  
{ 
  
        //
  
返回所有的子对象
  
    }
  
}


而其他作为树枝构件,实现代码如下:

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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
}  

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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
}  

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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
}

现在我们要对该图像元素进行处理:在客户端程序中,需要判断返回对象的具体类型到底是基本图像元素,还是复合图像元素。如果是复合图像元素,我们将要用递归去处理,然而这种处理的结果却增加了客户端程序与复杂图像元素内部结构之间的依赖,那么我们如何去解耦这种关系呢?我们希望的是客户程序可以像处理基本图像元素一样来处理复合图像元素,这就要引入Composite模式了,需要把对于子对象的管理工作交给复合图像元素,为了进行子对象的管理,它必须提供必要的Add(),Remove()等方法,类结构图如下:

第10章 组合模式(Composite Pattern)_设计模式_04

图4

示意性代码:


public abstract class Graphics  
{  
    protected string _name;  

    public Graphics(string name)  
      
{  
        this._name = name;  
    }  
    public abstract void Draw();  
    public abstract void Add();  
    public abstract void Remove();  
}  

public class Picture : Graphics  
{  
    protected ArrayList picList = new ArrayList();  

    public Picture(string name)  
        : base(name)  
      
{ }  
    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  

        foreach (Graphics g in picList)  
          
{  
            g.Draw();  
        }  
    }  

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

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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
    public override void Add(Graphics g)  
      
{ }  
    public override void Remove(Graphics g)  
      
{ }  
}  

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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
    public override void Add(Graphics g)  
      
{ }  
    public override void Remove(Graphics g)  
      
{ }  
}  

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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
    public override void Add(Graphics g)

第10章 组合模式(Composite Pattern)_出版_05

    

第10章 组合模式(Composite Pattern)_设计模式_06

{ }

第10章 组合模式(Composite Pattern)_newline_07

    public override void Remove(Graphics g)

第10章 组合模式(Composite Pattern)_library_08

第10章 组合模式(Composite Pattern)_出版_05

    

第10章 组合模式(Composite Pattern)_设计模式_06

{ }

第10章 组合模式(Composite Pattern)_出版_11

}

这样引入Composite模式后,客户端程序不再依赖于复合图像元素的内部实现了。然而,我们程序中仍然存在着问题,因为Line,Rectangle,Circle已经没有了子对象,它是一个基本图像元素,因此Add(),Remove()的方法对于它来说没有任何意义,而且把这种错误不会在编译的时候报错,把错误放在了运行期,我们希望能够捕获到这类错误,并加以处理,稍微改进一下我们的程序:


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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
    public override void Add(Graphics g)  
      
{   
        //抛出一个我们自定义的异常  
    }  
    public override void Remove(Graphics g)  
      
{  
        //抛出一个我们自定义的异常  
    }  
}

这样改进以后,我们可以捕获可能出现的错误,做进一步的处理。上面的这种实现方法属于透明式的Composite模式,如果我们想要更安全的一种做法,就需要把管理子对象的方法声明在树枝构件Picture类里面,这样如果叶子节点Line,Rectangle,Circle使用这些方法时,在编译期就会出错,看一下类结构图:

第10章 组合模式(Composite Pattern)_library_12

图5

示意性代码:

public abstract class Graphics  
{  
    protected string _name;  

    public Graphics(string name)  
      
{  
        this._name = name;  
    }  
    public abstract void Draw();  
}  

public class Picture : Graphics  
{  
    protected ArrayList picList = new ArrayList();  

    public Picture(string name)  
        : base(name)  
      
{ }  
    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  

        foreach (Graphics g in picList)  
          
{  
            g.Draw();  
        }  
    }  

    public void Add(Graphics g)  
      
{  
        picList.Add(g);  
    }  
    public void Remove(Graphics g)  
      
{  
        picList.Remove(g);  
    }  
}  

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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
}  

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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
}  

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

    public override void Draw()  
      
{  
        Console.WriteLine("Draw a" + _name.ToString());  
    }  
}

这种方式属于安全式的Composite模式,在这种方式下,虽然避免了前面所讨论的错误,但是它也使得叶子节点和树枝构件具有不一样的接口。这种方式和透明式的Composite各有优劣,具体使用哪一个,需要根据问题的实际情况而定。通过Composite模式,客户程序在调用Draw()的时候不用再去判断复杂图像元素中的子对象到底是基本图像元素,还是复杂图像元素,看一下简单的客户端调用:

public class App  
{  
    public static void Main()  
      
{  
        Picture root = new Picture("Root");  

        root.Add(new Line("Line"));  
        root.Add(new Circle("Circle"));  

        Rectangle r = new Rectangle("Rectangle");  
        root.Add(r);  

        root.Draw();  
    }  
}

.NET中的组合模式

如果有人用过Enterprise Library2.0,一定在源程序中看到了一个叫做ObjectBuilder的程序集,顾名思义,它是用来负责对象的创建工作的,而在ObjectBuilder中,有一个被称为定位器的东西,通过定位器,可以很容易的找到对象,它的结构采用链表结构,每一个节点是一个键值对,用来标识对象的唯一性,使得对象不会被重复创建。定位器的链表结构采用可枚举的接口类来实现,这样我们可以通过一个迭代器来遍历这个链表。同时多个定位器也被串成一个链表。具体地说就是多个定位器组成一个链表,表中的每一个节点是一个定位器,定位器本身又是一个链表,表中保存着多个由键值对组成的对象的节点。所以这是一个典型的Composite模式的例子,来看它的结构图:

第10章 组合模式(Composite Pattern)_出版_13


图6

正如我们在图中所看到的,IReadableLocator定义了最上层的定位器接口方法,它基本上具备了定位器的大部分功能。

部分代码:

public interface IReadableLocator : IEnumerable<KeyValuePair<object, object>>  
{  
    //返回定位器中节点的数量  
    int Count   
{ get; }  

    //一个指向父节点的引用  
    IReadableLocator ParentLocator   
{ get; }  

    //表示定位器是否只读  
    bool ReadOnly   
{ get; }  

    //查询定位器中是否已经存在指定键值的对象  
    bool Contains(object key);  

    //查询定位器中是否已经存在指定键值的对象,根据给出的搜索选项,表示是否要向上回溯继续寻找。  
    bool Contains(object key, SearchMode options);  

    //使用谓词操作来查找包含给定对象的定位器  
    IReadableLocator FindBy(Predicate<KeyValuePair<object, object>> predicate);  

    //根据是否回溯的选项,使用谓词操作来查找包含对象的定位器  
    IReadableLocator FindBy(SearchMode options, Predicate<KeyValuePair<object, object>> predicate);  

    //从定位器中获取一个指定类型的对象  
    TItem Get<TItem>();  

    //从定位其中获取一个指定键值的对象  
    TItem Get<TItem>(object key);  

    //根据选项条件,从定位其中获取一个指定类型的对象  
    TItem Get<TItem>(object key, SearchMode options);  

    //给定对象键值获取对象的非泛型重载方法  
    object Get(object key);  

    //给定对象键值带搜索条件的非泛型重载方法  
object Get(object key, SearchMode options);  
}   
一个抽象基类ReadableLocator用来实现这个接口的公共方法。两个主要的方法实现代码如下:
  
  
public abstract class ReadableLocator : IReadableLocator  
{  
    /** <summary>  
    /// 查找定位器,最后返回一个只读定位器的实例  
    /// </summary>  
    public IReadableLocator FindBy(SearchMode options, Predicate<KeyValuePair<object, object>> predicate)  
      
{  
        if (predicate == null)  
            throw new ArgumentNullException("predicate");  
        if (!Enum.IsDefined(typeof(SearchMode), options))  
            throw new ArgumentException(Properties.Resources.InvalidEnumerationValue, "options");  

        Locator results = new Locator();  
        IReadableLocator currentLocator = this;  

        while (currentLocator != null)  
          
{  
            FindInLocator(predicate, results, currentLocator);  
            currentLocator = options == SearchMode.Local ? null : currentLocator.ParentLocator;  
        }  

        return new ReadOnlyLocator(results);  
    }  

    /** <summary>  
    /// 遍历定位器  
    /// </summary>  
    private void FindInLocator(Predicate<KeyValuePair<object, object>> predicate, Locator results,  
                                        IReadableLocator currentLocator)  
      
{  
        foreach (KeyValuePair<object, object> kvp in currentLocator)  
          
{  
            if (!results.Contains(kvp.Key) && predicate(kvp))  
              
{  
                results.Add(kvp.Key, kvp.Value);  
            }  
        }  
    }  
}

可以看到,在FindBy方法里面,循环调用了FindInLocator方法,如果查询选项是只查找当前定位器,那么循环终止,否则沿着定位器的父定位器继续向上查找。FindInLocator方法就是遍历定位器,然后把找到的对象存入一个临时的定位器。最后返回一个只读定位器的新的实例。

从这个抽象基类中派生出一个具体类和一个抽象类,一个具体类是只读定位器(ReadOnlyLocator),只读定位器实现抽象基类没有实现的方法,它封装了一个实现了IReadableLocator接口的定位器,然后屏蔽内部定位器的写入接口方法。另一个继承的是读写定位器抽象类ReadWriteLocator,为了实现对定位器的写入和删除,这里定义了一个对IReadableLocator接口扩展的接口叫做IReadWriteLocator,在这个接口里面提供了实现定位器的操作:

第10章 组合模式(Composite Pattern)_出版_14


图7

实现代码如下:


public interface IReadWriteLocator : IReadableLocator  
{  
    //保存对象到定位器  
    void Add(object key, object value);  

    //从定位器中删除一个对象,如果成功返回真,否则返回假  
    bool Remove(object key);   
}

从ReadWirteLocator派生的具体类是Locator类,Locator类必须实现一个定位器的全部功能,现在我们所看到的Locator它已经具有了管理定位器的功能,同时他还应该具有存储的结构,这个结构是通过一个WeakRefDictionary类来实现的,这里就不介绍了。[关于定位器的介绍参考了niwalker的Blog]

效果及实现要点

1.Composite模式采用树形结构来实现普遍存在的对象容器,从而将“一对多”的关系转化“一对一”的关系,使得客户代码可以一致地处理对象和对象容器,无需关心处理的是单个的对象,还是组合的对象容器。

2.将“客户代码与复杂的对象容器结构”解耦是Composite模式的核心思想,解耦之后,客户代码将与纯粹的抽象接口——而非对象容器的复内部实现结构——发生依赖关系,从而更能“应对变化”。

3.Composite模式中,是将“Add和Remove等和对象容器相关的方法”定义在“表示抽象对象的Component类”中,还是将其定义在“表示对象容器的Composite类”中,是一个关乎“透明性”和“安全性”的两难问题,需要仔细权衡。这里有可能违背面向对象的“单一职责原则”,但是对于这种特殊结构,这又是必须付出的代价。ASP.NET控件的实现在这方面为我们提供了一个很好的示范。

4.Composite模式在具体实现中,可以让父对象中的子对象反向追溯;如果父对象有频繁的遍历需求,可使用缓存技巧来改善效率。

适用性

以下情况下适用Composite模式:

1.你想表示对象的部分-整体层次结构

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

总结

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

参考资料

阎宏,《Java与模式》,电子工业出版社

James W. Cooper,《C#设计模式》,电子工业出版社

Alan Shalloway James R. Trott,《Design Patterns Explained》,中国电力出版社

MSDN WebCast 《C#面向对象设计模式纵横谈(9):Composite组合模式(结构型模式)》


作者: TerryLee

标签:10,定位器,name,Composite,Pattern,void,Draw,Graphics,public
From: https://blog.51cto.com/u_130277/6457556

相关文章

  • 第8章 桥接模式(Bridge Pattern)
    桥接模式(BridgePattern)——.NET设计模式系列之九Terrylee,2006年2月概述在软件系统中,某些类型由于自身的逻辑,它具有两个或多个维度的变化,那么如何应对这种“多维度的变化”?如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化,而又不引入额外的复杂度?这就要使用Bridg......
  • Win10任务栏右下角日期时间秒数 星期几显示设置
    步骤1:点击跳转步骤2:点击跳转Tips:记得关闭小任务栏模式否则日期和周几都不会显示......
  • 算法学习day53动态规划part14-1143、53、1035
    packageLeetCode.DPpart14;/***1143.最长公共子序列*给定两个字符串text1和text2,返回这两个字符串的最长公共子序列的长度。*如果不存在公共子序列,返回0。*一个字符串的子序列是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些......
  • 第7章 适配器模式(Adapter Pattern)
    适配器模式(AdapterPattern)——.NET设计模式系列之八Terrylee,2006年2月概述在软件系统中,由于应用环境的变化,常常需要将“一些现存的对象”放在新的环境中应用,但是新环境要求的接口是这些现存对象所不满足的。那么如何应对这种“迁移的变化”?如何既能利用现有对象的良好实现,同时又能......
  • 第5章 原型模式(Protype Pattern)
    原型模式(PrototypePattern)——.NET设计模式系列之六Terrylee,2006年1月概述在软件系统中,有时候面临的产品类是动态变化的,而且这个产品类具有一定的等级结构。这时如果用工厂模式,则与产品类等级结构平行的工厂方法类也要随着这种变化而变化,显然不大合适。那么如何封装这种动态的变化......
  • 第11章 外观模式(Façade Pattern)
    外观模式(FaçadePattern)——.NET设计模式系列之十二Terrylee,2006年3月概述在软件开发系统中,客户程序经常会与复杂系统的内部子系统之间产生耦合,而导致客户程序随着子系统的变化而变化。那么如何简化客户程序与子系统之间的交互接口?如何将复杂系统的内部子系统与客户程序之间的依赖......
  • 第9章 装饰模式(Decorator Pattern)
    装饰模式(DecoratorPattern)——.NET设计模式系列之十Terrylee,2006年3月概述在软件系统中,有时候我们会使用继承来扩展对象的功能,但是由于继承为类型引入的静态特质,使得这种扩展方式缺乏灵活性;并且随着子类的增多(扩展功能的增多),各种子类的组合(扩展功能的组合)会导致更多子类的膨胀。如......
  • 10、Docker利用数据卷实现容器数据持久化与数据卷容器
    Docker利用数据卷实现容器数据持久化docker容器的分层容器的数据分层目录LowerDir:image镜像层,即镜像本身,只读UpperDir:容器的上层,可读写,容器变化的数据存放在此处,创建好容器,修改了数据,新生的的修改数据放在此处MergedDir:容器的文件系统,使用UnionFS(联合文件系统)......
  • 2023.6.1101.数据库基础介绍
    数据库基础介绍数据库概述数据库运维 1.认识MySQL什么是数据库数据库是⼀个⽤于存储和管理数据的电⼦化系统。我们可以把它想象成⼀个⼤型的⽂件柜,⾥⾯存储着各种类型的数据,例如个⼈信息、产品信息、订单信息等等。这些数据可以被组织、管理和检索,以⽅便⽤户快速地找到......
  • tinywin10下载地址
    地址https://archive.org/details/tiny-10_202301下载入口优势系统占用不足10G......