理解 C# 中的构建器模式

Question

建造者模式的定义： 建造者模式将复杂对象的规范与其实际构造分开。相同的构建过程可以创建不同的表示。

好吧，我有一个像这样的 Builder Pattern 代码示例

class Director
    {
        // Build a Product from several parts
        public void Construct(IBuilder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
            builder.BuildPartB();
        }
    }

    interface IBuilder
    {
        void BuildPartA();
        void BuildPartB();
        Product GetResult();
    }

    class Builder1 : IBuilder
    {
        private Product product = new Product();
        public void BuildPartA()
        {
            product.Add("PartA ");
        }

        public void BuildPartB()
        {
            product.Add("PartB ");
        }

        public Product GetResult()
        {
            return product;
        }
    }

    class Builder2 : IBuilder
    {
        private Product product = new Product();
        public void BuildPartA()
        {
            product.Add("PartX ");
        }

        public void BuildPartB()
        {
            product.Add("PartY ");
        }

        public Product GetResult()
        {
            return product;
        }
    }

    class Product
    {
        List<string> parts = new List<string>();
        public void Add(string part)
        {
            parts.Add(part);
        }

        public void Display()
        {
            Console.WriteLine("\nProduct Parts -------");
            foreach (string part in parts)
                Console.Write(part);
            Console.WriteLine();
        }
    }

    public class Client
    {

        public static void Main()
        {
            // Create one director and two builders
            Director director = new Director();

            IBuilder b1 = new Builder1();
            IBuilder b2 = new Builder2();

            // Construct two products
            director.Construct(b1);
            Product p1 = b1.GetResult();
            p1.Display();

            director.Construct(b2);
            Product p2 = b2.GetResult();
            p2.Display();

            Console.Read();
        }
    }

现在，我对上面的代码做了一些更改。下面的代码是否仍然代表构建器模式？

class Director
    {
        public void Construct(IBuilder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
            builder.GetResult();
        }
    }

    interface IBuilder
    {
        void BuildPartA();
        void BuildPartB();
        void GetResult();
    }

    class Builder1 : IBuilder
    {
        List<string> product = new List<string>();
        public void BuildPartA()
        {
            product.Add("PartA ");
        }

        public void BuildPartB()
        {
            product.Add("PartB ");
        }

        public void GetResult()
        {
            foreach (var p in product)
            {
                Console.WriteLine("the product created is :" + p);
            }
        }
    }

    class Builder2 : IBuilder
    {
        List<string> product = new List<string>();
        public void BuildPartA()
        {
            product.Add("PartX ");
        }

        public void BuildPartB()
        {
            product.Add("PartY ");
        }

        public void GetResult()
        {
            foreach (var p in product)
            {
                Console.WriteLine("the product created is :" + p);
            }
        }
    }
    public class Client
    {

        public static void Main()
        {

            Director director = new Director();
            IBuilder b1 = new Builder1();
            IBuilder b2 = new Builder2();
            director.Construct(b1);
            director.Construct(b2);

            Console.Read();
        }
    }

笔记：

我已经从第二个示例代码中删除了产品类。

我的问题是，创建一个处理所有对象并以有序方式调用方法的类使其成为构建器模式？只是想确保我理解了 Builder Pattern 的概念。提前致谢

更新 1

我真的不明白为什么第二个样本不是 Builder Pattern。让我创建第二个示例，该示例对我来说很容易理解，对其他人也很容易帮助我理解。下面是代码。

 interface IRoutine {
        void WakeUp();
        void GoToSchool();
        void ListenToMusic();
        void Sleep();
    }
    class person1 : IRoutine
    {
        public void GoToSchool()
        {
            Console.WriteLine("going to school");
        }

        public void ListenToMusic()
        {
            Console.WriteLine("litening to music");
        }

        public void Sleep()
        {
            Console.WriteLine("tring to sleep");
        }

        public void WakeUp()
        {
            Console.WriteLine("good morning !!!");
        }
    }
    class person2 : IRoutine
    {
        public void GoToSchool()
        {
            Console.WriteLine("going to school");
        }

        public void ListenToMusic()
        {
            Console.WriteLine("litening to music");
        }

        public void Sleep()
        {
            Console.WriteLine("tring to sleep");
        }

        public void WakeUp()
        {
            Console.WriteLine("good morning !!!");
        }
    }
    class Builder {
        public void Construct(IRoutine routine) {
            routine.WakeUp();
            routine.GoToSchool();
            routine.ListenToMusic();
            routine.Sleep();
        }
    }
    class Client {
        static void Main() {
            Builder builder = new Builder();
            IRoutine r1 = new person1();
            IRoutine r2 = new person2();

            builder.Construct(r1);
            builder.Construct(r2);

            Console.Read();
        }
    }

我最近提供的示例是 Builder Pattern 吗？如果不是那么为什么它不是构建器模式，请帮助我理解。

Answer 1

您的后一个片段不是构建器模式的示例。创建最终对象的步骤是该模式的关键部分，通过删除该步骤，您的构建器类实际上成为实际的构造（可变）对象。换句话说，如果string是可变的，则不会存在 a StringBuilder，您只需使用假设的string.Append方法来改变最终对象。或者，如果StringBuilder返回了除外的任何东西string，它不会被称为 a StringBuilder。

为了在实践中证明构建器存在的合理性，我希望它能够：

1. 提供一个用于构建不可变对象的接口，然后“冻结”它，即返回一个不可变的构建实例（StringBuilder就是一个很好的例子）。

2. 与具有大量构造函数参数的对象相比，提供稍微干净（例如流畅）的接口来实例化对象。但是，如果最终对象是可变的，则更难以证明这一点，因为无论如何您都可以设置单独的属性。

一些示例使用构建器来提供用于构建对象的附加抽象层（即允许以相同的方式构建不同的具体类型），然后将抽象构建器传递给使用它来构建对象的“导演”，但我发现这一步与模式无关。我什至会更进一步说，具有多种方法的抽象构建器感觉像是一种反模式，因为它们将每个具体对象的构建与相同的构建过程联系起来。为了更好地理解我的观点，请考虑如何在此处BoatBuilder给出的示例中实现。