builder模式

/*场景：房屋由多个部分组成，各个部分的组成方式不变（组成算法不变），

     * 但是，每个部分可能会多变。如蓝色屋顶转变为黄色屋顶。

     *

     * 目标：隔离出复杂对象的各个部分的变化，从而保持系统中“稳定的构建算法”不随着需求的改变而变化。

     *

     * 意图：将一个复杂的的构建和表示相分离，是的同样的构建过程可以创建不同的表示。

     */

 

    //HouseBuilder.cs

    public abstract class house

    {

 

    }

    public abstract class houseBuilder

    {

        public abstract void BuilderDoor();

        public abstract void BuilderWindow();

        public abstract void BuilderWall();

        public abstract void BuilderRoof();

 

        public abstract house GetHouse();

    }

 

    public abstract class Door

    { }

    public abstract class Window

    { }

    public abstract class Wall

    { }

    public abstract class Roof

    { }

 

    //modernHouseBuilder.cs

    public class modernHouse:house

    {

        public modernHouse()

        { System.Console.WriteLine("this is a modern house"); }

    }

    public class modernHouseBuilder:houseBuilder

    {

        public override void BuilderDoor()

        { System.Console.WriteLine("build modernHouseDoor"); }

        public override void BuilderWindow()

        { System.Console.WriteLine("build modernHouseWindow"); }

        public override void BuilderWall()

        { System.Console.WriteLine("build modernHouseWall"); }

        public override void BuilderRoof()

        { System.Console.WriteLine("build modernHouseRoof"); }

 

        public override house GetHouse()

        {

            return new modernHouse();

        }

    }

    public class modernHouseDoor:Door

    { }

    public class modernHouseWindow:Window

    { }

    public class modernHouseWall:Wall

    { }

    public class modernHouseRoof:Roof

    { }

 

 

    //HouseDirctor.cs

    /*

     * 该处为稳定算法部分

     *

     */

    public class HouseDirctor

    {

        public house houseConstruct(houseBuilder hb)

        {

            //如房屋由四个墙壁，一扇门，一个窗户和一个屋顶组成。

            hb.BuilderWall();

            hb.BuilderWall();

            hb.BuilderWall();

            hb.BuilderWall();

 

            hb.BuilderDoor();

            hb.BuilderWindow();

            hb.BuilderRoof();

 

           return  hb.GetHouse();

        }

 

        //调用过程演示

        /*

         * 说明：主要用于“分步骤构建一个复杂的对象”，这个步骤是一个稳定的算法，而复杂对象的各个部分则经常变化。

         * 应用：主要应对“复杂对象各个部分频繁变动“，但是，难于应用对“分步骤构建算法”的需求变动。

         *

         * Abstract Factory主要解决“系列对象”的需求变化（道路和）

         * Builder模式则主要解决“对象部分”需求变化，即各个部分不会相互引用（门、窗户、屋顶互不相关）。

         */

        static void Main (string[] args)

        {

            //可以通过xml配置文件，把需要构建的房屋类型写入其中。这样，我们可以通过读取

            //配置文件，通过反射机制，加载需要重建的房屋。由此，当需求改变时，只需要修改配置文件即可。

            HouseDirctor hm = new HouseDirctor();

            hm.houseConstruct(new modernHouseBuilder());

            //输出：

            /*build modernHouseWall

             * build modernHouseWall

             * build modernHouseWall

             * build modernHouseWall

             * build modernHouseDoor

             * build modernHouseWindow

             * build modernHouseRoof

             * this is a modern hourse

             */

           

        }

    }