动机：
　　在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的了对象用一定的算法构成：由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却欲相对稳定。
　　如何应对这种变化？如何提供一种“封闭机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？

意图：
　　将一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
　　出自：《设计模式》GoF

Builder模式的几个要点：
　　１、Builder模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
　　２、变化点在哪里，封装哪里。Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。
　　３、Abstract Factory模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化。Builder模式通常和Composite模式组合使用。

稳定部分：

    public abstract class Builder
    {
        public abstract void BuildDoor();
        public abstract void BuildWall();
        public abstract void BuildFloor();
        public abstract void BuildWindows();
        public abstract void BuildHouseCeiling();

        public abstract House GetHouse();
    }

    public abstract class Door
    {

    }

    public abstract class Wall 
    {

    }

    public abstract class Windows
    {

    }

    public abstract class Floor
    {

    }

    public abstract class HouseCeiling
    {

    }

    public class GameManager
    {
        Builder builder;

        public GameManager(Builder builder)
        {
            this.builder = builder;
        }

        public static House CreateHouse()
        {
            builder.BuildDoor();
            builder.BuildDoor();

            builder.BuildWall();
            builder.BuildWall();

            builder.BuildWindows();
            builder.BuildWindows();

            builder.BuildFloor();
            builder.BuildHouseCeiling();

            return builder.GetHouse();
        }
    }


变化部分：

    public class DoorA : Door
    {

    }

    public class WallA : Wall
    {

    }

    public class WindowsA : Windows
    {

    }

    public class FloorA : Floor
    {

    }

    public class HouseCeilingA : HouseCeiling
    {

    }

    public class HouseBuilderA : Builder
    {
        public override void BuildDoor()
        {

        }
        public override void BuildWallr()
        {

        }
        public override void BuildWindows()
        {

        }
        public override void BuildFloor()
        {

        }
        public override void BuildHouseCeiling()
        {

        }
        public override House GetHouse()
        {

        }
    }


主程序：

//应用于构建一个对象过程是稳定的
        public static void Main()
        {
            //变化点
            GameManager g = new GameManager(new HouseBuilderA());
            //GameManager g = new GameManager(new HouseBuilderB());
            House h = GameManager.CreateHouse();
        }