设计模式 --建造者模式

部分文字内容摘自网络；

建造者模式（Builder Pattern）:将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式使得建造代码与表示代码的分离，可以使客户端不必知道产品内部组成的细节，从而降低了客户端与具体产品之间的耦合度，下面通过类图来帮助大家更好地理清建造者模式中类之间的关系。

在建造者模式中，指挥者是直接与客户端打交道的，指挥者将客户端创建产品的请求划分为对各个部件的建造请求，再将这些请求委派到具体建造者角色，具体建造者角色是完成具体产品的构建工作的，却不为客户所知道。
建造者模式主要用于“分步骤来构建一个复杂的对象”，其中“分步骤”是一个固定的组合过程，而复杂对象的各个部分是经常变化的
产品不需要抽象类，由于建造模式的创建出来的最终产品可能差异很大，所以不大可能提炼出一个抽象产品类。
在前面文章中介绍的抽象工厂模式解决了“系列产品”的需求变化，而建造者模式解决的是 “产品部分” 的需要变化。
由于建造者隐藏了具体产品的组装过程，所以要改变一个产品的内部表示，只需要再实现一个具体的建造者就可以了，从而能很好地应对产品组成组件的需求变化。

详细代码如下

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

namespace BuildFactoryModel
{
class Program
{
static void Main(string[] args)
{
//指令，汽车制造者，制造一辆汽车
Car newcar =  CarMaker.Instance.BuildAnCar();
Console.ReadKey();
}
}
}

具体例子：

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

namespace BuildFactoryModel
{
/// <summary>
/// 制造基类
/// </summary>
public abstract class Maker
{
/// <summary>
/// 一个抽象的方法。所有制作者都实现这个方法
/// </summary>
/// <returns></returns>
public abstract basicClass build();
/// <summary>
/// 一个虚函数。可以有子类方法来覆盖
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
virtual public basicClass build(string parm)
{
return new basicClass();
}
}
/// <summary>
/// 发动机制作者
/// </summary>
public class engineMaker : Maker
{
/// <summary>
/// 建造一个发动机
/// </summary>
/// <returns></returns>
public override basicClass build()
{
return new Enginer();
}
}
/// <summary>
/// 控制系统制作者
/// </summary>
public class consysMaker : Maker
{
/// <summary>
/// 建造一个控制系统
/// </summary>
/// <returns></returns>
public override basicClass build()
{
return new ControlSystem();
}
}

/// <summary>
/// 轮胎制作者
/// </summary>
public class wheelMaker : Maker
{
public override basicClass build()
{
return new Wheel();
}
/// <summary>
/// 覆盖父类的建造方法，使用一个带参数
/// （复习虚函数使用方法）
/// </summary>
/// <param name="parm"></param>
/// <returns></returns>
public override basicClass build(string parm)
{
return new Wheel(parm);
}
}
/// <summary>
/// 控制系统制作者
/// </summary>
public class ControlSystemMaker : Maker
{
public override basicClass build()
{

return new ControlSystem();
}
}
/// <summary>
/// 座椅制作者
/// </summary>
public class ChairMaker : Maker
{
/// <summary>
/// 制造座椅
/// </summary>
/// <returns></returns>
public override basicClass build()
{
return new Chair();
}
/// <summary>
/// 制造某个特定座椅
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public override basicClass build(string param)
{
return new Chair(param);
}
}

/// <summary>
/// 汽车制造者
/// </summary>
public class CarMaker
{
/// <summary>
/// 汽车制造者需要的其他部件制作者
/// </summary>
/// 汽车铁框框制作者
private static carframeMaker carframeMaker;
/// <summary>
/// 汽车座椅制作者
/// </summary>
private static ChairMaker ChairMaker;
/// <summary>
/// 汽车轮胎制作者
/// </summary>
private static wheelMaker wheelMaker;
/// <summary>
/// 汽车发动机制作者
/// </summary>
private static engineMaker engineMaker;
/// <summary>
/// 汽车控制系统制作者
/// </summary>
private static consysMaker consysMaker;

/// <summary>
/// 汽车制作者采用单例模式  静态属性，私有构造，
/// 这里复习单例模式而已
/// </summary>
private static CarMaker _carMaker;
public static CarMaker Instance { get {
if (null == _carMaker) {
_carMaker = new CarMaker();
}
return _carMaker;
}
}
/// <summary>
/// 私有构造函数中实例化这些部件制作者
/// </summary>
private CarMaker() {
if (null == carframeMaker) {
carframeMaker = new carframeMaker();
}
if (null == ChairMaker)
{
ChairMaker = new ChairMaker();
}
if (null == wheelMaker)
{
wheelMaker = new wheelMaker();
}
if (null == engineMaker)
{
engineMaker = new engineMaker();
}
if (null == consysMaker)
{
consysMaker = new consysMaker();
}
}

/// <summary>
/// 建造这个汽车方法
/// </summary>
/// <returns></returns>
public Car BuildAnCar() {
Car car = new Car();
/// 制造铁壳
car.carframe = (CarFrame)carframeMaker.build();
//制造发动机
car.enginer = (Enginer)engineMaker.build();
//造四个座椅
for (int i = 1; i <= 4; i++)
{
car.Chairs.Add((Chair)ChairMaker.build(i.ToString ()));
}
//造四个轮胎
for (int i = 1; i <= 4; i++)
{
car.wheels.Add((Wheel)wheelMaker.build(i.ToString()));
}
//造控制系统
car.controlsystem = (ControlSystem)consysMaker.build();
return car;
}
}

public class carframeMaker : Maker {
public override basicClass build()
{
return  new CarFrame();
}
}
/// <summary>
/// 汽车类
/// </summary>
public class Car {
public List<Wheel> wheels;
public List<Chair> Chairs;
public Enginer enginer;
public ControlSystem controlsystem;
public CarFrame carframe;

public Car() {
Chairs = new List<Chair>();
wheels = new List<Wheel>();
}
}

public class basicClass {

}

/// <summary>
/// 轮子
/// </summary>
public class Wheel :basicClass {
public Wheel (){
Console.WriteLine("Wheel is Ready!");
}
public Wheel(string WheelName){
Console.WriteLine(string.Format( "Wheel {0} is Ready!",WheelName));
}
}
/// <summary>
/// 发动机实体类
/// </summary>
public class Enginer :basicClass{
public Enginer() {
Console.WriteLine("WEnginer is Ready!");
}
}
/// <summary>
/// 控制系统
/// </summary>
public class ControlSystem :basicClass{
public ControlSystem() {
Console.WriteLine("ControlSystem is Ready!");
}
}
/// <summary>
/// 座椅
/// </summary>
public class Chair :basicClass{
public Chair() {
Console.WriteLine("Chair is Ready!");
}
public Chair(string chairname)
{
Console.WriteLine(string.Format("Chair {0}is Ready!",chairname));
}

}

/// <summary>
/// 铁框框
/// </summary>
public class CarFrame : basicClass {
public CarFrame()
{
Console.WriteLine("CarFrame is Ready!");
}
}

}