Summer SALE

C# 组合模式讲解和代码示例

组合是一种结构型设计模式 你可以使用它将对象组合成树状结构 并且能像使用独立对象一样使用它们

对于绝大多数需要生成树状结构的问题来说 组合都是非常受欢迎的解决方案 组合最主要的功能是在整个树状结构上递归调用方法并对结果进行汇总



使用实例 组合模式在 C# 代码中很常见 常用于表示与图形打交道的用户界面组件或代码的层次结构

识别方法 组合可以通过将同一抽象或接口类型的实例放入树状结构的行为方法来轻松识别



  • 它由哪些类组成
  • 这些类扮演了哪些角色
  • 模式中的各个元素会以何种方式相互关联

Program.cs: 概念示例

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)

        public override void Remove(Component 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 += "+";
            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())
            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:");

            // 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());
            Console.WriteLine("Client: Now I've got a composite tree:");

            Console.Write("Client: I don't need to check the components classes even when managing the tree:\n");
            client.ClientCode2(tree, leaf);

Output.txt: 执行结果

Client: I get a simple component:

Client: 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)


C++ 组合模式讲解和代码示例 Go 组合模式讲解和代码示例 Java 组合模式讲解和代码示例 PHP 组合模式讲解和代码示例 Python 组合模式讲解和代码示例 Ruby 组合模式讲解和代码示例 Rust 组合模式讲解和代码示例 Swift 组合模式讲解和代码示例 TypeScript 组合模式讲解和代码示例