Summer SALE

Composite を C# で

Composite 構造に関するデザインパターンの一つで オブジェクトを木のような構造に構成し あたかも単一のオブジェクトであるかのように扱えるようにします

Composite は ツリー構造の構築を必要とする問題の大部分の解決策として かなりの人気を得るようになりました Composite の大きな特徴は ツリー構造全体でメソッドを再帰的に実行し 結果をまとめあげることです



使用例 Composite パターンは C# コードではよく見かけます ユーザー・インターフェースのコンポーネントの階層構造の表現や グラフに対して動作するコードで多く使われます

見つけ方 オブジェクト・ツリーがあって ツリーのそれぞれのオブジェクトが同じクラス階層の部分であれば 十中八九 Composite です もしこれらのクラス中のメソッドが ツリーの子オブジェクトに仕事を委任し それを階層の基底クラスやインターフェースを介して行うなら これは間違いなく Composite です


この例は Composite デザインパターンの構造を説明するためのものです 以下の質問に答えることを目的としています

  • どういうクラスからできているか
  • それぞれのクラスの役割は
  • パターンの要素同士はどう関係しているのか

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)

他言語での Composite

Composite を C++ で Composite を Go で Composite を Java で Composite を PHP で Composite を Python で Composite を Ruby で Composite を Rust で Composite を Swift で Composite を TypeScript で