Unity 观察者模式(实例详解)

这篇具有很好参考价值的文章主要介绍了Unity 观察者模式(实例详解)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

简介

在Unity中实现观察者模式,我们可以创建一个Subject(目标/主题)类,它负责维护订阅者列表,并且当其状态改变时通知所有观察者。下面通过5个代码示例来详细展示如何在Unity C#脚本中应用观察者模式:

示例1 - 简单的文本更新通知

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

// 观察者接口
public interface IObserver
{
    void OnUpdate(string message);
}

// 被观察者接口
public interface IObservable
{
    void Register(IObserver observer);
    void Remove(IObserver observer);
    void NotifyObservers(string message);
}

// 具体的被观察者类
public class TextDisplay : MonoBehaviour, IObservable
{
    private List<IObserver> observers = new List<IObserver>();

    public void Register(IObserver observer)
    {
        observers.Add(observer);
    }

    public void Remove(IObserver observer)
    {
        observers.Remove(observer);
    }

    public void NotifyObservers(string message)
    {
        foreach (var observer in observers)
        {
            observer.OnUpdate(message);
        }
    }

    // 模拟状态改变
    public void UpdateText(string newText)
    {
        Debug.Log("Text has been updated to: " + newText);
        NotifyObservers(newText);
    }
}

// 具体的观察者类
public class ConsoleLogger : MonoBehaviour, IObserver
{
    public void OnUpdate(string message)
    {
        Debug.Log("Console Logger received update: " + message);
    }
}

// 使用示例
public class GameManager : MonoBehaviour
{
    public TextDisplay display;
    public ConsoleLogger logger;

    void Start()
    {
        display.Register(logger);
        display.UpdateText("Hello, World!");
    }
}

示例2 - 多观察者监听游戏分数变化

public interface IScoreObserver : IObserver
{
    void OnScoreChanged(int newScore);
}

public class ScoreManager : MonoBehaviour, IObservable
{
    private List<IScoreObserver> scoreObservers = new List<IScoreObserver>();

    public void Register(IScoreObserver observer)
    {
        scoreObservers.Add(observer);
    }

    public void Remove(IScoreObserver observer)
    {
        scoreObservers.Remove(observer);
    }

    public void NotifyScoreObservers(int newScore)
    {
        foreach (var observer in scoreObservers)
        {
            observer.OnScoreChanged(newScore);
        }
    }

    public void IncreaseScore(int points)
    {
        int currentScore = GetTotalScore(); // 假设这是一个获取当前分数的方法
        int newScore = currentScore + points;
        SetTotalScore(newScore); // 假设这是一个设置总分数的方法
        NotifyScoreObservers(newScore);
    }
}

public class ScoreUI : MonoBehaviour, IScoreObserver
{
    public void OnScoreChanged(int newScore)
    {
        GetComponent<Text>().text = "Score: " + newScore;
    }
}

public class HighScoreTracker : MonoBehaviour, IScoreObserver
{
    public void OnScoreChanged(int newScore)
    {
        if (newScore > PlayerPrefs.GetInt("HighScore"))
        {
            PlayerPrefs.SetInt("HighScore", newScore);
        }
    }
}

// 使用示例
public class GameInitializer : MonoBehaviour
{
    public ScoreManager scoreManager;
    public ScoreUI scoreUI;
    public HighScoreTracker highScoreTracker;

    void Start()
    {
        scoreManager.Register(scoreUI);
        scoreManager.Register(highScoreTracker);
        // 游戏过程中调用scoreManager.IncreaseScore()增加分数
    }
}

示例3 - 事件系统实现观察者模式

using UnityEngine.Events;

public class SubjectWithEvent : MonoBehaviour
{
    public UnityEvent<string> OnTextUpdated;

    public void UpdateText(string newText)
    {
        Debug.Log("Text has been updated to: " + newText);
        OnTextUpdated.Invoke(newText);
    }
}

public class ObserverUsingEvent : MonoBehaviour
{
    public SubjectWithEvent subject;

    void Start()
    {
        subject.OnTextUpdated.AddListener(OnTextUpdatedHandler);
    }

    void OnDestroy()
    {
        subject.OnTextUpdated.RemoveListener(OnTextUpdatedHandler);
    }

    void OnTextUpdatedHandler(string message)
    {
        Debug.Log("Received text update: " + message);
    }
}

示例4 - 泛型观察者和可序列化的事件系统

[System.Serializable]
public class GenericEvent<T> : UnityEvent<T>
{
}

public class ObservableGeneric<T> : MonoBehaviour
{
    public GenericEvent<T> OnStateChanged;

    public T State { get; private set; }

    public void ChangeState(T newState)
    {
        State = newState;
        OnStateChanged?.Invoke(newState);
    }
}

public class ObserverForGeneric<T> : MonoBehaviour
{
    public ObservableGeneric<T> observable;

    public void Awake()
    {
        observable.OnStateChanged.AddListener(StateChangedHandler);
    }

    public void OnDestroy()
    {
        observable.OnStateChanged.RemoveListener(StateChangedHandler);
    }

    void StateChangedHandler(T newState)
    {
        Debug.Log($"New state received: {newState}");
    }
}

// 使用示例
public class ExampleUsage : MonoBehaviour
{
    public ObservableGeneric<int> healthObservable;
    public ObserverForGeneric<int> healthObserver;

    void Start()
    {
        healthObserver.observable = healthObservable;
    }
}

示例5 - 使用C#委托简化版

public class SimpleObservable
{
    public delegate void MessageEventHandler(string message);

    public event MessageEventHandler OnMessageEvent;

    public void SendMessage(string message)
    {
        OnMessageEvent?.Invoke(message);
    }
}

public class SimpleObserver : MonoBehaviour
{
    public SimpleObservable observable;

    void Start()
    {
        observable.OnMessageEvent += HandleMessageEvent;
    }

    void OnDestroy()
    {
        observable.OnMessageEvent -= HandleMessageEvent;
    }

    void HandleMessageEvent(string message)
    {
        Debug.Log("Received message: " + message);
    }
}

// 使用示例
public class SimpleExample : MonoBehaviour
{
    public SimpleObservable messageSource;
    public SimpleObserver messageRecipient;

    void Start()
    {
        messageRecipient.observable = messageSource;
        messageSource.SendMessage("Hello from the Observable");
    }
}

以上每个示例都展示了观察者模式的基本原理:当被观察者的状态发生改变时,它会通知所有已注册的观察者进行相应的响应或更新操作。

python推荐学习汇总连接:
50个开发必备的Python经典脚本(1-10)

50个开发必备的Python经典脚本(11-20)

50个开发必备的Python经典脚本(21-30)

50个开发必备的Python经典脚本(31-40)

50个开发必备的Python经典脚本(41-50)
————————————————

​最后我们放松一下眼睛
unity实现观察者,unity C#设计模式详解,unity,观察者模式,c#文章来源地址https://www.toymoban.com/news/detail-834248.html

到了这里,关于Unity 观察者模式(实例详解)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Unity实战100例】人物状态栏UI数据刷新—MVC观察者模式

    目录 一.创建Model层数据模型 二.创建View层关联UI组件 三.创建Controller层使得V和M数据关联 源码:

    2024年02月13日
    浏览(30)
  • 用C++11打造智能观察者模式:详解实现步骤完整示例代码

      观察者模式是一种行为设计模式,其中一个对象(主题)维护其依赖对象(观察者)的列表,当主题的状态发生变化时,它通知所有观察者。以下是一个使用C++11实现观察者模式的简单例子: 定义观察者接口(Observer):  创建一个观察者接口,该接口包含观察者需要实现

    2024年01月25日
    浏览(47)
  • 【观察者设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    观察者模式(Observer Pattern)是一种行为型模式。它定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。 观察者模式使用三个类Subject、Observer和Client。Subject对象带有绑定观察者到Client对象和从Client对象解绑观察

    2023年04月21日
    浏览(81)
  • 【设计模式】第十二章:观察者模式详解及应用案例

    【设计模式】七大设计原则 【设计模式】第一章:单例模式 【设计模式】第二章:工厂模式 【设计模式】第三章:建造者模式 【设计模式】第四章:原型模式 【设计模式】第五章:适配器模式 【设计模式】第六章:装饰器模式 【设计模式】第七章:代理模式 【设计模式

    2024年02月13日
    浏览(41)
  • Java设计模式-观察者模式-SpringBoot实现

    项目:https://gitee.com/KakarottoChen/blog-code.git 的:JavaSpringListener Java观察者模式是一种设计模式,用于实现对象之间的一对多依赖关系。在观察者模式中,当一个对象的状态发生变化时,它的所有依赖对象(观察者)都会自动收到通知并进行相应的更新。 观察者模式由以下几个核

    2024年02月08日
    浏览(40)
  • JavaScript 简单实现观察者模式和发布-订阅模式

    大家好,我是南木元元,热衷分享有趣实用的文章。今天来聊聊设计模式中常用的观察者模式和发布-订阅模式。 观察者模式定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都将得到通知。 如何理解这句话呢?来举个生活中的例子

    2024年02月12日
    浏览(106)
  • Go和Java实现观察者模式

    在监控系统中,我们需要采集监控指标的信息,假设当采集的指标信息超过阈值时我们需要对该监控指标持久化到 数据库中并且进行告警。 本文通过指标采集持久化和告警来说明观察者模式的使用,使用Go语言和Java语言实现。 观察者模式是一种行为型设计模式,它定义了一

    2024年02月16日
    浏览(35)
  • 如何用C++11实现观察者模式

    观察者模式是一种设计模式,定义了对象之间的一对多关系。当一个对象状态发生改变时,它的依赖者都会收到通知并自动更新。在C++11中,可以通过以下方式实现观察者模式: 首先,我们需要创建一个观察者接口,其中包含一个更新方法。这个接口可以被多个观察者类实现

    2024年02月15日
    浏览(32)
  • 「观察者(Observer)」设计模式 Swift实现

    观察者设计模式(Observer Pattern)是一种行为型设计模式,它定义了对象之间的一种一对多的依赖关系,使得当一个对象的状态发生变化时,所有依赖于它的对象都会受到通知并自动更新。 在这种模式中,被观察者对象(Subject)存储其观察者对象(Observer)列表,并提供了用

    2024年02月16日
    浏览(39)
  • ts:简单实现 mobx 的观察者模式 observable

    mobx 状态管理器 订阅者: 管理 变化后 回调的函数列表 观察者:将传入的 数据监听 起来,并且在 有变化时 , 执行 订阅者管理的 函数列表

    2024年02月12日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包