Hey, I have just reduced the price for all products. Let's prepare our programming skills for the post-COVID era. Check it out »

Builder in C#

Builder is a creational design pattern, which allows constructing complex objects step by step.

Unlike other creational patterns, Builder doesn’t require products to have a common interface. That makes it possible to produce different products using the same construction process.

Usage of the pattern in C#



Usage examples: The Builder pattern is a well-known pattern in C# world. It’s especially useful when you need to create an object with lots of possible configuration options.

Identification: The Builder pattern can be recognized in a class, which has a single creation method and several methods to configure the resulting object. Builder methods often support chaining (for example, someBuilder->setValueA(1)->setValueB(2)->create()).

Conceptual Example

This example illustrates the structure of the Builder design pattern. It focuses on answering these questions:

  • What classes does it consist of?
  • What roles do these classes play?
  • In what way the elements of the pattern are related?

Program.cs: Conceptual example

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: Execution result

Standard basic product:
Product parts: PartA1

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

Custom product:
Product parts: PartA1, PartC1

Builder in Other Languages

Design Patterns: Builder in Java Design Patterns: Builder in C++ Design Patterns: Builder in PHP Design Patterns: Builder in Python Design Patterns: Builder in Ruby Design Patterns: Builder in Swift Design Patterns: Builder in TypeScript Design Patterns: Builder in Go