在多人协作的 Unity 项目开发中，高效的通信机制至关重要。事件系统提供了一种解耦模块间依赖的途径，允许不同开发者负责的不同功能模块（如接口、UI、游戏逻辑）之间通过事件进行通信。

基础事件管理器

以下是一个基础的事件管理器实现，它使用一个字典来存储事件类型与对应的回调函数列表。

using System;
using System.Collections.Generic;

public class EventBus
{
    private static EventBus _instance;
    public static EventBus Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new EventBus();
            }
            return _instance;
        }
    }

    // 使用枚举定义事件类型，并存储对应的回调列表
    private Dictionary>> _eventListeners =
        new Dictionary>>();

    private EventBus() { } // 私有构造函数，防止外部实例化

    // 注册事件监听器
    public void RegisterListener(GameEventType eventType, Action listener)
    {
        if (!_eventListeners.ContainsKey(eventType))
        {
            _eventListeners[eventType] = new List>();
        }
        _eventListeners[eventType].Add(listener);
    }

    // 移除特定事件的所有监听器
    public void UnregisterAllListeners(GameEventType eventType)
    {
        if (_eventListeners.ContainsKey(eventType))
        {
            _eventListeners.Remove(eventType);
        }
        else
        {
            UnityEngine.Debug.LogWarning($"Event type '{eventType}' not found in listeners.");
        }
    }

    // 移除特定的事件监听器
    public void UnregisterListener(GameEventType eventType, Action listener)
    {
        if (_eventListeners.TryGetValue(eventType, out List> listeners))
        {
            listeners.Remove(listener);
        }
        else
        {
            UnityEngine.Debug.LogWarning($"Event type '{eventType}' not found for listener removal.");
        }
    }

    // 触发事件
    public void TriggerEvent(GameEventType eventType, List<object> eventArgs = null)
    {
        if (_eventListeners.TryGetValue(eventType, out List> listeners))
        {
            // 遍历所有监听器并执行回调
            foreach (var listener in listeners)
            {
                listener(eventArgs);
            }
        }
        else
        {
            UnityEngine.Debug.LogWarning($"Event type '{eventType}' has no registered listeners.");
        }
    }
}

// 示例事件类型枚举
public enum GameEventType
{
    MapLoadComplete,
    DataFetchSuccess,
    NetworkError
}
    

使用示例

在一个组件中，可以通过以下方式注册和触发事件：

using UnityEngine;
using System.Collections.Generic;

public class MapDataLoader : MonoBehaviour
{
    private void OnEnable()
    {
        // 监听地图加载完成事件
        EventBus.Instance.RegisterListener(GameEventType.MapLoadComplete, HandleMapLoadCompletion);
    }

    private void OnDisable()
    {
        // 移除事件监听器，防止内存泄漏
        EventBus.Instance.UnregisterListener(GameEventType.MapLoadComplete, HandleMapLoadCompletion);
    }

    // 地图加载完成的回调处理函数
    private void HandleMapLoadCompletion(List<object> data)
    {
        Debug.Log("Map loaded successfully!");
        if (data != null && data.Count > 0 && data[0] is string status && status == "success")
        {
            // 处理加载成功后的逻辑
        }
    }

    // 模拟接口请求成功后触发事件
    public void SimulateApiSuccess()
    {
        Debug.Log("API request successful, triggering MapLoadComplete event.");
        EventBus.Instance.TriggerEvent(GameEventType.MapLoadComplete, new List<object> { "success" });
    }
}
    

优化改进

当事件的回调函数签名一致时，可以考虑使用更简洁的委托组合方式，减少字典中列表的开销。以下是一个优化后的消息管理器，它直接使用字符串作为消息标识，并采用单个委托处理所有消息。

using System;
using System.Collections.Generic;

public class MessageDispatcher
{
    private static MessageDispatcher _singletonInstance;
    public static MessageDispatcher SingletonInstance
    {
        get
        {
            // 使用 null 合并运算符简化实例创建
            return _singletonInstance ?? (_singletonInstance = new MessageDispatcher());
        }
    }

    // 使用字符串作为消息键，Action<object[]> 作为处理委托
    private Dictionary> _messageHandlers = new Dictionary>(32);

    private MessageDispatcher() { } // 私有构造函数

    // 订阅消息
    public void Subscribe(string messageKey, Action handler)
    {
        if (_messageHandlers.TryGetValue(messageKey, out Action existingHandlers))
        {
            // 如果消息已存在，则追加新的处理函数
            existingHandlers += handler;
            _messageHandlers[messageKey] = existingHandlers;
        }
        else
        {
            // 否则，添加新的消息键和处理函数
            _messageHandlers.Add(messageKey, handler);
        }
    }

    // 取消订阅消息
    public void Unsubscribe(string messageKey)
    {
        _messageHandlers.Remove(messageKey);
    }

    // 发布消息
    public void Publish(string messageKey, params object[] messageArgs)
    {
        if (_messageHandlers.TryGetValue(messageKey, out Action handlers))
        {
            handlers(messageArgs); // 执行所有注册的处理函数
        }
    }
}