Spring SALE

Builder を C# で

Builder は生成に関するデザインパターンの一つで 複雑なオブジェクトを段階的に構築することができます

他の生成に関するパターンとは異なり Builder ではプロダクト 訳注 本パターンでは 生成されるモノのことを一般にプロダクトと呼びます が共通のインターフェースを持つ必要はありません このため 同じ構築の手続きを経て 異なるプロダクトを作成することができます



使用例 Builder パターンは C# の世界では よく知られているパターンです 多くの設定オプションを持つオブジェクトを作成する必要がある場合に特に便利です

見つけ方 Builder パターンは 一つのクラスが生成メソッドを一つ持ち 結果として得られるオブジェクトの構成を行うメソッドがいくつかあることで識別できます ビルダーのメソッドは 多くの場合連結できます someBuilder.​setValueA(1).​setValueB(2).​create()


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

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

Program.cs: 概念的な例

using System;
using System.Collections.Generic;

namespace RefactoringGuru.DesignPatterns.Builder.Conceptual
    // The Builder interface specifies methods for creating the different parts
    // of the Product objects.
    public interface IBuilder
        void BuildPartA();
        void BuildPartB();
        void BuildPartC();
    // The Concrete Builder classes follow the Builder interface and provide
    // specific implementations of the building steps. Your program may have
    // several variations of Builders, implemented differently.
    public class ConcreteBuilder : IBuilder
        private Product _product = new Product();
        // A fresh builder instance should contain a blank product object, which
        // is used in further assembly.
        public ConcreteBuilder()
        public void Reset()
            this._product = new Product();
        // All production steps work with the same product instance.
        public void BuildPartA()
        public void BuildPartB()
        public void BuildPartC()
        // Concrete Builders are supposed to provide their own methods for
        // retrieving results. That's because various types of builders may
        // create entirely different products that don't follow the same
        // interface. Therefore, such methods cannot be declared in the base
        // Builder interface (at least in a statically typed programming
        // language).
        // Usually, after returning the end result to the client, a builder
        // instance is expected to be ready to start producing another product.
        // That's why it's a usual practice to call the reset method at the end
        // of the `GetProduct` method body. However, this behavior is not
        // mandatory, and you can make your builders wait for an explicit reset
        // call from the client code before disposing of the previous result.
        public Product GetProduct()
            Product result = this._product;


            return result;
    // It makes sense to use the Builder pattern only when your products are
    // quite complex and require extensive configuration.
    // Unlike in other creational patterns, different concrete builders can
    // produce unrelated products. In other words, results of various builders
    // may not always follow the same interface.
    public class Product
        private List<object> _parts = new List<object>();
        public void Add(string part)
        public string ListParts()
            string str = string.Empty;

            for (int i = 0; i < this._parts.Count; i++)
                str += this._parts[i] + ", ";

            str = str.Remove(str.Length - 2); // removing last ",c"

            return "Product parts: " + str + "\n";
    // The Director is only responsible for executing the building steps in a
    // particular sequence. It is helpful when producing products according to a
    // specific order or configuration. Strictly speaking, the Director class is
    // optional, since the client can control builders directly.
    public class Director
        private IBuilder _builder;
        public IBuilder Builder
            set { _builder = value; } 
        // The Director can construct several product variations using the same
        // building steps.
        public void BuildMinimalViableProduct()
        public void BuildFullFeaturedProduct()

    class Program
        static void Main(string[] args)
            // The client code creates a builder object, passes it to the
            // director and then initiates the construction process. The end
            // result is retrieved from the builder object.
            var director = new Director();
            var builder = new ConcreteBuilder();
            director.Builder = builder;
            Console.WriteLine("Standard basic product:");

            Console.WriteLine("Standard full featured product:");

            // Remember, the Builder pattern can be used without a Director
            // class.
            Console.WriteLine("Custom product:");

Output.txt: 実行結果

Standard basic product:
Product parts: PartA1

Standard full featured product:
Product parts: PartA1, PartB1, PartC1

Custom product:
Product parts: PartA1, PartC1

他言語での Builder

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