设计模式学习之路——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模式组合使用。