Builder模式

 

Builder模式：程序的主体是稳定的，构建程序的部分变化相对剧烈。将一个复杂对象的结构与表示分离。

结构图： 

//builder

/// <summary>
/// 一个构建House的builder类，假设所有的房子都是由墙，门，窗，地板，屋顶 构成。
/// 这个地方相对稳定，抽象出构建房子的接口
/// </summary>
public abstract class HouseBuilder
{
    public abstract void createWall();
    public abstract void createDoor();
    public abstract void createWindow();
    public abstract void createFloor();
    public abstract void createRoof();

    public abstract House getHouse();

}

public abstract class House
{ }
public abstract class Wall
{ }
public abstract class Door
{ }
public abstract class Window
{ }
public abstract class Floor
{ }
public abstract class Roof
{ }

//Director

/// <summary>
/// 构建House是一个相对稳定的类，假设所有的House都是由一门，一地板，一顶，两面墙，一窗构成。
/// 参数为接受具体house的类型实例
/// </summary>
public class Director
{
    public Director(HouseBuilder builder)
    {
        builder.createDoor();
        builder.createFloor();
        builder.createRoof();
        builder.createWall();
        builder.createWall();
        builder.createWindow();
    }
}

//ConcreteBuilder

/// <summary>
/// 古典风格的房子，实现HouseBuilder类，这是一个变化的点，具体的房子
/// </summary>
public class ClassicalHouseBuilder : HouseBuilder
{
    public override void createWall()
    {
        throw new System.NotImplementedException();
    }

    public override void createDoor()
    {
        throw new System.NotImplementedException();
    }

    public override void createWindow()
    {
        throw new System.NotImplementedException();
    }

    public override void createFloor()
    {
        throw new System.NotImplementedException();
    }

    public override void createRoof()
    {
        throw new System.NotImplementedException();
    }

    public override House getHouse()
    {
        return new ClassicalHouse();
    }
}

public class ClassicalWall : Wall
{
    public ClassicalWall()
    {
        System.Console.WriteLine("古典风格的墙！");
    }
}
public class ClassicalWindow : Window
{
    //todo:古典风格的窗户
}
public class ClassicalFloor : Floor
{

}
public class ClassicalRoof : Roof
{

}
public class ClassicalDoor : Door
{

}
public class ClassicalHouse : House { }

 //客户端调用是稳定的，具体构建的地方可以用反射配置达到稳定。
        public static void Main()
        {
            HouseBuilder b = new ClassicalHouseBuilder();
            Director d = new Director(b);
        }