👉一、迭代器模式（Iterator）

介绍:
迭代器模式是一种行为型设计模式，它提供了一种统一的方式来访问集合对象中的元素，而不是暴露集合内部的表示方式。简单地说，就是将遍历集合的责任封装到一个单独的对象中，我们可以按照特定的方式访问集合中的元素。

代码如下:

public interface IIterator<T> 
{
    bool HasNext();
    T Next();
}
 
public interface IAggregate<T> 
{
    IIterator<T> GetIterator();
}
 
public class ConcreteIterator<T> : IIterator<T> 
{
    private List<T> _items;
    private int _currentIndex = 0;
 
    public ConcreteIterator(List<T> items) 
    {
        _items = items;
    }
 
    public bool HasNext() 
    {
        return _currentIndex < _items.Count;
    }
 
    public T Next() 
    {
        T item = _items[_currentIndex];
        _currentIndex++;
        return item;
    }
}
 
public class ConcreteAggregate<T> : IAggregate<T> 
{
    private List<T> _items = new List<T>();
 
    public void AddItem(T item) 
    {
        _items.Add(item);
    }
 
    public IIterator<T> GetIterator() 
    {
        return new ConcreteIterator<T>(_items);
    }
}

👉二、处理者模式（Chain of Responsibility）

介绍：
‌Unity中的处理者模式‌主要指的是责任链模式，这是一种行为型设计模式，用于处理多个对象之间的请求传递和责任分配。在责任链模式中，请求者发送的请求会沿着处理者链进行传递，直到被处理。这种模式可以避免请求发送者与多个处理者之间的耦合，提高系统的灵活性和可维护性。

代码如下：

public abstract class Handler 
{
    protected Handler _successor;
 
    public void SetSuccessor(Handler successor) 
    {
        _successor = successor;
    }
 
    public abstract void HandleRequest(int request);
}
 
public class ConcreteHandlerA : Handler 
{
    public override void HandleRequest(int request) 
    {
        if (request >= 0 && request < 10) 
        {
            Debug.Log("Handled by Concrete Handler A");
        }
        else if (_successor != null)
        {
            _successor.HandleRequest(request);
        }
    }
}
 
public class ConcreteHandlerB : Handler 
{
    public override void HandleRequest(int request) 
    {
        if (request >= 10 && request < 20) 
        {
            Debug.Log("Handled by Concrete Handler B");
        }
        else if (_successor != null)
        {
            _successor.HandleRequest(request);
        }
    }
}
 
public class ConcreteHandlerC : Handler 
{
    public override void HandleRequest(int request) 
    {
        if (request >= 20 && request < 30) 
        {
            Debug.Log("Handled by Concrete Handler C");
        }
        else if (_successor != null)
        {
            _successor.HandleRequest(request);
        }
    }
}
 
public class Client
{
private Handler _handlerChain;
public Client() 
{
    _handlerChain = new ConcreteHandlerA();
    Handler handlerB = new ConcreteHandlerB();
    Handler handlerC = new ConcreteHandlerC();
    _handlerChain.SetSuccessor(handlerB);
    handlerB.SetSuccessor(handlerC);
}
 
public void ProcessRequests() 
{
    int[] requests = new int[] { 2, 17, 25, 40, 5 };
 
    foreach (int request in requests)
    {
        _handlerChain.HandleRequest(request);
    }
}
}

👉三、装饰者模式（Decorator）

介绍：
‌Unity中的装饰者模式‌是一种结构型设计模式，主要用于动态地给一个对象添加额外的功能，而不需要修改其原有的代码。这种模式在游戏中尤其有用，例如，可以为游戏角色添加不同的装备、技能等，而不需要修改角色的基本代码。

代码如下：

public abstract class Component 
{
    public abstract void Operation();
}
 
public class ConcreteComponent : Component 
{
    public override void Operation() 
    {
        Debug.Log("Concrete Component Operation");
    }
}
 
public abstract class Decorator : Component 
{
    private Component _component;
 
    public Decorator(Component component) 
    {
        _component = component;
    }
 
    public override void Operation() 
    {
        if (_component != null) 
        {
            _component.Operation();
        }
    }
}
 
public class ConcreteDecoratorA : Decorator 
{
    public ConcreteDecoratorA(Component component) : base(component) 
    {
    }
 
    public override void Operation() 
    {
        base.Operation();
        AddedBehavior();
        Debug.Log("Concrete Decorator A Operation");
    }
 
    private void AddedBehavior() 
    {
        Debug.Log("Added Behavior from Concrete Decorator A");
    }
}
 
public class ConcreteDecoratorB : Decorator 
{
    public ConcreteDecoratorB(Component component) : base(component) 
    {
    }
 
    public override void Operation() 
    {
        base.Operation();
        AddedBehavior();
        Debug.Log("Concrete Decorator B Operation");
    }
 
    private void AddedBehavior() 
    {
        Debug.Log("Added Behavior from Concrete Decorator B");
    }
}

👉四、组合模式（Composite）

介绍：
‌在Unity中，组合模式（Composite Pattern）是一种结构型设计模式，它允许将对象组合成树形结构以表现“整体-部分”的层次结构，并且用户可以一致地处理单个对象和组合对象‌。
组合模式在Unity中的应用实例包括图形界面元素的组合。通过定义抽象的UIComponent接口，包含UIButton和UIMenu等具体组件，可以展示如何将单个对象和组合对象进行一致处理。例如，UIButton作为叶子节点不支持添加或删除子组件，而UIMenu作为组合节点则可以管理多个子组件。‌

代码如下：

public abstract class Component 
{
    protected string _name;
 
    public Component(string name) 
    {
        _name = name;
    }
 
    public abstract void Add(Component component);
    public abstract void Remove(Component component);
    public abstract void Display(int depth);
}
 
public class Leaf : Component 
{
    public Leaf(string name) : base(name) 
    {
    }
 
    public override void Add(Component component) 
    {
        Debug.Log("Cannot add to a leaf.");
    }
 
    public override void Remove(Component component) 
    {
        Debug.Log("Cannot remove from a leaf.");
    }
 
    public override void Display(int depth) 
    {
        Debug.Log(new string('-', depth) + " " + _name);
    }
}
 
public classComposite : Component
{
private List<Component> _children = new List<Component>();
public Composite(string name) : base(name) 
{
}
 
public override void Add(Component component) 
{
    _children.Add(component);
}
 
public override void Remove(Component component) 
{
    _children.Remove(component);
}
 
public override void Display(int depth) 
{
    Debug.Log(new string('-', depth) + " " + _name);
 
    foreach (Component component in _children)
    {
        component.Display(depth + 2);
    }
}
}