比如说组装机电脑，是很多东西组建成的。

//产品类，复杂的产品是由多种东西组成的
public class ComputeProduct {

    private string cpu;
    private string gpu;
    private string look;

    public void setCup(string cup) { this.cpu = cpu; }
    public void setGpu(string gpu) { this.gpu = gpu; }
    public void setLook(string look) {  this.look = look;}

}

//构建的抽象类
public interface IBuild {

    void buildGpu(string gpu);
    void buildCPU(string cpu);
    void buildLook(string look);

    ComputeProduct GetResult();
}

//具体的构造类
public class ComputerBuild : IBuild
{
    private ComputeProduct computer = new ComputeProduct();

    public void buildCPU(string cpu)
    {
        computer.setCup(cpu);
    }

    public void buildGpu(string gpu)
    {
        computer.setGpu(gpu);
    }

    public void buildLook(string look)
    {
        computer.setLook(look);
    }

    public ComputeProduct GetResult()
    {
        return computer;
    }
}

//指挥类，控制组装的顺序
public class Direction  {

    private IBuild build;

    public Direction(IBuild build)
    {
        this.build = build;
    }

    public ComputeProduct BuildComputer(string cpu, string gpu, string look)
    {
        build.buildCPU(cpu);
        build.buildGpu(gpu);
        build.buildLook(look);
        return build.GetResult();
    }
}

//使用
using UnityEngine;

public class testBuild : MonoBehaviour {
    
	void Start () {
        IBuild build = new ComputerBuild();
        Direction dir = new Direction(build);
        dir.BuildComputer("ffg", "ttr", "beauty");
	}
}

如果某个产品是很复杂的，且由一定的组件构造起来的，我们就可以使用构造者模式。易于扩展，但是使用得有点多余的，浪费内存。