23种设计模式-Builde(生成器)设计模式

解决"对象部分"的需求变化,通常和Composite(组合)模式组合使用.

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

namespace Builder生成器模式
{
    /*
     *1.Builder模式主要用于"分步骤构建一个复杂的对象",在这其中"分步骤"是一个稳定的算法,而复杂对象的各个部分则经常变化
     *2.变化点在哪里,封装哪里---Builder模式主要在于应对"复杂对象各个部分"的频繁需求变动.其缺点在于难于应对"分步骤构建算法"
     *  的需求变动.
     *3.Abstract Factory(抽象工厂)模式解决"系列对象"的需求变化,Builder模式解决"对象部分"的需求变化.
     *  Builder模式通常和Composite模式组合使用
     */


    //不关心具体的表示,能够把这个里面那些高层抽象的东西,给他抽出来,先给他定下来.
    //设计一个系统架构的时候,其实是在设计有关系统架构的一组接口.并不是在设计某个具体的东西.

    //我们先写一个抽象类,当然不一定非要是抽象的
    //抽象接口(稳定的)-----------------------------------------------------------------------
    //门
    public abstract class Door
    {
        public abstract void typeDoor();
    }
    //墙壁
    public abstract class Wall
    {
        public abstract void typeWall();
    }
    //窗子
    public abstract class Windows
    {
        public abstract void typeWindows();
    }
    //房子
    public abstract class House {
        public  Door door;
        public  Wall wall;
        public  Windows windows;
        public abstract void ShiYong();
    }


    public abstract class Builder{
        //创建门
        public abstract void BuildDoor();
        //创建墙壁
        public abstract void BuildWall();
        //创建窗子
        public abstract void BuildWindows();
  
        //获取房子
        public abstract House GetHouse();
    }
  
    //-----------------------------------------------------------------------------------------------------------------------


    //实例(不稳定的)============================================================================
    public class WindowsLuoMaDoor : Door
    {
        public override void typeDoor()
        {
            Console.WriteLine("罗马门");
        }
    }
    public class LuoMaWall : Wall
    {
        public override void typeWall()
        {
            Console.WriteLine("罗马围墙");
        }
    }
    public class LuoMaWindows : Windows
    {
        public override void typeWindows()
        {
            Console.WriteLine("罗马窗户");
        }
    }
    public class LuoMaHouse : House {


        public override void ShiYong()
        {
            Console.WriteLine("罗马房子");
        }
    }
    //这里就看你自己怎么组合了
    public class LuoMaHouseBuilder : Builder
    {
        Door door = new WindowsLuoMaDoor();
        Wall wall = new LuoMaWall();
        Windows windows = new LuoMaWindows();
        House house = new LuoMaHouse();
        public override void BuildDoor()
        {
            door.typeDoor();
        }

        public override void BuildWall()
        {
            wall.typeWall();
        }

        public override void BuildWindows()
        {
            windows.typeWindows();
        }

        public override House GetHouse()
        {
            house.door = this.door;
            house.wall = this.wall;
            house.windows = this.windows;
            return house;
        }
    }
   //=====================================================================================



   //另一个类文件(稳定的)----------------------------------------------------
    //这个类和抽象类是绑定的比较紧的,实例类怎么改变都不会影响到它
    //在实际编程中这个模块是比较复杂的,所以要让它稳定起来,这样就达到了设计模式的目的
    public static class GameManager
    {//你可能根据读取一个Html文件或者数据库文件,让你去建立有两个门的房子
        public static House CreateHouse(Builder _builder)
        {
            //假设经过一系列的算法通过数据库信息来,build    
            //算法省略,直接进入结果
            _builder.BuildDoor();
            _builder.BuildDoor();
            _builder.BuildWall();
            _builder.BuildWindows();
           return _builder.GetHouse();
        }

       // internal static void CreateHouse()
        //{
        //    throw new NotImplementedException();
       // }
    }
    //-------------------------------------------------------------------------------------------------



    class Program
    {
        static void Main(string[] args)
        {
            //使用
           House house = GameManager.CreateHouse(new LuoMaHouseBuilder());
           house.ShiYong();
           Console.ReadKey();
        }
    }

    //如果有需求改变的话,我们这样就可以以扩展的方式改变,而不是更改代码
    //整个框架已经出来了,我们要的结果就是,抽象接口(稳定),GameManager分步骤算法(稳定),而实例的各个部分(脆弱)
    //不管实例需求怎么改变,整个框架也不需要修改.
}