C#设计模式：建造者模式（Builder Pattern）

一，建造者模式（Builder Pattern）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _4.建造者模式
{
    //建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一种对象创建型模式。
    //与抽象工厂的区别是：抽象工厂是针对系列对象（如会出现各种车对象），然而创建者模式是针对一个对象的局部变化（如单个对象有不同武器等）
    class Program
    {
        static void Main(string[] args)
        {
            Builder builder = new USA("黑皮肤", "美国人", "英语");
            Director director = new Director(builder);
            People product = director.Construct();
            Console.Write("\r\n");

            Builder builder1 = new USA("白皮肤", "英国人", "日语");
            Director director1 = new Director(builder1);
            People product1 = director1.Construct();
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 创建抽象类
    /// </summary>
    public abstract class Builder
    {
        protected People people = new People();
        public abstract void SetCountry();
        public abstract void SetSpeak();
        public abstract void SetSkinColor();

        public People getResult()
        {
            return people;
        }
    }
    /// <summary>
    /// 被创建的对象，对象会出现局部的不同，
    /// </summary>
    public class People
    {
        public People()
        {
            Console.Write("我们都是人，但是");
        }
    }
    public class USA : Builder
    {
        private string _country;
        private string _speak;
        private string _skincolor;
        public USA(string skincolor, string country, string speak)
        {
            this._country = country;
            this._skincolor = skincolor;
            this._speak = speak;
        }
        public override void SetSkinColor()
        {
            Console.Write(_skincolor + "的");
        }
        public override void SetCountry()
        {
            Console.Write(_country);
        }

        public override void SetSpeak()
        {
            Console.Write("讲" + _speak);
        }
    }
    public class UK : Builder
    {
        private string _country;
        private string _speak;
        private string _skincolor;
        public UK(string skincolor, string country, string speak)
        {
            this._country = country;
            this._skincolor = skincolor;
            this._speak = speak;
        }
        public override void SetSkinColor()
        {
            Console.Write(_skincolor + "的");
        }
        public override void SetCountry()
        {
            Console.Write(_country);
        }

        public override void SetSpeak()
        {
            Console.Write("讲" + _speak);
        }
    }
    /// <summary>
    /// 执行者,创建对象
    /// </summary>
    public class Director
    {
        private Builder builder;
        public Director(Builder bu)
        {
            this.builder = bu;
        }
        public People Construct()
        {
            builder.SetSkinColor();
            builder.SetCountry();
            builder.SetSpeak();
            return builder.getResult();
        }
    }
}

二，根据上面代码，我们会感觉和抽象工厂很像，他们两个是什么呢？

1》建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一种复杂对象创建型模式。

2》抽象工厂则是针对系列对象，建造者模式是一种复杂对象

三，相对抽象工厂和建造者的一种复杂对象怎么理解呢？

我们就以People为对象来理解：

1》在建造者模式中，我们可以通过抽象的类创建出美国人和英国人对象，而这对象则是有自己独立的东西等，如黑皮肤的美国人讲英语和白皮肤的英国人讲日语，这里的人理解成为同一种复杂的对象

2》而在重抽象工厂中，在英国人工厂中，只能实现白皮肤的英国人讲日语。而不会出现实现了黑皮肤的美国人讲英语（这个属于美国人的工厂实现的），所以对于抽象工厂，在此时我们将英国人和美国人理解为两个不同的对象，所以抽象工厂是针对系列对象