用Unity写设计模式-建造者模式

建造者模式介绍

将一个复杂对象的构造与它的表示分离 使同样的构建过程可以创建不同的表示 这样的设计模式被称为建造者模式

参数详解

• 参与者：参与此模式的类和对象是:

• Builder (机动车建造者)

指定一个抽象接口，用于创建Product对象的各个部分

• ConcreteBuilder 具体建设者(摩托车建设者，汽车建设者，踏板车建设者)

通过实现Builder接口来构造和组装产品的各个部分
定义并跟踪它创建的表示
提供了检索产品的接口

• Director 董事(店)

使用Builder接口构造一个对象

• Product 产品(机动车)

表示正在构建的复杂对象。 ConcreteBuilder构建产品的内部表示，并定义组装过程
包含定义组成部分的类，包括将这些部分组装成最终结果的接口

建造者模式

//-------------------------------------------------------------------------------------
//	BuilderStructure.cs
//-------------------------------------------------------------------------------------

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class BuilderStructure : MonoBehaviour
{
	void Start ( )
    {
        // 实例化建造管理器 建造者
        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();
    }
}

/// <summary>
/// 建造管理器
/// </summary>
class Director
{
    // Builder使用一系列复合的步骤
    // 参数传递：基类对象用子类实例化-执行子类建造方法
    public void Construct(Builder builder)
    {
        builder.BuildPartA();
        builder.BuildPartB();
    }
}

/// <summary>
/// 建造者
/// </summary>
abstract class Builder
{
    public abstract void BuildPartA();
    public abstract void BuildPartB();
    public abstract Product GetResult();
}

/// <summary>
/// 建造者1号
/// </summary>
class ConcreteBuilder1 : Builder
{
    private Product _product = new Product();

    public override void BuildPartA()
    {
        _product.Add("PartA");
    }

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

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

/// <summary>
/// 建造者2号
/// </summary>
class ConcreteBuilder2 : Builder
{
    private Product _product = new Product();

    public override void BuildPartA()
    {
        _product.Add("PartX");
    }

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

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

/// <summary>
/// 产品
/// </summary>
class Product
{
    private List<string> _parts = new List<string>();

    public void Add(string part)
    {
        _parts.Add(part);
    }

    public void Show()
    {
      Debug.Log("\nProduct Parts -------");
        foreach (string part in _parts)
        {
            Debug.Log(part);
        }

    }
}

请忽略此图…

建造者模式案例1

//-------------------------------------------------------------------------------------
//	BuilderPatternExample1.cs
//-------------------------------------------------------------------------------------

using System;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

//This real-world code demonstates the Builder pattern in which different vehicles are assembled in a step-by-step fashion. 
//The Shop uses VehicleBuilders to construct a variety of Vehicles in a series of sequential steps.

namespace BuilderPatternExample1
{
    public class BuilderPatternExample1 : MonoBehaviour
    {
        void Start()
        {
            VehicleBuilder builder;

            // Create shop with vehicle builders
            Shop shop = new Shop();

            // Construct and display vehicles
            builder = new ScooterBuilder();
            shop.Construct(builder);
            builder.Vehicle.Show();

            builder = new CarBuilder();
            shop.Construct(builder);
            builder.Vehicle.Show();

            builder = new MotorCycleBuilder();
            shop.Construct(builder);
            builder.Vehicle.Show();

        }
    }

    /// <summary>
    /// The 'Director' class
    /// </summary>
    class Shop
    {
        // Builder uses a complex series of steps
        public void Construct(VehicleBuilder vehicleBuilder)
        {
            vehicleBuilder.BuildFrame();
            vehicleBuilder.BuildEngine();
            vehicleBuilder.BuildWheels();
            vehicleBuilder.BuildDoors();
        }
    }

    /// <summary>
    /// The 'Builder' abstract class
    /// </summary>
    abstract class VehicleBuilder
    {
        protected Vehicle vehicle;

        // Gets vehicle instance
        public Vehicle Vehicle
        {
            get { return vehicle; }
        }

        // Abstract build methods
        public abstract void BuildFrame();
        public abstract void BuildEngine();
        public abstract void BuildWheels();
        public abstract void BuildDoors();
    }

    /// <summary>
    /// The 'ConcreteBuilder1' class
    /// </summary>
    class MotorCycleBuilder : VehicleBuilder
    {
        public MotorCycleBuilder()
        {
            vehicle = new Vehicle("MotorCycle");
        }

        public override void BuildFrame()
        {
            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";
        }
    }


    /// <summary>
    /// The 'ConcreteBuilder2' class
    /// </summary>
    class CarBuilder : VehicleBuilder
    {
        public CarBuilder()
        {
            vehicle = new Vehicle("Car");
        }

        public override void BuildFrame()
        {
            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";
        }
    }

    /// <summary>
    /// The 'ConcreteBuilder3' class
    /// </summary>
    class ScooterBuilder : VehicleBuilder
    {
        public ScooterBuilder()
        {
            vehicle = new Vehicle("Scooter");
        }

        public override void BuildFrame()
        {
            vehicle["frame"] = "Scooter Frame";
        }

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

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

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

    /// <summary>
    /// The 'Product' class
    /// </summary>
    class Vehicle
    {
        private string _vehicleType;
        private Dictionary<string, string> _parts =
          new Dictionary<string, string>();

        // Constructor
        public Vehicle(string vehicleType)
        {
            this._vehicleType = vehicleType;
        }

        // Indexer
        public string this[string key]
        {
            get { return _parts[key]; }
            set { _parts[key] = value; }
        }

        public void Show()
        {
            Debug.Log("\n---------------------------");
            Debug.Log("Vehicle Type: " + _vehicleType);
            Debug.Log(" Frame : " + _parts["frame"]);
            Debug.Log(" Engine : " + _parts["engine"]);
            Debug.Log(" #Wheels: " + _parts["wheels"]);
            Debug.Log(" #Doors : " + _parts["doors"]);
        }
    }
}

建造者模式案例2

//-------------------------------------------------------------------------------------
//	BuilderPatternExample2.cs
//-------------------------------------------------------------------------------------

using UnityEngine;
using System.Collections;

namespace BuilderPatternExample2
{
    public class BuilderPatternExample2 : MonoBehaviour
    {
        void Start()
        {
            IRobotBuilder oldRobot = new OldRobotBuilder();
            RobotEngineer engineer = new RobotEngineer(oldRobot);
            engineer.MakeRobot();

            Robot firstRobot = engineer.GetRobot();
            Debug.Log("First Robot built");
            Debug.Log(firstRobot.ToStringEX());
        }
    }

    public interface IRobotPlan
    {
        void SetRobotHead(string head);

        void SetRobotTorso(string torso);

        void SetRobotArms(string arms);

        void SetRobotLegs(string legs);
    }

    public class Robot : IRobotPlan
    {
        public string head { get; protected set; }
        public string torso { get; protected set; }
        public string arms { get; protected set; }
        public string legs { get; protected set; }

        public void SetRobotHead(string head)
        {
            this.head = head;
        }

        public void SetRobotTorso(string torso)
        {
            this.torso = torso;
        }

        public void SetRobotArms(string arms)
        {
            this.arms = arms;
        }

        public void SetRobotLegs(string legs)
        {
            this.legs = legs;
        }

        public string ToStringEX()
        {
            return "Head: " + this.head + ", torso: " + this.torso + ", Arms: " + arms + ", legs: " + legs;
        }
    }




    // they're kinda like a blueprint these RobotBuilder classes:
    public interface IRobotBuilder
    {
        Robot GetRobot();
        void BuildRobotHead();
        void BuildRobotTorso();
        void BuildRobotArms();
        void BuildRobotLegs();
    }

    // for each new robot that you might want to have just create a new RobotBuilder Object
    public class OldRobotBuilder : IRobotBuilder
    {
        protected Robot robot { get; set; }

        public OldRobotBuilder()
        {
            this.robot = new Robot();
        }

        public Robot GetRobot()
        {
            return robot;
        }

        public void BuildRobotHead()
        {
            this.robot.SetRobotHead("Old Head");
        }

        public void BuildRobotTorso()
        {
            this.robot.SetRobotTorso("Old Torso");
        }

        public void BuildRobotArms()
        {
            this.robot.SetRobotArms("Old Arms");
        }

        public void BuildRobotLegs()
        {
            this.robot.SetRobotLegs("Roller Skates");
        }
    }



    // he just calls the method in the Robot Objects (which are defined by the interface, just think of blueprints)
    public class RobotEngineer
    {
        public IRobotBuilder robotBuilder { get; protected set; }

        public RobotEngineer(IRobotBuilder builder)
        {
            this.robotBuilder = builder;
        }

        public Robot GetRobot()
        {
            return this.robotBuilder.GetRobot();
        }

        public void MakeRobot()
        {
            this.robotBuilder.BuildRobotHead();
            this.robotBuilder.BuildRobotTorso();
            this.robotBuilder.BuildRobotArms();
            this.robotBuilder.BuildRobotLegs();
        }
    }


}

中括号的用法单独拎出来

• 详细用法传送门

实例化的对象没有点出属性使用，直接在中括号填写参数

 vehicle["frame"] = "Car Frame"