组合模式是一种结构型模式,你可以使用它将对象组合成树状结构,并且能像使用独立对象一样使用它们。
如果应用的核心模型能用树状结构表示,在应用中使用组合模式才有价值。
例如,你有两类对象:产品
和盒子
。一个盒子中可以包含多个产品
或者几个较小的盒子
。这些小盒子
中同样可以包含一些产品
或更小的盒子
,以此类推。
假设你希望在这些类的基础上开发一个定购系统。订单中可以包含无包装的简单产品,也可以包含装满产品的盒子……以及其他盒子。此时你会如何计算每张订单的总价格呢?
你可以尝试直接计算:打开所有盒子,找到每件产品,然后计算总价。这在真实世界中或许可行,但在程序中,你并不能简单地使用循环语句来完成该工作。你必须事先知道所有产品
和盒子
的类别,所有盒子的嵌套层数以及其他繁杂的细节信息。因此,直接计算极不方便,甚至完全不可行。
组合模式建议使用一个通用接口来与产品
和盒子
进行交互,并且在该接口中声明一个计算总价的方法。
那么方法该如何设计呢?对于一个产品,该方法直接返回其价格;对于一个盒子,该方法遍历盒子中的所有项目,询问每个项目的价格,然后返回该盒子的总价格。如果其中某个项目是小一号的盒子,那么当前盒子也会遍历其中的所有项目,以此类推,直到计算出所有内部组成部分的价格。你甚至可以在盒子的最终价格中增加额外费用,作为该盒子的包装费用。
该方式的最大优点在于你无需了解构成树状结构的对象的具体类。你也无需了解对象是简单的产品还是复杂的盒子。你只需调用通用接口以相同的方式对其进行处理即可。当你调用该方法后,对象会将请求沿着树结构传递下去。
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151 | using System;using System.Collections.Generic;namespace RefactoringGuru.DesignPatterns.Composite.Conceptual{ // The base Component class declares common operations for both simple and // complex objects of a composition. abstract class Component { public Component() { } // The base Component may implement some default behavior or leave it to // concrete classes (by declaring the method containing the behavior as // "abstract"). public abstract string Operation(); // In some cases, it would be beneficial to define the child-management // operations right in the base Component class. This way, you won't // need to expose any concrete component classes to the client code, // even during the object tree assembly. The downside is that these // methods will be empty for the leaf-level components. public virtual void Add(Component component) { throw new NotImplementedException(); } public virtual void Remove(Component component) { throw new NotImplementedException(); } // You can provide a method that lets the client code figure out whether // a component can bear children. public virtual bool IsComposite() { return true; } } // The Leaf class represents the end objects of a composition. A leaf can't // have any children. // // Usually, it's the Leaf objects that do the actual work, whereas Composite // objects only delegate to their sub-components. class Leaf : Component { public override string Operation() { return "Leaf"; } public override bool IsComposite() { return false; } } // The Composite class represents the complex components that may have // children. Usually, the Composite objects delegate the actual work to // their children and then "sum-up" the result. class Composite : Component { protected List<Component> _children = new List<Component>(); public override void Add(Component component) { this._children.Add(component); } public override void Remove(Component component) { this._children.Remove(component); } // The Composite executes its primary logic in a particular way. It // traverses recursively through all its children, collecting and // summing their results. Since the composite's children pass these // calls to their children and so forth, the whole object tree is // traversed as a result. public override string Operation() { int i = 0; string result = "Branch("; foreach (Component component in this._children) { result += component.Operation(); if (i != this._children.Count - 1) { result += "+"; } i++; } return result + ")"; } } class Client { // The client code works with all of the components via the base // interface. public void ClientCode(Component leaf) { Console.WriteLine($"RESULT: {leaf.Operation()}\n"); } // Thanks to the fact that the child-management operations are declared // in the base Component class, the client code can work with any // component, simple or complex, without depending on their concrete // classes. public void ClientCode2(Component component1, Component component2) { if (component1.IsComposite()) { component1.Add(component2); } Console.WriteLine($"RESULT: {component1.Operation()}"); } } class Program { static void Main(string[] args) { Client client = new Client(); // This way the client code can support the simple leaf // components... Leaf leaf = new Leaf(); Console.WriteLine("Client: I get a simple component:"); client.ClientCode(leaf); // ...as well as the complex composites. Composite tree = new Composite(); Composite branch1 = new Composite(); branch1.Add(new Leaf()); branch1.Add(new Leaf()); Composite branch2 = new Composite(); branch2.Add(new Leaf()); tree.Add(branch1); tree.Add(branch2); Console.WriteLine("Client: Now I've got a composite tree:"); client.ClientCode(tree); Console.Write("Client: I don't need to check the components classes even when managing the tree:\n"); client.ClientCode2(tree, leaf); } }} |
---|
执行结果:
12345678 | Client: I get a simple component:RESULT: LeafClient: Now I've got a composite tree:RESULT: Branch(Branch(Leaf+Leaf)+Branch(Leaf))Client: I don't need to check the components classes even when managing the tree:RESULT: Branch(Branch(Leaf+Leaf)+Branch(Leaf)+Leaf) |
---|
参考原文:组合设计模式