c# - 了解 C# 中的构建器模式

Question

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

好吧，我有这样一个构建器模式的代码示例

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();
        }
    }

注意:

I have removed the product class from the second sample code.

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

更新 1

我真的不明白为什么第二个示例不是构建器模式。让我创建第二个例子，这对我来说很容易理解，对其他人来说也很容易帮助我理解。下面是代码。

 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();
        }
    }

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

Answer 1

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

为了在实践中证明构建器的存在，我希望它:

1. 提供用于构建不可变对象(immutable对象)的接口(interface)，然后“卡住”它，即返回一个不可变 构建实例(StringBuilder 是一个很好的例子)。

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

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