设计模式学习之路——Builder 生成器模式

     生成器模式有点类似于抽象工厂模式，两者都返回由许多方法和对象组成的类。它们之间的主要差别是，抽象工厂返回的是一系列相关的类，而生成器是根据提供给它的数据一步一步地构建一个复杂的对象。

动机：

在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？

意图：

将一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

——《设计模式》GoF

结构：

协作：

代码实现

using System;
using System.Collections.Generic;
using System.Text;

namespace Builder
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("true： 中式风格房屋,false:西式风格房屋");
            string Input = Console.ReadLine();
            try
            {
                HouseBuilder builder = ClienManger.builder(bool.Parse(Input));
                House chinaHouse = ClienManger.CreateHouse(builder);
                chinaHouse.Show();
            }
            catch
            {
                Console.WriteLine("输入错误！");
            }
        

            Console.ReadKey();

        }
    }

    public class House
    {
       

        private List<string> door = new List<string>();

        public List<string> Door
        {
            get { return door; }
            set { door = value; }
        }

        private List<string> windows = new List<string>();

        public List<string> Windows
        {
            get { return windows; }
            set { windows = value; }
        }

        private string wall;

        public string Wall
        {
            get { return wall; }
            set { wall = value; }
        }
        private string floor;

        public string Floor
        {
            get { return floor; }
            set { floor = value; }
        }



        public void Show()
        {
            Console.WriteLine(Door.Count.ToString() + "个" + Door[0].ToString());
            Console.WriteLine(Wall);
            Console.WriteLine(Windows.Count.ToString() + "个" + Windows[0].ToString());
            Console.WriteLine(Floor);
        }

    }

    public abstract class HouseBuilder
    {
        public abstract void BuildDoor();

        public abstract void BuildWall();

        public abstract void BuildWindows();

        public abstract void BuildFloor();

        public abstract House GetHouse();
    }

    public class ClienManger
    {

        public static House CreateHouse(HouseBuilder builder)
        {

            builder.BuildDoor();
            builder.BuildFloor();
            builder.BuildWall();
            builder.BuildWindows();

            return builder.GetHouse();
        }

        public static HouseBuilder builder(bool bl)
        {
            if (bl)
            {
                return new ChinaHouseBuilder();
            }
            else
            {
                return new EuroHouseBuilder();
            }
        }
    }



    public class ChinaHouseBuilder : HouseBuilder
    {
        private House chinaHouse = new House();

        public override void BuildDoor()
        {
            chinaHouse.Door.Add("门(中国风格)");
            chinaHouse.Door.Add("门(中国风格)");
        }


        public override void BuildWall()
        {
            chinaHouse.Wall = "墙(中国风格)";
        }


        public override void BuildWindows()
        {
            chinaHouse.Windows.Add("窗(中国风格)");
            chinaHouse.Windows.Add("窗(中国风格)");
        }

        public override void BuildFloor()
        {
            chinaHouse.Floor = "地板(中国风格)";
        }

        public override House GetHouse()
        {
            return chinaHouse;
        }
    }


    public class EuroHouseBuilder : HouseBuilder
    {
        private House EuroHouse = new House();

        public override void BuildDoor()
        {
            EuroHouse.Door.Add("门(欧洲风格)");
        }

        public override void BuildWall()
        {
            EuroHouse.Wall = "墙(欧洲风格)";
        }


        public override void BuildWindows()
        {
            EuroHouse.Windows.Add("窗(欧洲风格)");
        }

        public override void BuildFloor()
        {
            EuroHouse.Floor = "地板(欧洲风格)";
        }

        public override House GetHouse()
        {
            return EuroHouse;
        }
    }
}

Builder 模式的几个要点：

1.Builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。

2.变化点在哪里，封装哪里—— Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。

3. Abstract Factory模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化。Builder模式通常和Composite模式组合使用。