Unity解耦合-事件的监听与广播系统

最新推荐文章于 2026-03-08 00:07:40 发布
转载 最新推荐文章于 2026-03-08 00:07:40 发布 · 1.2k 阅读 · 13 ·
本内容遵循CC 4.0 BY-SA版权协议
原文链接：http://www.sikiedu.com/my/course/304/summary
标签
#unity3d #c#
这篇博客介绍了如何在Unity中通过创建委托和事件中心类来实现代码的解耦合。事件中心类(EventCenter)管理事件监听的添加、移除及广播，使用不同参数数量的回调方法，确保了各组件间的独立性。通过添加和移除监听，以及无参数到五参数的广播功能，实现了灵活的消息传递。在测试部分，展示了如何在不同场景下订阅和触发事件，以展示系统的有效性。

Unity解耦合-事件的监听与广播系统

目的

解决代码之间耦合性问题

解决方法

利用委托封装事件方法，然后利用广播和监听事件来实现解耦。
优点：解决代码和代码之间的耦合性，每个脚本只需要关心自己要干的事情，不需要和外界进行联系。
缺点：添加监听时泛型的类型问题，必须明确参数的顺序，不可以出错，如果出错回报错。

  1. 委托脚本
    CallBack.cs
//委托类,自己进行委托封装，可以添加多个参数
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);
  1. 事件处理中心类
    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>();

    #region 脚本精简，将重复性脚本提取出来
    /// <summary>
    /// 添加监听
    /// </summary>
    private static void OnListenerAdding(EventType eventType, Delegate callBack)
    {
        //判断事件码是否存在，如果不存在就添加
        if (!m_EventTable.ContainsKey(eventType))
        {
            m_EventTable.Add(eventType, null);
        }
        //拿到m_EventTable所对应的委托
        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()));
        }
    }

    /// <summary>
    /// 移除监听前
    /// </summary>
    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));
        }
    }

    /// <summary>
    /// 移除监听后
    /// </summary>
    private static void OnListenerRemoved(EventType eventType)
    {
        //判断当前事件码对应的委托是否为空，为空的话事件码无用，移除事件码
        if (m_EventTable[eventType] == null)
        {
            m_EventTable.Remove(eventType);
        }
    }
    #endregion

    /// <summary>
    /// 无参的添加监听
    /// </summary>
    public static void AddListener(EventType eventType, CallBack callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack)m_EventTable[eventType] + callBack;
    }

    /// <summary>
    /// 单个参数的监听
    /// </summary>
    public static void AddListener<T>(EventType eventType, CallBack<T> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] + callBack;
    }

    /// <summary>
    /// 两个参数的监听
    /// </summary>
    public static void AddListener<T, X>(EventType eventType, CallBack<T, X> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X>)m_EventTable[eventType] + callBack;
    }

    /// <summary>
    /// 三个参数的监听
    /// </summary>
    public static void AddListener<T, X, Y>(EventType eventType, CallBack<T, X, Y> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y>)m_EventTable[eventType] + callBack;
    }

    /// <summary>
    /// 四个参数的监听
    /// </summary>
    public static void AddListener<T, X, Y, Z>(EventType eventType, CallBack<T, X, Y, Z> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y, Z>)m_EventTable[eventType] + callBack;
    }

    /// <summary>
    /// 五个参数的监听
    /// </summary>
    public static void AddListener<T, X, Y, Z, W>(EventType eventType, CallBack<T, X, Y, Z, W> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y, Z, W>)m_EventTable[eventType] + callBack;
    }

    /// <summary>
    /// 无参的移除监听
    /// </summary>
    public static void RemoveListener(EventType eventType, CallBack callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    /// <summary>
    /// 一个参数的移除监听
    /// </summary>
    public static void RemoveListener<T>(EventType eventType, CallBack<T> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    /// <summary>
    /// 两个参数的移除监听
    /// </summary>
    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);
    }

    /// <summary>
    /// 三个参数的移除监听
    /// </summary>
    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);
    }

    /// <summary>
    /// 四个参数的移除监听
    /// </summary>
    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);
    }

    /// <summary>
    /// 无个参数的移除监听
    /// </summary>
    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);
    }

    /// <summary>
    /// 无参广播
    /// </summary>
    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));
            }
        }
    }

    /// <summary>
    /// 一个参数的广播
    /// </summary>
    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));
            }
        }
    }

    // <summary>
    /// 两个参数的广播
    /// </summary>
    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));
            }
        }
    }

    // <summary>
    /// 三个参数的广播
    /// </summary>
    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));
            }
        }
    }

    // <summary>
    /// 四个参数的广播
    /// </summary>
    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));
            }
        }
    }

    // <summary>
    /// 五个参数的广播
    /// </summary>
    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));
            }
        }
    }
}
  1. 事件码枚举类
    分别对应无参数、1参数、2参数、3参数、4参数、5参数
    EventType.cs
public enum EventType
{
   ShowText0,
   ShowText1,
   ShowText2,
   ShowText3,
   ShowText4,
   ShowText5,
}

测试

共有两个类用于测试
ShowText .cs

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

public class ShowText : MonoBehaviour
{
    private void Awake()
    {
        gameObject.SetActive(false);
        EventCenter.AddListener(EventType.ShowText0, Show0);
        EventCenter.AddListener<string>(EventType.ShowText1, Show1);
        EventCenter.AddListener<string, float>(EventType.ShowText2, Show2);
        EventCenter.AddListener<string, float, int>(EventType.ShowText3, Show3);
        EventCenter.AddListener<string, float, int, string>(EventType.ShowText4, Show4);
        EventCenter.AddListener<string, float, int, string, int>(EventType.ShowText5, Show5);
    }

    private void OnDestroy()
    {
        EventCenter.RemoveListener(EventType.ShowText0, Show0);
        EventCenter.RemoveListener<string>(EventType.ShowText1, Show1);
        EventCenter.RemoveListener<string, float>(EventType.ShowText2, Show2);
        EventCenter.RemoveListener<string, float, int>(EventType.ShowText3, Show3);
        EventCenter.RemoveListener<string, float, int, string>(EventType.ShowText4, Show4);
        EventCenter.RemoveListener<string, float, int, string, int>(EventType.ShowText5, Show5);
    }

    public void Show0()
    {
        gameObject.SetActive(true);
    }

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

    public void Show2(string str, float a)
    {
        gameObject.SetActive(true);
        GetComponent<Text>().text = str + a;
    }

    public void Show3(string str, float a, int b)
    {
        gameObject.SetActive(true);
        GetComponent<Text>().text = str + a + b;
    }

    public void Show4(string str, float a, int b, string str2)
    {
        gameObject.SetActive(true);
        GetComponent<Text>().text = str + a + b + str2;
    }

    public void Show5(string str, float a, int b, string str2, int c)
    {
        gameObject.SetActive(true);
        GetComponent<Text>().text = str + a + b + str2 + c;
    }
}

BtnClick.cs

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

public class BtnClick : MonoBehaviour
{
    private Button noParameter;
    private Button oneParameter;
    private Button twoParameter;
    private Button threeParameter;
    private Button fourParameter;
    private Button fiveParameter;
    private void Awake()
    {
        noParameter = transform.Find("NoParameter").GetComponent<Button>();
        oneParameter = transform.Find("OneParameter ").GetComponent<Button>();
        twoParameter = transform.Find("TwoParameter").GetComponent<Button>();
        threeParameter = transform.Find("ThreeParameter").GetComponent<Button>();
        fourParameter = transform.Find("FourParameter").GetComponent<Button>();
        fiveParameter = transform.Find("FiveParameter").GetComponent<Button>();
    }

    private void Start()
    {
        noParameter.onClick.AddListener(()=>
        {
            EventCenter.Broadcast(EventType.ShowText0);
        });

        oneParameter.onClick.AddListener(() =>
        {
            EventCenter.Broadcast(EventType.ShowText1, "你好1");
        });

        twoParameter.onClick.AddListener(() =>
        {
            EventCenter.Broadcast(EventType.ShowText2, "你好1", 2.0f);
        });

        threeParameter.onClick.AddListener(() =>
        {
            EventCenter.Broadcast(EventType.ShowText3, "你好1", 2.0f, 3);
        });

        fourParameter.onClick.AddListener(() =>
        {
            EventCenter.Broadcast(EventType.ShowText4, "你好1", 2.0f, 3, "吗？4");
        });

        fiveParameter.onClick.AddListener(() =>
        {
            EventCenter.Broadcast(EventType.ShowText5, "你好1", 2.0f, 3, "吗？4", 5);
        });
    }
}

脚本挂载与界面如下图所示，其中ShowText .cs挂在Text上，BtnClick .cs挂在Buttons上
在这里插入图片描述

unity c# 事件监听与广播
main_hello的博客
04-06 542
事件监听与广播
Unity高度解耦和（事件的监听与广播系统）学习记录
qq_59479318的博客
01-07 1227
.原理：使用委托，事件的监听与广播调用一个委托 2.如何使用事件的广播与监听系统 CallBack类：定义委托的类，定义的委托分别为无参的，一个参数，两个参数，三个参数，四个参数，五个参数的类。这个类相当于c#提供的Action类
【Unity每篇一个知识点】：事件广播系统
weixin_46259189的博客
08-22 1175
事件广播系统
Unity解耦合--事件的监听和广播
qq_62947569的博客
05-07 1054
unity的监听事件和广播系统
Unity广播快速学习
yaolinjun1的博客
09-15 1024
Unity实现广播进制方法之一的快速教程
阿木自学unity系列--第三篇Unity高度解耦和-事件的监听与广播系统----2019.1.31
weixin_39315127的博客
01-31 721
本来昨天想开始学Carson老师最新的初级课程–幻径小游戏的制作的，可是听了前两个视频才知道有先修课程哈哈哈哈，所以屁颠屁颠的跑去学了今天要记录的这门课–Unity高度解耦和，关于事件的监听与广播系统，这门课程主要就是将怎么用代码实现较方便的事件监听以及广播，需要了解的同学们可以往下看啦。 课程名称：Unity高度解耦和 - 事件的监听与广播系统（Unity2018.1.0） 我的Unity版本：...
c# 事件监听与广播系统
star__119的博客
12-21 3070
最近看了SIKI学院一个课程，讲得很简单明了，所以就自己写了一下发上来 课程：http://www.sikiedu.com/my/course/304 1. 消息类型（EventType） public enum EventType { ShowText } 2. 委托，回调函数（CallBack） 当然也可以直接使用Action，Func public delegate void ...
Unity--高度解耦和(事件的监听与广播系统)
weixin_51002263的博客
04-22 625
在Unity中我们通常要通过鼠标注册事件来完成当我们点击按钮触发某一效果，或许我们可以通过鼠标注册来完成，或者通过从其他脚本中通过单例模型来解决但这样可能会产生一些不必要的影响，所以我们可以利用事件的监听以及广播来完成对此鼠标注册的替换。 例子: 如上图所示，当我们点击场景中的按钮时我们可以将文本New Text替换为你好。(未使用鼠标注册事件以及单例模型)。 1.无参类型 EventCenter脚本 作用:用于监听，广播，移除监听的脚本。 首先我们需要定义一个字典用于储存事件码，以及委托。 接着定义添
Unity事件的高级监听与广播系统
明明明的博客
03-10 1174
1.创建一个单例模式的基类：BaseManager.cs using System.Collections; using System.Collections.Generic; using UnityEngine; /// <summary> /// 泛型基类:用于创建单例模式 /// </summary> /// <typeparam name="T">类型</typeparam> public class BaseManager <T&.
事件监听与广播系统
qq_45901693的博客
05-21 1260
Unity的事件监听与广播系统
Unity C# 事件监听和广播
podaosanshiliu的博客
07-07 3651
通过事件监听和广播实现Unity上的一个小功能：按钮点击显示文本和内容。通过此功能讲解，展示事件监听和广播的使用
Unity 事件监听与广播(高度解耦合，观察者模式)
明明明的博客
06-28 1857
unity 事件的监听与广播、解耦合、观察者模式
unity发送自定义广播传参（参数可以是布尔值、string、double数组等数据类型）、动态注册安卓广播、接收安卓静态广播和动态广播
yhx956058885的博客
12-10 1842
自定义的广播可以收缩到，但是系统广播接收不到； 如果静态广播接收不到，有可能是需要动态注册广播 Java部分 build.gradle修改为库 修改为library；注释掉ID；没有的都删掉 配置AndroidManifest java代码 package com.unity3d.player; import android.content.BroadcastReceiver; import android.content.Context; import android.conte
如何在Unity中给游戏添加热更新与广播公告
qq_54140134的博客
04-30 789
之前初中的时候有通过iapp写过一些软件 那会也是使用蓝奏云进行更新与进行公告的 那会蓝奏云也提供下载API 不需要验证机器人便能够可以直接下载 然后忽然想到为什么不可以使用蓝奏云给自己的在unity中写的游戏添加自动更新和公告呢 然后就花掉了一上午时间成功实现了这个功能 那么下面开始我们的教程(⁠｡⁠•̀⁠ᴗ⁠-⁠)⁠✧。首先需要注册一个蓝奏云的账号 并在其中添加一个你的游戏名的文件夹 在其中填写你的版本号与简介 我是比较直接酱紫。
Unity（二）Camera Path Animator插件中的事件调度和广播机制Broad Cast
LinZhonglong的博客
11-14 4325
PS:以前只是简单使用该插件，现在发现还是它好用。相比Itween  Path、DoTween前两者都是可视化编辑，方便了和策划的分工配合。不过Itween Path在制作循环圈形轨迹的时候首末点的衔接会使得Target跳跃和停顿，这点很不爽。而Camera Path在衔接上几乎没有卡跃，挺好。DoTween在制作动画方便还是很好使用的。 Unity里的广播机制BroadCast，意思就是群发消
Unity调用安卓接口实现自定义广播监听
qq_40364278的博客
08-25 1437
在进行某硬件开发时，根据厂商规定的硬件功能接口触发广播，在Android Studio中封装广播接收器和回调接口，导出AAR包供Unity调用，Unity端通过C#脚本调用AAR内部封装的接口。
深入解析UnityEvent：Unity中的高效事件监听与广播机制
最新发布
weixin_29011667的博客
03-08 211
本文深入解析了Unity中的UnityEvent事件系统，详细阐述了其作为高效事件监听与广播机制的工作原理。通过对比传统强耦合代码的弊端，结合实战案例演示了如何利用UnityEvent实现模块间解耦，提升代码可维护性。文章还涵盖了从基础无参数事件到带参数事件的应用，并探讨了使用ScriptableObject构建全局事件中心等高级架构，帮助开发者掌握这一核心通信工具。
Unity中事件订阅
m0_66744030的博客
11-23 509
无参数的事件委托，继承ScriptableObject。使用方法，列如主角触发机关，会发生的一系列事情。这里的主角碰撞机关，播放广播，通知所有订阅者。其他物体注册订阅，根据广播做出反应。可以根据情况使用委托。
Unity3D 发送广播与消息
health的博客
08-08 4401
一个对象可以绑定多个脚本，实现这些脚本之间的交互就可以使用广播机制。 游戏对象之间发送的广播与消息分为三种：第一种向子对象发送，将发送至该对象的同辈对象或者子孙对象中；第二种为给自己发送，发送至自身对象；第三种为向父对象发送，发送至该对象的同辈或者父辈对象中。 发送消息的方法都有两个参数：第一个参数为接受消息的方法名称，第二个参数为一个 object 对象，可将任意类型作为参数附加在消息中。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值