单例模式

       整个软件生命周期中有且仅有一个实例。继承自MonoBehavior的类挂载到游戏物体上面算初始化一次，在Awake里引用到实例Instance=this；非继承自Mono的类需要在代码里初始化对象。（尽量在管理者的身上写单例，例如AudioManager，ParticleSystemManager）

private static A _instance;

public static A Instance
{
    get { return _instance ??= new A(); }
}//再次吐槽下Resharper是真的强大

private static readonly A _instance = new A();

public static A Instance => _instance;

工厂模式

       这个简单字义如其名，就是我们不关心产品是如何造出来的，只需要关心工厂要什么东西（传递参数），产出什么东西出来（传递出来的结果），一般不需要继承自mono，需要什么引入命名空间就行。

using UnityEngine;

public static class TestFactory//工厂
{
    private static Sprite[] _sprites;

    static TestFactory()
    {
        Initialization();
    }
    private static void Initialization()
    {
        _sprites = Resources.LoadAll<Sprite>("1");
    }

    public static void CreateSprite(int index,Vector2 trans,Transform parentTransform)
    {
        GameObject tempGameObject = new GameObject();
        tempGameObject.transform.SetParent(parentTransform);
        tempGameObject.transform.localPosition = trans;
        tempGameObject.AddComponent<SpriteRenderer>();
        index %= _sprites.Length;
        tempGameObject.GetComponent<SpriteRenderer>().sprite = _sprites[index];
    }
}

using UnityEngine;

public class TestUsingFactory : MonoBehaviour//使用工厂
{
    private int index = 0;
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            TestFactory.CreateSprite(index,Vector3.one*index,gameObject.transform);
            index++;
        }
    }
}

观察者模式

       通俗来讲的话就是收作业的模式，自己就是收作业的那个人，观察者模式就是一个人一个人每时每刻的问下去，看他们什么时候可以交作业的模式。（就是Update里写if加计时器）

public class TestObserverMode : MonoBehaviour
{
	private float timer=1f;
    void Update()
    {
        if (timer>1f)
        {
            //do something
        }
    }
}

代理模式

       上面的观察者模式是每时每刻的都在监视被观察者，而代理模式就是开始写作业的时候，收作业的人对写作业的说，写完之后交给他，就是干了这么一件事。应用在c#里就是委托和事件。

Button btn = GetComponent<Button>();//事件
btn.onClick.AddListener(() => { });

public UnityAction MyAction;//委托，unity居然没有function委托
MyAction += (() => { });
MyAction.Invoke();

策略者模式

       嗯…还是精简的说吧，这模式大概意思就是公司接待不同客户有不同的方法，给出不同的解决方案，转到编程中就是一个类的同一个方法，可以有多个结果。不同客户比作不同子类，客户们可以抽象成一个父类，，在子类中都重写父类解决方案这个方法，在使用的类中去创建方法去引用父类的方法，而参数设置为指向父类的指针（因为是对类的引用所以形容为指针），使用时传递子类的引用（就是多态），这样就实现了不同客户对象的解决方案都不同了。

using UnityEngine;

public class Client
{
    public virtual void SolveProblem()
    {
        //do something
    }
}
public class Client1:Client
{
    public override void SolveProblem()
    {
        Debug.Log("Client1's problem has been solved");
    }
}
public class Client2:Client
{
    public override void SolveProblem()
    {
        Debug.Log("Client2's problem has been solved");
    }
}
public class TestStrategy : MonoBehaviour
{
    void SolveProblem(Client baseClient)
    {
        baseClient.SolveProblem();
    }
    void Start()
    {
        Client1 client1 = new Client1();
        Client2 client2 = new Client2();
        SolveProblem(client1);
        SolveProblem(client2);
    }
}

建造者模式

       与公司的管理制度相同，由上到下依次分级，如：老板=>经理=>员工 这种层级。可以把各个模块分的很小，从而对应到各个类中，缺点则是动则牵一身，多层继承的不建议用

using  UnityEngine;

namespace Asset
{
    public class Boss
    {
        private Manager[] _managers;

        private static Boss _boss;
        public static Boss Boss1 => _boss ?? (_boss = new Boss());

        private Boss()
        {
            _managers = new Manager[2] {new Manager(), new Manager()};
        }

        internal void AssignWork()
        {
            foreach (Manager manager in _managers)
            {
                manager.AssignWork();
                manager.GetToWork();
            }
        }
    }

    public class Manager
    {
        private Employee[] _employees;

        public Manager()
        {
            _employees = new Employee[2] {new Employee(), new Employee()};
        }

        internal void GetToWork()
        {
            Debug.Log("work");
        }

        internal void AssignWork()
        {
            foreach (Employee employee in _employees)
            {
                employee.GetToWork();
            }
        }
    }

    public class Employee
    {
        internal void GetToWork()
        {
            Debug.Log("work");
        }
    }
}

using UnityEngine;

namespace Asset
{
    public class TestBulider : MonoBehaviour
    {
        void Start()
        {
            Boss.Boss1.AssignWork();
        }
    }
}

中介者模式

       顾名思义就是房东和客户需要中介来介入来减少耦合性。举个客户和经理的例子，客户需要公司出产品，而又不直接和员工谈需求，所以需要经理来充当中介，客户提需求给经理，经理给员工方案，员工做好了拿给经理，经理转交给客户。举例：客户=>经理<=员工（建议搭配MVC更香哦）

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

public class Manager
{
    private Employee _employee;
    private Customer _customer;

    public Manager(Employee employee,Customer customer)
    {
        this._employee = employee;
        this._customer = customer;
    }

    public void SolveProblems() => _employee.SolveProblems();
    public void AskQuestions() => _customer.AskQuestions();
}

public class Employee
{
    public void SolveProblems()
    {
        //SolveProblems
        Debug.Log("The Problem has been solved");
    }
}

public class Customer
{
    public void AskQuestions()
    {
        //AskQuestions
        Debug.Log("The customer asks some questions");
    }
}

public class TestMediator : MonoBehaviour
{
    void Start()
    {
        Customer customer = new Customer();
        Employee employee = new Employee();
        Manager manager = new Manager(employee, customer);
        manager.AskQuestions();
        manager.SolveProblems();
    }
}

门面模式

       将不同类型或毫无相干的对象聚合在一起，形成新的功能，例如红绿灯，在场景中最多只是作为空物体的子物体，都是一个独立的个体，但是又可以相互影响，这时就要用到了。实现（放置两个Image代表红绿灯，放置一个Button来切换，调用onClick.AddListener()来实现转换）

组合模式

       与门面模式相反，组合模式是把有关联的对象聚合在一起来实现同步调用。例如汽车的各零件直接都是组成汽车的必不可少的部件，在启动时都有各自的用处，而就是各个零件才组成了一个汽车，汽车要想动所有的零件都要发挥作用才可以动，缺一不可。实现（所有的零件建立一个基类来承载，在调用的类里创建list承载所有的零件，update里循环调用所有零件的方法实现汽车的移动）