Unity EventCenter 消息中心的设计与实现

在开发过程中,想要传递信号和数据,就得在不同模块之间实现通信。直接通过单例调用虽然简单,但会导致代码高度耦合,难以维护。消息中心提供了一种松耦合的通信方式:发布者不需要知道谁接收事件,接收者不需要知道事件来自哪里,由此减少模块间的直接依赖,便于扩展和维护。

架构

cs 复制代码
%% EventCenter 架构图
graph TD
    subgraph 事件中心核心
        A[EventCenter] --> B[ConcurrentDictionary eventKey:callback]
    end

    subgraph 调用接口
        A --> E[添加监听 AddListener]
        A --> F[移除监听 RemoveListener]
        A --> G[同步触发 SyncBroadcast]
        A --> H[异步触发 Broadcast]
    end

    subgraph 线程管理
        G -->|立即执行| J[当前线程]
        H -->|主线程队列延迟| K[主线程]
    end

    subgraph 异常处理
        G --> L[Try-Catch块]
        H --> L
        L --> M[打印错误日志]
        M --> N[继续触发剩余回调]
    end

数据结构

我们需要一个数据结构来存储eventKey与callback的映射关系,可以使用字典。

如果使用Dictionary,当多个线程同时注册或触发事件,可能导致数据异常,因此我们可以使用ConcurrentDictionary,它是门为高并发场景设计的线程安全集合,内置原子操作,无需手动加锁。

ConcurrentDictionary 提供以下方法:

cs 复制代码
bool TryAdd(TKey key, TValue value);
bool TryRemove(TKey key, out TValue value);
bool TryGetValue(TKey key, out TValue value);
bool ContainsKey(TKey key);

思考一下,可以使用 ConcurrentDictionary<string,delegate>存储eventKey与callback的映射,但很快便发现,这样一个key只能对应一个回调,不能满足多个模块监听一个事件的应用场景。

于是我们尝试 ConcurrentDictionary<string,List<delegate>>,但是ConcurrentDictionary只能保证获取到 List<T> 的过程是安全的,修改 List<T> 仍然会存在线程不安全的问题。

假设有两个线程同时执行这段代码:

cs 复制代码
if (!eventDic.ContainsKey("Attack")) 
{ 
    eventDic["Attack"] = new List<Delegate>(); 
    eventDic["Attack"].Add(callback); 
}
时间 线程1 线程2
t1 执行步骤1(判断"Attack"不存在) -
t2 - 执行步骤1(同样判断"Attack"不存在)
t3 执行步骤2(创建新List) -
t4 - 执行步骤2(再次创建新List,覆盖线程1创建的List)
t5 执行步骤3(向被覆盖的List添加handler1) -
t6 - 执行步骤3(向新List添加handler2)

可以看到线程2覆盖了线程1创建的List,这可能会导致数据错误。

我们可以尝试使用ConcurrentDictionary<string,ConcurrentDictionary<Delegate,bool>>,嵌套的内层字典可以存储多个Delegate,并且修改操作都是线程安全的,对于内存字典的值,我们是用不上的,可以使用字节数最小的bool类型来占位。

广播

在广播时,我们遍历存储当前key所有委托的内层字典,并依次执行其回调函数。

因为我们不需要回调函数的返回值,所以我们把这些方法委托都从基类Delegate转换成无返回值类型的Action委托。

回调函数无参数:

cs 复制代码
public static void SyncBroadcast(string eventKey)
{
    if (eventDic.TryGetValue(eventKey, out ConcurrentDictionary<Delegate, bool> callbackList))
    {
        foreach (var callback in callbackList.Keys)
        {
            (callback as Action)?.Invoke();
        }
    }
}

回调函数带参数,使用泛型实现:

一般来说,三个参数就可以覆盖绝大多数的使用场景,所以我们只实现0~3个参数的方法。

cs 复制代码
public static void SyncBroadcast<T>(string eventKey, T data)
{
    if (eventDic.TryGetValue(eventKey, out ConcurrentDictionary<Delegate, bool> callbackList))
    {
        foreach (var callback in callbackList.Keys)
        {
            (callback as Action<T>)?.Invoke(data);
        }
    }
}

错误处理

如果某个回调抛出异常,会中断后续回调的执行,还需要增加 try-catch 包裹回调执行部分。

Broadcast与SyncBroadcast

对于SyncBroadcast,Invoke会在调用SyncBroadcast的线程执行。

但很多时候,我们需要在Unity主线程执行回调函数,可以使LoomManager.QueueOnMainThread方法把回调函数传给主线程执行。于是我们可以这样包装一下:

cs 复制代码
public static void Broadcast(string eventKey)
{
    LoomManager.QueueOnMainThread(() => SyncBroadcast(eventKey));
}

代码

cs 复制代码
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using UnityEngine;

public static class EventCenter
{
    private static string TAG = "[EventCenter]";

    private static readonly ConcurrentDictionary<string, ConcurrentDictionary<Delegate, bool>>
        eventDic = new ConcurrentDictionary<string, ConcurrentDictionary<Delegate, bool>>();

    // 添加事件监听
    public static void AddListener(string eventKey, Action callback)
    {
        if (!eventDic.ContainsKey(eventKey))
        {
            eventDic[eventKey] = new ConcurrentDictionary<Delegate, bool>();
        }
        eventDic[eventKey].TryAdd(callback, false);
    }

    #region 有参
    public static void AddListener<T>(string eventKey, Action<T> callback)
    {
        if (!eventDic.ContainsKey(eventKey))
        {
            eventDic[eventKey] = new ConcurrentDictionary<Delegate, bool>();
        }
        eventDic[eventKey].TryAdd(callback, false);
    }

    public static void AddListener<T,U>(string eventKey, Action<T,U> callback)
    {
        if (!eventDic.ContainsKey(eventKey))
        {
            eventDic[eventKey] = new ConcurrentDictionary<Delegate, bool>();
        }
        eventDic[eventKey].TryAdd(callback, false);
    }

    public static void AddListener<T, U, V>(string eventKey, Action<T, U, V> callback)
    {
        if (!eventDic.ContainsKey(eventKey))
        {
            eventDic[eventKey] = new ConcurrentDictionary<Delegate, bool>();
        }
        eventDic[eventKey].TryAdd(callback, false);
    }
    #endregion

    // 移除事件监听
    public static void RemoveListener(string eventKey, Action callback)
    {
        if(eventDic.TryGetValue(eventKey,out ConcurrentDictionary<Delegate,bool> callbackList))
        {
            if (callbackList.ContainsKey(callback))
                callbackList.TryRemove(callback, out bool result);
        }
    }

    // 移除全部事件监听
    public static void Clear() => eventDic.Clear();

    #region 有参
    public static void RemoveListener<T>(string eventKey, Action<T> callback)
    {
        if (eventDic.TryGetValue(eventKey, out ConcurrentDictionary<Delegate, bool> callbackList))
        {
            if (callbackList.ContainsKey(callback))
                callbackList.TryRemove(callback, out bool result);
        }
    }

    public static void RemoveListener<T, U>(string eventKey, Action<T, U> callback)
    {
        if(eventDic.TryGetValue(eventKey,out ConcurrentDictionary<Delegate,bool> callbackList))
        {
            if (callbackList.ContainsKey(callback))
                callbackList.TryRemove(callback, out bool result);
        }
    }

    public static void RemoveListener<T, U, V>(string eventKey, Action<T, U, V> callback)
    {
        if (eventDic.TryGetValue(eventKey, out ConcurrentDictionary<Delegate, bool> callbackList))
        {
            if (callbackList.ContainsKey(callback))
                callbackList.TryRemove(callback, out bool result);
        }
    }
    #endregion

    // 立即触发事件
    public static void SyncBroadcast(string eventKey)
    {
        if (eventDic.TryGetValue(eventKey, out ConcurrentDictionary<Delegate, bool> callbackList))
        {
            foreach (var callback in callbackList.Keys)
            {
                try
                {
                    (callback as Action)?.Invoke();
                }
                catch(Exception ex)
                {
                    Debug.LogError(TAG + $"Event:{eventKey} Callback:{callback.Method.Name} Failed: {ex.Message}");
                }
            }
        }
    }

    #region 有参
    public static void SyncBroadcast<T>(string eventKey, T data)
    {
        if (eventDic.TryGetValue(eventKey, out ConcurrentDictionary<Delegate, bool> callbackList))
        {
            foreach (var callback in callbackList.Keys)
            {
                try
                {
                    (callback as Action<T>)?.Invoke(data);
                }
                catch (Exception ex)
                {
                    Debug.LogError(TAG + $"Event:{eventKey} Callback:{callback.Method.Name} Failed: {ex.Message}");
                }
            }
        }
    }

    public static void SyncBroadcast<T, U>(string eventKey, T dataT, U dataU)
    {
        if (eventDic.TryGetValue(eventKey, out ConcurrentDictionary<Delegate, bool> callbackList))
        {
            foreach (var callback in callbackList.Keys)
            {
                try
                {
                    (callback as Action<T, U>)?.Invoke(dataT, dataU);
                }
                catch (Exception ex)
                {
                    Debug.LogError(TAG + $"Event:{eventKey} Callback:{callback.Method.Name} Failed: {ex.Message}");
                }
            }
        }
    }

    public static void SyncBroadcast<T, U, V>(string eventKey, T dataT, U dataU, V dataV)
    {
        if (eventDic.TryGetValue(eventKey, out ConcurrentDictionary<Delegate, bool> callbackList))
        {
            foreach (var callback in callbackList.Keys)
            {
                try
                {
                    (callback as Action<T, U, V>)?.Invoke(dataT, dataU, dataV);
                }
                catch (Exception ex)
                {
                    Debug.LogError(TAG + $"Event:{eventKey} Callback:{callback.Method.Name} Failed: {ex.Message}");
                }
            }
        }
    }
    #endregion

    // 在主线程触发事件
    public static void Broadcast(string eventKey)
    {
        LoomManager.QueueOnMainThread(() => SyncBroadcast(eventKey));
    }

    #region 有参
    public static void Broadcast<T>(string eventKey, T data)
    {
        LoomManager.QueueOnMainThread(() => SyncBroadcast(eventKey, data));
    }

    public static void Broadcast<T, U>(string eventKey, T dataT, U dataU)
    {
        LoomManager.QueueOnMainThread(() => SyncBroadcast(eventKey, dataT, dataU));
    }

    public static void Broadcast<T, U, V>(string eventKey, T dataT, U dataU, V dataV)
    {
        LoomManager.QueueOnMainThread(() => SyncBroadcast(eventKey, dataT, dataU, dataV));
    }
    #endregion
}
相关推荐
ellis19702 天前
Claude Code[二] 上下文相关的机制
unity·ai编程
zdr尽职尽责3 天前
Unity 3C 动画系统:从「蜘蛛网」到可维护的动画架构
unity·架构·游戏引擎
国家一级摸鱼选手3 天前
[Unity]几何碰撞检测:SAT 分离轴定理详解(从数学原理到 C# 实现)
unity·c#·游戏引擎·分离轴定理(sat)·多边形相交
暴走约伯5 天前
【VFX工具链源码拆解 09】终极工业化闭环:基于 ID 规则驱动的全自动场景建档、骨骼挂载与男转女场景迁移
unity·c#·游戏引擎·材质
寂寞的船6 天前
【Unity知识速递】第13期 Unity 内存泄漏排查实战:从 Memory Profiler 到 Lua 引用泄漏的生产级全链路诊断
unity·junit·c#·游戏引擎·lua
寂寞的船7 天前
【Unity Bug挑战】第12期 Awaitable 二次 await 死锁之谜 —— 为什么同一个异步操作等两次就卡死?
unity·c#·游戏引擎·bug
探求虚无8 天前
用 AI 在 Unity 里做一款 RTS:最难的不是生成代码,而是证明它真的能玩
人工智能·unity·游戏引擎
17岁的勇气9 天前
Unity Shader unity文档学习笔记(二十二):shader变体
笔记·学习·unity
寂寞的船10 天前
【Unity知识速递】第10期 Unity GC 零分配实战:从 UnityEngine.Pool 到手动 GC 控制的全链路优化
jvm·unity·c#·游戏引擎·lucene
寂寞的船12 天前
【Unity知识速递】第8期 IL2CPP 托管堆内存碎片与原生堆交互机制深度解析
unity·游戏引擎·交互