设计模式之创建型(4)-建造者模式(Builder)

（一）定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们。用户不知道内部的具体构建细节。

UML类图：抽象不应该依赖细节，细节应该依赖于抽象

（二）类与对象之间的关系：

Builder：抽象建造者。为创建一个Product对象的各个部件指定抽象接口。

ConcreteBuilder：具体建造者。实现Builder接口。
  ❶  构造和装配产品的各个部件。
  ❷  定义并明确它所创建的表示。
  ❸  提供一个返回这个产品的接口。

Director：指挥者。构建一个使用Builder接口的对象。

Product：产品角色。
  ❶  被构建的复杂对象，具体建造者创建该产品的内部表示并定义它的装配过程。
  ❷ 包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

（三）时序图：

（四）4.1 案例分析：车间造车

车间装配车辆是分步骤完成的复杂装配过程，车行采用不同的车间装配出不同的车辆。但是每个车辆装配的过程是稳定的，不同是会根据不同的需求装配出不同的车辆。因此可以将该问的处理采用生成器模式来解决。

类关系图如下：

代码如下：

using System;
using System.Collections;
using System.Text;

namespace 设计模式.生成器模式
{
    public class Shop
    {
        public Shop(VehicleBuilder vehicleBuilder) //聚合关系，从构造函数传参来构建类
        {
            vehicleBuilder.BuildFrame();
            vehicleBuilder.BuildEngine();
            vehicleBuilder.BuildWheels();
            vehicleBuilder.BuildDoors();
        }
    }

    public abstract class VehicleBuilder
    {
        protected Vehicle vehicle;
        public Vehicle Vehicle
        {
            get
            {
                return vehicle;
            }
        }
        public abstract void BuildFrame();
        public abstract void BuildEngine();
        public abstract void BuildWheels();
        public abstract void BuildDoors();
    }

    public class MotorCycleBuilder : VehicleBuilder
    {
        public override void BuildFrame()
        {
            vehicle = new Vehicle("摩托车");
            vehicle["frame"] = "MotorCycle Frame";
        }

        public override void BuildEngine()
        {
            vehicle["engine"] = "500 CC";
        }

        public override void BuildWheels()
        {
            vehicle["wheels"] = "2";
        }

        public override void BuildDoors()
        {
            vehicle["doors"] = "0";
        }
    }

    public class CarBuilder : VehicleBuilder
    {

        public override void BuildFrame()
        {
            vehicle = new Vehicle("轿车");
            vehicle["frame"] = "Car Frame";
        }

        public override void BuildEngine()
        {
            vehicle["engine"] = "2500 CC";
        }

        public override void BuildWheels()
        {
            vehicle["wheels"] = "4";
        }

        public override void BuildDoors()
        {
            vehicle["doors"] = "4";
        }
    }

    public class ScooterBuilder : VehicleBuilder
    {

        public override void BuildFrame()
        {
            vehicle = new Vehicle("单脚滑行车");
            vehicle["frame"] = "Scooter Frame";
        }

        public override void BuildEngine()
        {
            vehicle["engine"] = "none";
        }

        public override void BuildWheels()
        {
            vehicle["wheels"] = "2";
        }

        public override void BuildDoors()
        {
            vehicle["doors"] = "0";
        }
    }

    public class Vehicle
    {
        private string type;
        private Hashtable parts = new Hashtable();

        public Vehicle(string type)
        {
            this.type = type;
        }

        public object this[string key]
        {
            get { return parts[key]; }
            set { parts[key] = value; }
        }

        public string Show()
        {
            Console.WriteLine("
----------------------------------");
            Console.WriteLine("车辆类型：" + type);
            Console.WriteLine(" 框架：" + parts["frame"]);
            Console.WriteLine(" 发动机：" + parts["engine"]);
            Console.WriteLine(" #轮子数：" + parts["wheels"]);
            Console.WriteLine(" #车门数：" + parts["doors"]);

            StringBuilder sb=new StringBuilder();
            sb.AppendFormat("车辆类型：{0}",type).AppendLine();
            sb.AppendFormat(" 框架：{0}",parts["frame"]).AppendLine();
            sb.AppendFormat(" 发动机：{0}",parts["engine"]).AppendLine();
            sb.AppendFormat(" #轮子数：{0}", parts["wheels"]).AppendLine();
            sb.AppendFormat(" #车门数：{0}" , parts["doors"]);
            return sb.ToString();
        }
    }
}

4.2  案例分析：房屋构建

class Program
{
    static void Main(string[] args)
    {
        IHouse house = BuildHouse(false);
        Console.WriteLine(house.Description());
        Console.ReadKey();
    }

    public static IHouse BuildHouse(bool isBackyard)
    {
        if (isBackyard)
        {
            return new SingleFamilyHouse();
        }
        else
        {
            return new Aparement();
        }
    }
}

public interface IHouse
{
    Boolean GetBackyard();
    long NoOfRooms();
    string Description();
}

public class Room
{
    public string RoomName { get; set; }
}

public class Aparement : IHouse
{
    private Boolean isBackyard; //是否带院子
    private List<Room> rooms;

    public Aparement()
    {
        rooms = new List<Room>();

        Room room = new Room();  //与Room类形成组合关系
        room.RoomName = "Master Room";
        rooms.Add(room);

        room = new Room();
        room.RoomName = "Second BedRoom";
        rooms.Add(room);

        room = new Room();
        room.RoomName = "Living Room";
        rooms.Add(room);
        isBackyard = false;
    }

    public bool GetBackyard()
    {
        return isBackyard;
    }

    public long NoOfRooms()
    {
        return rooms.Count;
    }

    public string Description()
    {
        StringBuilder strDescript = new StringBuilder();
        strDescript.AppendFormat("这是一间公寓，有{0}间房间，这间公寓没有后院", rooms.Count).AppendLine();
        foreach (Room item in rooms)
        {
            strDescript.AppendFormat("{0}房间{1}", rooms.FindIndex(t => t.RoomName == item.RoomName), item.RoomName).AppendLine();
        }
        return strDescript.ToString();
    }
}

public class SingleFamilyHouse : IHouse
{
    private bool isBackyard;
    private List<Room> rooms;

    public SingleFamilyHouse()
    {
        rooms = new List<Room>();

        Room room = new Room();  //与Room类形式组合关系。
        room.RoomName = "Master Room";
        rooms.Add(room);

        room = new Room();
        room.RoomName = "Second BedRoom";
        rooms.Add(room);

        room = new Room();
        room.RoomName = "Third BedRoom";
        rooms.Add(room);

        room = new Room();
        room.RoomName = "Guest BedRoom";
        rooms.Add(room);

        room = new Room();
        room.RoomName = "Living Room";
        rooms.Add(room);
        isBackyard = true;
    }

    public bool GetBackyard()
    {
        return isBackyard;
    }

    public long NoOfRooms()
    {
        return rooms.Count;
    }

    public string Description()
    {
        StringBuilder strDescript = new StringBuilder();
        strDescript.AppendFormat("这是一间公寓，有{0}间房间，这间公寓有后院", rooms.Count).AppendLine();
        foreach (Room item in rooms)
        {
            strDescript.AppendFormat("{0}房间{1}", rooms.FindIndex(t => t.RoomName == item.RoomName), item.RoomName).AppendLine();
        }
        return strDescript.ToString();
    }
}

（五）建造者模式的适用性及优缺点分析

优点：建造者模式使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体建造者就可以了。建造者模式将一个复杂对象的生成责任进行了很好的分配。它把构造过程放到指挥者的方法中，把装配过程放到具体建造者类中。建造者模式的产品之间都有共通点。

缺点：如果产品之间的差异性很大，这就需要借助工厂方法模式或抽象工厂模式。另外，如果产品的内部变化复杂，Builder的每一个子类都需要对应到不同的产品去做构建的动作，这就需要定义很多个具体建造者类来实现这种变化。

适用性：

①  创建复杂对象的算法是独立于它的组成部件及装配过程。

创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。

②  构造的过程允许构造对象有不同的表现。