C# 建造者模式

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

namespace ConsoleApp1
{
    public interface IBuilder
    {
        void BuildPartA();
        void BuildPartB();
        void BuildPartC();

    }


    public class ConcreteBuilder : IBuilder
    {
        private Product product = new Product();

        public ConcreteBuilder()
        { this.Reset(); }

        private void Reset()
        {
            this.product = new Product();
        }

        public void BuildPartA()
        {
            this.product.add("PartOne");
        }

        public void BuildPartB()
        {
            this.product.add("PartTwo");
        }

        public void BuildPartC()
        {
            this.product.add("PartThree");
        }

        // 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;

            this.Reset();

            return result;
        }
    }


    public class Director
    {
        private IBuilder _builder;
        public IBuilder Builder
        {
            set => _builder =value;
        }

        public void buildMinimalViableProduct()
        {
            this._builder.BuildPartA();
        }

        public void buildFullFeatureProduct()
        {
            this._builder.BuildPartA();
            this._builder.BuildPartB();
            this._builder.BuildPartC();
        }


    }


    public class Product
    {
        private List<object> _parts = new List<object>();

        public void add(string part)
        {
            this._parts.Add(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);

            return str;
        }
    }



    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:");
            director.buildMinimalViableProduct();
            Console.WriteLine(builder.GetProduct().ListParts());

            Console.WriteLine("Standard full featured product:");
            director.buildFullFeatureProduct();
            Console.WriteLine(builder.GetProduct().ListParts());

            // Remember, the Builder pattern can be used without a Director
            // class.
            Console.WriteLine("Custom product:");
            builder.BuildPartA();
            builder.BuildPartC();
            Console.Write(builder.GetProduct().ListParts());
        }
    }
}