Unity高度解耦和 - 事件的监听与广播系统（Unity2018）

最新推荐文章于 2023-05-07 18:00:01 发布
原创 最新推荐文章于 2023-05-07 18:00:01 发布 · 725 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入解析Unity中的事件系统，涵盖事件监听与广播的实现机制，包括无参、单参数及多参数事件的处理方法。通过具体示例展示了如何在游戏开发中使用事件系统，如按钮点击触发文本显示等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

创建添加监听的方法

CallBcak.cs

public delegate void CallBack();
public delegate void CallBack<T>(T arg);

EventType.cs

public enum EventType
{

}

EventCenter.cs

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

public class EventCenter
{
    private static Dictionary<EventType, Delegate> m_EventTable = new Dictionary<EventType, Delegate>();

    //no parameters
    public static void AddListener(EventType eventType,CallBack callBack)
    {
        if(!m_EventTable.ContainsKey(eventType))//如果我们的时间表里不包含事件码
        {
            m_EventTable.Add(eventType, null);
        }
        Delegate d = m_EventTable[eventType];
        if(d!=null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试为时间{0}添加不同类型的委托，当前事件所对应的委托是{1},要添加的委托的类型为{2}", eventType, d.GetType(), callBack.GetType()));
        }
        m_EventTable[eventType] = (CallBack)m_EventTable[eventType] + callBack;
    }
}

移除监听和广播

    //no parameters
    public static void RemoveListener(EventType eventType, CallBack callBack)
    {
        if (m_EventTable.ContainsKey(eventType))
        {
            Delegate d = m_EventTable[eventType];
            if(d == null)
            {
                throw new Exception(string.Format("移除监听错误：事件{0}没有对应的委托", eventType));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除监听错误：尝试为事件{0}移除不同类型的委托，当前类型的委托类型为{1},要移除的委托类型为{2}", eventType,d.GetType(),callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除监听错误：没有时间码{0}", eventType));
        }
        m_EventTable[eventType] = (CallBack)m_EventTable[eventType] - callBack;
    }

    //no parameters
    public static void Broadcast(EventType eventType)
    {
        Delegate d;
        if(m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack callBack = d as CallBack;
            if(callBack != null)
            {
                callBack();
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }

创建测试的脚本，测试无参的监听与广播

首先创建一个Text，给它身上挂一个ShowText脚本

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

public class ShowText : MonoBehaviour
{
    private void Awake()
    {
        gameObject.SetActive(false);
        EventCenter.AddListener(EventType.ShowText, Show);
    }

    private void OnDestroy()
    {
        EventCenter.RemoveListener(EventType.ShowText, Show);
    }

    private void Show()
    {
        gameObject.SetActive(true);
    }
}

然后创建一个按钮，挂一个BtnClick脚本

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

public class BtnClick : MonoBehaviour
{
    private void Awake()
    {
        GetComponent<Button>().onClick.AddListener(() =>
        {
            EventCenter.Broadcast(EventType.ShowText);

        });
    }
}

实现带有一个参数的监听和广播的方法

    //Single Parameter
    public static void AddListener<T>(EventType eventType, CallBack<T> callBack)
    {
        if (!m_EventTable.ContainsKey(eventType))//如果我们的时间表里不包含事件码
        {
            m_EventTable.Add(eventType, null);
        }
        Delegate d = m_EventTable[eventType];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试为时间{0}添加不同类型的委托，当前事件所对应的委托是{1},要添加的委托的类型为{2}", eventType, d.GetType(), callBack.GetType()));
        }
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] + callBack;
    }


    //Single parameter
    public static void RemoveListener<T>(EventType eventType, CallBack<T> callBack)
    {
        if (m_EventTable.ContainsKey(eventType))
        {
            Delegate d = m_EventTable[eventType];
            if (d == null)
            {
                throw new Exception(string.Format("移除监听错误：事件{0}没有对应的委托", eventType));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除监听错误：尝试为事件{0}移除不同类型的委托，当前类型的委托类型为{1},要移除的委托类型为{2}", eventType, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除监听错误：没有时间码{0}", eventType));
        }
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] - callBack;
    }

    //Single parameter
    public static void Broadcast<T>(EventType eventType, T arg)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T> callBack = d as CallBack<T>;
            if (callBack != null)
            {
                callBack(arg);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }

在ShowText中也要进行修改

    private void Awake()
    {
        gameObject.SetActive(false);
        EventCenter.AddListener<string>(EventType.ShowText, Show);
        EventCenter.AddListener(EventType.ShowText, Show2);
    }

    private void OnDestroy()
    {
        EventCenter.RemoveListener<string>(EventType.ShowText, Show);
        EventCenter.RemoveListener(EventType.ShowText, Show2);
    }

    private void Show(string str)
    {
        gameObject.SetActive(true);
        GetComponent<Text>().text = str;
    }

实现多个参数的监听和广播

CallBack里面添加多参数

public delegate void CallBack();
public delegate void CallBack<T>(T arg);
public delegate void CallBack<T,X>(T arg1,X arg2);
public delegate void CallBack<T, X,Y>(T arg1, X arg2,Y arg3);
public delegate void CallBack<T, X, Y, Z>(T arg1, X arg2, Y arg3, Z arg4);
public delegate void CallBack<T, X, Y, Z, W>(T arg1, X arg2, Y arg3, Z arg4, W arg5);

添加EventSystem里面的多个参数的方法

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

public class EventCenter
{
    private static Dictionary<EventType, Delegate> m_EventTable = new Dictionary<EventType, Delegate>();

    #region AddListener
    private static void OnListererAdding(EventType eventType,Delegate callBack)
    {
        if (!m_EventTable.ContainsKey(eventType))//如果我们的时间表里不包含事件码
        {
            m_EventTable.Add(eventType, null);
        }
        Delegate d = m_EventTable[eventType];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试为时间{0}添加不同类型的委托，当前事件所对应的委托是{1},要添加的委托的类型为{2}", eventType, d.GetType(), callBack.GetType()));
        }
    }

    //no parameters
    public static void AddListener(EventType eventType,CallBack callBack)
    {
        OnListererAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack)m_EventTable[eventType] + callBack;
    }

    //Single Parameter
    public static void AddListener<T>(EventType eventType, CallBack<T> callBack)
    {
        OnListererAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] + callBack;
    }

    //Two Parameters
    public static void AddListener<T,X>(EventType eventType, CallBack<T,X> callBack)
    {
        OnListererAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T,X>)m_EventTable[eventType] + callBack;
    }

    //Three Parameters
    public static void AddListener<T, X,Y>(EventType eventType, CallBack<T, X, Y> callBack)
    {
        OnListererAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y>)m_EventTable[eventType] + callBack;
    }

    //Four Parameters
    public static void AddListener<T, X,Y,Z>(EventType eventType, CallBack<T, X, Y, Z> callBack)
    {
        OnListererAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y, Z>)m_EventTable[eventType] + callBack;
    }

    //Five Parameters
    public static void AddListener<T, X, Y, Z,W>(EventType eventType, CallBack<T, X, Y, Z, W> callBack)
    {
        OnListererAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y, Z, W>)m_EventTable[eventType] + callBack;
    }

    #endregion

    #region RemoveListener
    private static void OnListenerRemoving(EventType eventType, Delegate callBack)
    {
        if (m_EventTable.ContainsKey(eventType))
        {
            Delegate d = m_EventTable[eventType];
            if (d == null)
            {
                throw new Exception(string.Format("移除监听错误：事件{0}没有对应的委托", eventType));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除监听错误：尝试为事件{0}移除不同类型的委托，当前类型的委托类型为{1},要移除的委托类型为{2}", eventType, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除监听错误：没有时间码{0}", eventType));
        }
    }

    private static void OnListenerRemoved(EventType eventType)
    {
        if (m_EventTable[eventType] == null)
        {
            m_EventTable.Remove(eventType);
        }
    }

    //no parameters
    public static void RemoveListener(EventType eventType, CallBack callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
 
    //Single parameter
    public static void RemoveListener<T>(EventType eventType, CallBack<T> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    //Two parameters
    public static void RemoveListener<T,X>(EventType eventType, CallBack<T,X> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T,X>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    //Three parameters
    public static void RemoveListener<T, X,Y>(EventType eventType, CallBack<T, X, Y> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    //Four parameters
    public static void RemoveListener<T, X, Y,Z>(EventType eventType, CallBack<T, X, Y, Z> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y, Z>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    //Five parameters
    public static void RemoveListener<T, X, Y, Z,W>(EventType eventType, CallBack<T, X, Y, Z, W> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack< T, X, Y, Z, W>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    #endregion

    #region Boradcast
    //no parameters
    public static void Broadcast(EventType eventType)
    {
        Delegate d;
        if(m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack callBack = d as CallBack;
            if(callBack != null)
            {
                callBack();
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }

    //Single parameter
    public static void Broadcast<T>(EventType eventType, T arg)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T> callBack = d as CallBack<T>;
            if (callBack != null)
            {
                callBack(arg);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }

    //Two parameter
    public static void Broadcast<T,X>(EventType eventType, T arg1, X arg2)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T,X> callBack = d as CallBack<T,X>;
            if (callBack != null)
            {
                callBack(arg1,arg2);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }

    //Three parameters
    public static void Broadcast<T, X,Y>(EventType eventType, T arg1, X arg2,Y arg3)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T, X, Y> callBack = d as CallBack<T, X, Y>;
            if (callBack != null)
            {
                callBack(arg1, arg2,arg3);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }

    //Four parameters
    public static void Broadcast<T, X, Y,Z>(EventType eventType, T arg1, X arg2, Y arg3,Z arg4)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T, X, Y, Z> callBack = d as CallBack<T, X, Y, Z>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3,arg4);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }


    //Five parameters
    public static void Broadcast<T, X, Y, Z,W>(EventType eventType, T arg1, X arg2, Y arg3, Z arg4,W arg5)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T, X, Y, Z, W> callBack = d as CallBack<T, X, Y, Z,W>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3, arg4,arg5);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }
    #endregion


}

 

Unity--高度解耦和(事件的监听与广播系统)
weixin_51002263的博客
04-22 591
在Unity中我们通常要通过鼠标注册事件来完成当我们点击按钮触发某一效果，或许我们可以通过鼠标注册来完成，或者通过从其他脚本中通过单例模型来解决但这样可能会产生一些不必要的影响，所以我们可以利用事件的监听以及广播来完成对此鼠标注册的替换。 例子: 如上图所示，当我们点击场景中的按钮时我们可以将文本New Text替换为你好。(未使用鼠标注册事件以及单例模型)。 1.无参类型 EventCenter脚本 作用:用于监听，广播，移除监听的脚本。 首先我们需要定义一个字典用于储存事件码，以及委托。 接着定义添
阿木自学unity系列--第三篇Unity高度解耦和-事件的监听与广播系统----2019.1.31
weixin_39315127的博客
01-31 656
本来昨天想开始学Carson老师最新的初级课程–幻径小游戏的制作的，可是听了前两个视频才知道有先修课程哈哈哈哈，所以屁颠屁颠的跑去学了今天要记录的这门课–Unity高度解耦和，关于事件的监听与广播系统，这门课程主要就是将怎么用代码实现较方便的事件监听以及广播，需要了解的同学们可以往下看啦。 课程名称：Unity高度解耦和 - 事件的监听与广播系统（Unity2018.1.0） 我的Unity版本：...
Unity---高度解耦和
ddef54114650的博客
04-28 637
介绍 先举一个简单的例子： 在UGUI中新建一个Button和Text，要求实现点击Button改变Text中的文字。 我的第一反应就是在Button上添加一个脚本，获取点击事件来改变Text的内容。 或者在Text和Button上都添加一个脚本，Text设置为单例模式，Button点击事件触发Text中的改变文字方法。 可是这两种方法要不就是关联度太高协作开发时很不好，要不在大项目中用...
Unity事件监听广播（泛型）
qq_36429060的博客
04-29 442
在每个显示层利用字典进行类型和委托绑定，在控制层利用类型进行调用委托达到“广播”的方式 泛型基本应用分为泛型类和泛型方法 泛型方法 string a<T>(T a, T b) { a+b; } 调用：a(11,12); / a("11","23") 泛型类 Class A<T> { } 调用：Class a=new A<int/任意...
Unity：简易事件监听与广播系统
不二
03-31 1418
一个非常简单的事件监听与广播系统，功能也比较简单，但是还是挺实用的，可以用来解耦 实现功能： 添加事件监听 移除事件监听 广播消息 消息类型枚举： /// <summary> /// 事件类型枚举 /// </summary> public enum EventType { ShowText, HideText } 消息中心： usin...
SIki学院的高度解耦和：事件的监听与广播系统（Unity2018.1.0）资料
01-26
本资料主要探讨了如何在Unity2018.1.0版本中实现事件的监听与广播系统，以达到这一目标。以下是关于这个主题的详细知识点： 1. **事件驱动编程**： 事件驱动编程是一种编程范式，它依赖于事件处理器来响应特定的...
高度解耦和：事件的监听与广播系统（Unity2018.1.0）资料
01-26
在Unity游戏开发中，事件监听和广播系统是实现组件间通信和解耦合的重要机制。本资料主要聚焦于Unity 2018.1.0版本中的事件处理系统，通过一系列视频教程，深入讲解如何有效地利用这个系统提高代码的可维护性和灵活...
Unity高度解耦和（事件的监听与广播系统）学习记录
qq_59479318的博客
01-07 1157
.原理：使用委托，事件的监听与广播调用一个委托 2.如何使用事件的广播与监听系统 CallBack类：定义委托的类，定义的委托分别为无参的，一个参数，两个参数，三个参数，四个参数，五个参数的类。这个类相当于c#提供的Action类
关于Unity中的高度解耦和
qq_42855293的博客
02-04 969
主要是利用委托及事件的监听和广播来达到代码的高度解耦和 以Button的点击事件为例进行简单的探讨： 代码很简单只有短短的几十行代码（先上代码然后根据代码来简单说明）完整的工程可去本人资源下载里面去下载 CallBack：(这个里面封装的是委托事件，跟Unity给我们的预定义委托Action是一样的，你也可以直接使用Action，不过这里自己封装的委托事件的参数的多少你可以自己控制) public...
Unity事件的高级监听与广播系统
qq_45047433的博客
05-25 563
在大型的项目中，一般需要大量的事件来实现我们的功能，如果代码之间的耦合度高，相应的扩展性就会变得差一些。要改变一些要改变的代码时就要去找相应的引用，这会非常麻烦。降低代码的耦合度，可以大大提高项目的扩展性，给我们带来了方便。 基本思路是：每一个事件码对应一种事件，通过广播事件码，来触发相应的事件。 首先我们需要建立三个脚本来分别存放和处理不同方法和逻辑 1.创建一个单例模式的基类：BaseManager.cs using System.Collections; using Syst...
[EntLib]微软企业库5 0 学习之路 第十步 使用Unity解耦你的系统 PART2 了解Unity的使用方法（3）
07-28
[EntLib]微软企业库5 0 学习之路 第十步 使用Unity解耦你的系统 PART2 了解Unity的使用方法（3）
unity通过全局事件对项目进行解耦
qq_40629631的博客
11-25 2989
一个类要是想调用另一个类的方法，例如A想调用B的方法。 方式一：引用 最简单的方式是A持有一个B类的引用，即A拥有一个B的成员对象。 方式二：设计模式（中介者模式） 或者A和B同属于一个对象C，通过对象C调用对方（中介者模式），例如QQ群，A和B互相没有对方好友，但是都在一个QQ群C，他们可以在C互相和对方说话。 方式三：静态（通常是单例模式，B是管理类等） 将B中的方法设置为静态方法。 但是项目中，有N多类，A和B完全没有关系，不宜有对方的引用，并且都不是工具类，不宜设置为静态方法。那么此时，我们该如何让
Unity解耦合-事件的监听与广播系统
FutureDr的博客
02-04 1190
Unity解耦合-事件的监听与广播系统目的解决方法测试 目的 解决代码之间耦合性问题 解决方法 利用委托封装事件方法，然后利用广播和监听事件来实现解耦 委托脚本 CallBack.cs //委托类,自己进行委托封装，可以添加多个参数 public delegate void CallBack(); public delegate void CallBack<T>(T arg); public delegate void CallBack<T, X>(T arg1, X arg2)
unity事件系统（广播系统）的学习笔记
weixin_45072334的博客
05-25 1787
最近在研究广播系统，写下来记录一下，好记性不如烂笔头。简单写了无参数广播事件系统 using System; using System.Collections; using System.Collections.Generic; using UnityEngine; public delegate void CallBack();//需要有参数的直接在这加上需要的参数就可以实现参数广播。 public enum EventTypee//广播事件 { test } public class Eve
Unity解耦合--事件的监听和广播
qq_62947569的博客
05-07 963
unity的监听事件和广播系统
Unity 解耦 一通过委托解耦
qq_39779932的博客
11-24 1077
Unity开发过程中，不可避免的存在的耦合的问题，特别是当处理的对象特别多的时候，更容易耦合。 开发中可以通过运用委托来进行一定的解耦，比如下面的的示例。 一个简单的场景，按下1键时亮起灯1，按下2键时亮起2灯，按下3键时亮起3灯，每次亮灯时都要关闭其他的灯。 结合委托，代码如下 灯1代码如下： public class LightController1 : MonoBehavio...
Unity(十二) MVC中V与C的解耦
LinZhonglong的博客
03-05 413
using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; //View层 Button public class BaseSkill : MonoBehaviour { public string mName; public float...
Unity 游戏开发中的代码解耦原则
创小董
12-08 492
什么是耦合、内聚？ 个人理解:耦合就是对象、类的双向引用、循环引用，内聚就是同样类型的代码放在一起。 对象之间的交互方式 拿到对象的引用直接调用对象的方法 采用委托或者事件调用 调用和执行分开 采用命令模式 代码解耦方法： 1.父亲可以直接拿到孩子的引用 调用孩子的方法 2.孩子调用父亲的方法使用委托或者时间 3.数据驱动 数据驱动就是当Model层数据发生变化时 驱动各相关模块的更新 具体做法是在各模块增加对数据变化的监听(通过委托或者事件的方式) 当数据变化时在对应的监听事件做出相应
Unity 事件管理器
xinzhilinger的博客
03-18 2446
对于继承于MonoBehaviour的脚本： using System.Collections; using System.Collections.Generic; using UnityEngine; public class MainTest : MonoBehaviour { //声明单例模式 static MainTest _instance; private void Awake() { if (_instance != null)
Unity事件监听与广播系统解耦技术资料
资源摘要信息:"SIki学院的'高度解耦和：事件的监听与广播系统（Unity2018.1.0）资料'是一套关于如何在Unity游戏引擎中实现高度解耦的事件监听和广播系统的教程或示例代码。在Unity中，事件监听和广播系统是一个非常...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值