Unity3D常见的设计模式（三）

心疼你的一切

发布于 2026-01-20 14:41:17

960

👉前言

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

博客将会介绍Unity中常用的设计模式，每种设计模式都会给出详细的示例代码。希望这篇博客对Unity的开发者有所帮助。大家好，我是心疼你的一切，不定时更新Unity开发技巧，觉得有用记得一键三连哦。欢迎点赞评论哦.下面就让我们进入正文吧 !

提示：以下是本篇文章正文内容，下面案例可供参考

👉一、状态模式（State）

介绍： ‌在Unity中使用状态模式是一种行为设计模式，它允许对象在其内部状态改变时改变其行为。‌在Unity中，状态模式通常用于实现角色的不同行为状态切换，例如玩家角色的行走、奔跑、跳跃、攻击等。‌

代码如下：

public interface IState 
{
    void HandleState(Context context);
}
 
public class ConcreteStateA : IState 
{
    public void HandleState(Context context) 
    {
        Debug.Log("Handle State A");
        context.State = new ConcreteStateB();
    }
}
 
public class ConcreteStateB : IState 
{
    public void HandleState(Context context) 
    {
        Debug.Log("Handle State B");
        context.State = new ConcreteStateA();
    }
}
 
public class Context 
{
    public IState State { get; set; }
 
    public Context(IState state) 
    {
        State = state;
    }
 
    public void Request() 
    {
        State.HandleState(this);
    }
}

👉二、访问者模式（Visitor）

介绍： ‌Unity中的访问者模式‌是一种将数据结构和数据操作分离的设计模式，主要用于在不改变数据结构的前提下定义作用于这些元素的新操作。访问者模式的基本思想是针对系统中拥有的某些固定类型的对象结构（元素），在其内部提供一个accept()方法用来接受访问者对象的访问。不同的访问者对同一元素的访问内容不同，因此相同的元素可以产生不同的结果‌。

代码如下：

public interface IVisitor 
{
    void Visit(ConcreteElementA element);
    void Visit(ConcreteElementB element);
}
 
public abstract class Element 
{
    public abstract void Accept(IVisitor visitor);
}
 
public class ConcreteElementA : Element 
{
    public override void Accept(IVisitor visitor) 
    {
        visitor.Visit(this);
    }
 
    public string OperationA() 
    {
        return "Concrete Element A Operation";
    }
}
 
public class ConcreteElementB : Element 
{
    public override void Accept(IVisitor visitor) 
    {
        visitor.Visit(this);
    }
 
    public string OperationB() 
    {
        return "Concrete Element B Operation";
    }
}
 
public class ConcreteVisitor : IVisitor 
{
    public void Visit(ConcreteElementA element) 
    {
        Debug.Log(element.OperationA());
    }
 
    public void Visit(ConcreteElementB element) 
    {
        Debug.Log(element.OperationB());
    }
}
 
public class ObjectStructure 
{
    private List<Element> _elements = new List<Element>();
 
    public void AddElement(Element element) 
    {
        _elements.Add(element);
    }
 
    public void RemoveElement(Element element) 
    {
        _elements.Remove(element);
    }
 
    public void Accept(IVisitor visitor) 
    {
        foreach (Element element in _elements)
        {
            element.Accept(visitor);
        }
    }
}

👉三、观察者模式（Observer）

介绍：观察者模式是软件开发中一种十分常见的设计模式，又被称为发布-订阅模式，属于行为型模式的一种。它定义了一种一对多的依赖关系，让多个观察者对象(Observer)同时监听某一个主题对象(Subject)。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

代码如下：

public interface IObserver 
{
    void Update(ISubject subject);
}
 
public interface ISubject 
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}
 
public abstract class Subject : ISubject 
{
    private List<IObserver> _observers = new List<IObserver>();
 
    public void Attach(IObserver observer) 
    {
        _observers.Add(observer);
    }
 
    public void Detach(IObserver observer) 
    {
        _observers.Remove(observer);
    }
 
    public void Notify() 
    {
        foreach (IObserver observer in _observers)
        {
            observer.Update(this);
        }
    }
}
 
public class ConcreteSubject : Subject 
{
    private string _state;
 
    public string State 
    {
        get 
        {
            return _state;
        }
        set 
        {
            _state = value;
            Notify();
        }
    }
}
 
public class ConcreteObserver : IObserver 
{
    private string _observerState;
 
    public void Update(ISubject subject) 
    {
        if (subject is ConcreteSubject)
        {
            ConcreteSubject concreteSubject = (ConcreteSubject)subject;
            _observerState = concreteSubject.State;
            Debug.Log("Observer State: " + _observerState);
        }
    }
}

👉四、备忘录模式（Memento）

介绍： ‌Unity备忘录模式（Memento Pattern）‌是一种行为设计模式，主要用于在不破坏封装性的情况下捕获对象的内部状态，并在对象之外保存该状态。备忘录模式允许对象在需要时恢复到之前的状态，而不暴露对象的实现细节‌。

代码如下：

public class Memento 
{
    public int Level { get; private set; }
    public int Score { get; private set; }
 
    public Memento(int level, int score) 
    {
        Level = level;
        Score = score;
    }
}
 
public class Originator 
{
    public int Level { get; set; }
    public int Score { get; set; }
 
    public Memento Save() 
    {
        return new Memento(Level, Score);
    }
 
    public void Load(Memento memento) 
    {
        Level = memento.Level;
        Score = memento.Score;
    }
}
 
public class Caretaker 
{
    private Dictionary<string, Memento> _mementos = new Dictionary<string, Memento>();
 
    public void SaveState(string savepoint, Memento memento) 
    {
        _mementos.Add(savepoint, memento);
    }
 
    public Memento LoadState(string savepoint) 
    {
        if (!_mementos.ContainsKey(savepoint))
        {
            return null;
        }
 
        Memento memento = _mementos[savepoint];
        _mementos.Remove(savepoint);
        return memento;
    }
}

👉五、中介者模式（Mediator）

介绍： ‌Unity中介者模式‌是一种行为型设计模式，主要用于减少对象之间的直接交互，通过引入一个中介者对象来封装一组对象的交互行为，从而降低它们之间的耦合度，并简化彼此之间的通信过程‌。

中介者模式定义了一个中介者对象，该对象封装了一组对象的交互。通过中介者，对象可以发送和接收消息，而不需要直接相互引用，从而减少了它们之间的耦合度。这种模式特别适用于复杂系统中，当多个对象需要频繁交互且直接通信会导致系统难以维护和扩展时‌。

代码如下：

public abstract class Colleague 
{
    protected IMediator _mediator;
 
    public Colleague(IMediator mediator) 
    {
        _mediator = mediator;
    }
 
    public abstract void Send(string message);
    public abstract void Receive(string message);
}
 
public interface IMediator 
{
    void AddColleague(Colleague colleague);
    void SendMessage(Colleague sender, string message);
}
 
public class ConcreteColleagueA : Colleague 
{
    public ConcreteColleagueA(IMediator mediator) : base(mediator) 
    {
    }
 
    public override void Send(string message) 
    {
        _mediator.SendMessage(this, message);
    }
 
    public override void Receive(string message) 
    {
        Debug.Log("Concrete Colleague A received message: " + message);
    }
}
 
public class ConcreteColleagueB : Colleague 
{
    public ConcreteColleagueB(IMediator mediator) : base(mediator) 
    {
    }
 
    public override void Send(string message) 
    {
        _mediator.SendMessage(this, message);
    }
 
    public override void Receive(string message) 
    {
        Debug.Log("Concrete Colleague B received message: " + message);
    }
}
 
public class ConcreteMediator : IMediator 
{
    private List<Colleague> _colleagues = new List<Colleague>();
 
    public void AddColleague(Colleague colleague) 
    {
        _colleagues.Add(colleague);
    }
 
    public void SendMessage(Colleague sender, string message) 
    {
        foreach (Colleague colleague in _colleagues)
        {
            if (colleague != sender)
            {
                colleague.Receive(message);
            }
        }
    }
}