创建型模式 --- 建造者模式(Builder)

Builder模式的缘起：
假设创建游戏中的一个房屋House设施，该房屋的构建由几部分组成，且各个部分富于变化。如果使用最直观的设计方法，每一个房屋部分的变化，都将导致房屋构建的重新修正…..
动机（Motivation):
在软件系统中，有时候面临一个”复杂对象”的创建工作，其通常由各个部分的子对象用一定算法构成;由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合到一起的算法却相对稳定。
如何应对种变化呢？如何提供一种”封装机制”来隔离出”复杂对象的各个部分”的变化，从而保持系统中的”稳定构建算法”不随需求的改变而改变？
意图(Intent)：
将一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
——-《设计模式》GOF
结构图(Struct):

协作(Collaborations):

生活中的例子：

适用性：
1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2.当构造过程必须允许被构造的对象有不同的表示时。

实例代码：

Builder类：

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

           public abstract House GetHouse();
     }

Director类：这一部分是 组合到一起的算法（相对稳定）。

public class Director
 {
        public void Construct(Builder builder)
        {
            builder.BuildWall();
            builder.BuildHouseCeiling();          
            builder.BuildDoor();
            builder.BuildWindows();
            builder.BuildFloor();         
       }
 }

ChineseBuilder类

public class ChineseBuilder:Builder
 {
         private House ChineseHouse = new House();
          public override void BuildDoor()
          {
              Console.WriteLine("this Door 's style of Chinese");
          }
          public override void BuildWall()
          {
             Console.WriteLine("this Wall 's style of Chinese");
         }
         public override void BuildWindows()
         {
             Console.WriteLine("this Windows 's style of Chinese");
         }
         public override void BuildFloor()
         {
             Console.WriteLine("this Floor 's style of Chinese");
         }
         public override void BuildHouseCeiling()
         {
             Console.WriteLine("this Ceiling 's style of Chinese");
         }
         public override House GetHouse()
         {
             return ChineseHouse;
         }
 }

RomanBuilder类：

 class RomanBuilder:Builder
      {
          private House RomanHouse = new House();
          public override void BuildDoor()
          {
              Console.WriteLine("this Door 's style of Roman");
          }
          public override void BuildWall()
          {
             Console.WriteLine("this Wall 's style of Roman");
         }
         public override void BuildWindows()
         {
             Console.WriteLine("this Windows 's style of Roman");
         }
         public override void BuildFloor()
         {
             Console.WriteLine("this Floor 's style of Roman");
         }
         public override void BuildHouseCeiling()
         {
             Console.WriteLine("this Ceiling 's style of Roman");
         }
         public override House GetHouse()
         {
             return RomanHouse;
         }
 }

ChineseBuilder和RomanBuilder这两个是：这个复杂对象的两个部分经常面临着剧烈的变化。

   public class Client
     {
         public static void Main(string[] args)
         {
             Director director = new Director();

             Builder instance;

             Console.WriteLine("Please Enter House No:");

             string No = Console.ReadLine();

             string houseType = ConfigurationSettings.AppSettings["No" + No];

             instance = (Builder)Assembly.Load("House").CreateInstance("House." + houseType);

             director.Construct(instance);

             House house= instance.GetHouse();
             house.Show();

             Console.ReadLine();
         }
     }

 <?xml version="1.0" encoding="utf-8" ?>
 <configuration>
   <appSettings>
     <add key="No1" value="RomanBuilder"></add>
     <add key="No2" value="ChineseBuilder"></add>
   </appSettings>
 </configuration>

Builder模式的几个要点:

Builder模式 主要用于“分步骤构建一个复杂的对象”。在这其中“分步*骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。*
Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在*于难以应对“分步骤构建算法”的需求变动*。

Abstract Factory模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化。
Builder模式通常和Composite模式组合使用。