c#设计模式- Builder模式（建造者模式）

最新推荐文章于 2024-07-12 17:34:12 发布

fffanpei

最新推荐文章于 2024-07-12 17:34:12 发布

阅读量1k

点赞数

分类专栏：设计模式文章标签：建造者模式

设计模式专栏收录该内容

6 篇文章 0 订阅

订阅专栏

参考以下链接

http://www.cnblogs.com/zhenyulu/articles/37378.html

http://wenku.baidu.com/link?url=9pgl-CINtdSZKeL9PEZ2AggLB1gppKpMRqmyhcvqOUrXQn9hIXZVKmPAI_0dl7JdOhRKFvXmL9YDCnB_MhTatWZvRqAzmHH-ia67yfrBHrW

http://wenku.baidu.com/link?url=a09XcM5Nn1OKpcbbQb3UIFECqD8DVOvbcW6ugEhST8GbNi8xaoN6sjEkMKK5lqAs4VU3qTygHXtqDvlTrz-m5qDzLkfp0OxCftfs9lHajD7

http://www.cnblogs.com/promise-7/archive/2012/06/11/2545401.html

一建造者（Builder）模式

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

二 Builder结构

建造者（Builder）角色：给出一个抽象接口，以规范产品对象的各个组成成分的建造。一般而言，此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者（ConcreteBuilder）角色。具体建造者类必须实现这个接口所要求的方法：一个是建造方法，另一个是结果返还方法。

具体建造者（Concrete Builder）角色：担任这个角色的是于应用程序紧密相关的类，它们在应用程序调用下创建产品实例。这个角色主要完成的任务包括：

实现Builder角色提供的接口，一步一步完成创建产品实例的过程。
在建造过程完成后，提供产品的实例。

指导者（Director）角色：担任这个角色的类调用具体建造者角色以创建产品对象。导演者并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者对象。

产品（Product）角色：产品便是建造中的复杂对象。

三举例

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

namespace Builder1
{
    // Product class.
    class Product
    {
        ArrayList parts = new ArrayList();

        public void Add(string part)
        {
            if (!parts.Contains(part))
            { 
                parts.Add(part); 
            }
        }

        public void Show()
        {
            Console.WriteLine("Product parts -------------");
            foreach (string temp in parts)
            {
                Console.WriteLine(temp);
            }
        }
    }

    // Abstract builder class.
    abstract class Builder
    {
        abstract public void BuildPartA();
        abstract public void BuildPartB();
        abstract public Product GetResult();
    }

    class ConcreteBuilder1 : Builder
    {
        private Product product;

        public override void BuildPartA()
        {
            product = new Product();
            product.Add("PartA");
        }

        public override void BuildPartB()
        {
            product.Add("PartB");
        }

        public override Product GetResult()
        {
            return product;
        }
    }

    class ConcreteBuilder2 : Builder
    {
        private Product product;

        public override void BuildPartA()
        {
            product = new Product();
            product.Add("PartX");
        }

        public override void BuildPartB()
        {
            product.Add("PartY");
        }

        public override Product GetResult()
        {
            return product;
        }
    }

    // Director class
    class Director
    {
        public void Construct(Builder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
        }
    }

    public class Client
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Builder b1 = new ConcreteBuilder1();
            Builder b2 = new ConcreteBuilder2();

            director.Construct(b1);
            Product p1 = b1.GetResult();
            p1.Show();

            director.Construct(b2);
            Product p2 = b2.GetResult();
            p2.Show();
        }
    }
}

抽象建造者类 Builder

实现的具体类ConcreteBuilder1和ConcreteBuilder2

指导者类Director

客户端负责创建指导者和具体建造者对象。然后，客户把具体建造者对象交给指导者。客户一声令下，指导者操纵建造者开始创建产品。当产品创建完成后，建造者把产品返还给客户端。

运行结果

四另一个例子

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

namespace Build2
{
    // Product.
    class Car
    {
        private string type;
        private Hashtable parts = new Hashtable();

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

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

        public void Show()
        {
            Console.WriteLine("-------------------------");
            Console.WriteLine("Car type:"+ type);
            Console.WriteLine(" Frame :" + parts["frame"]);
            Console.WriteLine(" Engine :" + parts["engine"]);
            Console.WriteLine(" Wheels :" + parts["wheels"]);
            Console.WriteLine(" Doors :" + parts["doors"]);
            Console.WriteLine(string.Empty);
        }
    }

    // Abstract builder class
    abstract class CarBuilder
    {
        protected Car car;

        public Car Car
        {
            get { return car;}
        }

        abstract public void BuildFrame();
        abstract public void BuildEngine();
        abstract public void BuildWheels();
        abstract public void BuildDoors();
    }

    class MotorBuilder : CarBuilder
    {
        public override void BuildFrame()
        {
            car = new Car("Motor");
            car["frame"] = "Motor Frame";
        }

        public override void BuildEngine()
        {
            car["engine"] = "Motor engine - 500 cc";
        }

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

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

    class JeepBuilder : CarBuilder
    {
        public override void BuildFrame()
        {
            car = new Car("Jeep");
            car["frame"] = "Jeep Frame";
        }

        public override void BuildEngine()
        {
            car["engine"] = "2.0T";
        }

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

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

    class TruckBuilder : CarBuilder
    {
        public override void BuildFrame()
        {
            car = new Car("Truck");
            car["frame"] = "Truck Frame";
        }

        public override void BuildEngine()
        {
            car["engine"] = "3.6 L";
        }

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

        public override void BuildDoors()
        {
            car["doors"] = "2";
        }
    }

    // Director
    class FourSShop
    {
        public void Construct(CarBuilder carBuilder)
        {
            carBuilder.BuildFrame();
            carBuilder.BuildEngine();
            carBuilder.BuildWheels();
            carBuilder.BuildDoors();
        }
    }


    public class Client
    {
        public static void Main(string[] args)
        {
            FourSShop store = new FourSShop();
            CarBuilder b1 = new MotorBuilder();
            CarBuilder b2 = new JeepBuilder();
            CarBuilder b3 = new TruckBuilder();

            store.Construct(b1);
            b1.Car.Show();

            store.Construct(b2);
            b2.Car.Show();

            store.Construct(b3);
            b3.Car.Show();
        }
    }
}

汽车组装和4S养护之类都是很好的例子。

五简化

1 省去抽象建造者

class Director
{
  private ConcreteBuilder builder;

  // Methods
  public void Construct()
  {
    builder.BuildPartA();
    builder.BuildPartB();
  }
}

2 省去指导者类

public class Builder
{
  private Product product = new Product();

  public void BuildPartA()
  { 
    //Some code here
  }

  public void BuildPartB()
  {
    //Some code here
  }

  public Product GetResult()
  {
    return product;
  }

  public void Construct()
  {
    BuildPartA();
    BuildPartB();
  }
}

客户端调整为

public class Client
{
  private static Builder builder;

  public static void Main()
  {
    builder = new Builder();
    builder.Construct();
    Product product = builder.GetResult();
  }
}

六总结

实现要点

1、建造者模式主要用于“分步骤构建一个复杂的对象”，在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。

2、产品不需要抽象类，特别是由于创建对象的算法复杂而导致使用此模式的情况下或者此模式应用于产品的生成过程，其最终结果可能差异很大，不大可能提炼出一个抽象产品类。

3、创建者中的创建子部件的接口方法不是抽象方法而是空方法，不进行任何操作，具体的创建者只需要覆盖需要的方法就可以，但是这也不是绝对的，特别是类似文本转换这种情况下，缺省的方法将输入原封不动的输出是合理的缺省操作。

4、前面我们说过的抽象工厂模式（Abtract Factory）解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化，建造者模式常和组合模式（Composite Pattern）结合使用。

效果

1、建造者模式的使用使得产品的内部表象可以独立的变化。使用建造者模式可以使客户端不必知道产品内部组成的细节。

2、每一个Builder都相对独立，而与其它的Builder无关。

3、可使对构造过程更加精细控制。

4、将构建代码和表示代码分开。

5、建造者模式的缺点在于难于应付“分步骤构建算法”的需求变动。

适用性
以下情况应当使用建造者模式：

1、需要生成的产品对象有复杂的内部结构。

2、需要生成的产品对象的属性相互依赖，建造者模式可以强迫生成顺序。

3、在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。