简单的事件中心实现

CRYCHIC的最强客服-丰川祥子

完整演示项目地址 cneicy/Rouge

最简单的版本展开最简单的版本隐藏

EventCenter.cs

using System;
using Client.Event.EventArgs;
using Client.Event.EventHandler;
using Client.Object;
using UnityEngine;

namespace Client.Event
{
    public class EventCenter : MonoBehaviour
    {
        #region 单例

        private static readonly object Lock = new();
        private static EventCenter _instance;

        public static EventCenter Instance
        {
            get
            {
                lock (Lock)
                {
                    if (_instance != null) return _instance;
                    _instance = FindObjectOfType<EventCenter>() ??
                                new GameObject("EventCenter").AddComponent<EventCenter>();
                    return _instance;
                }
            }
        }

        private void Awake()
        {
            if (_instance != null && _instance != this)
            {
                Destroy(gameObject);
            }
            else
            {
                _instance = this;
            }
        }

        #endregion

        //定义事件
        public event PlayerHpChangeEventHandler OnPlayerHpChange;
        public event Action<ulong> OnPlayerDie;
        public event TouchPlayerEventHandler OnTouchPlayer;

        //玩家HP变化 血量归零时执行PlayerDie，触发OnPlayerDie
        public int PlayerHpChange(int hp, ulong playerID)
        {
            if (OnPlayerHpChange == null) return hp;
            var newHp = OnPlayerHpChange(new PlayerHpChangeEventArgs(hp, playerID));
            if (newHp <= 0) PlayerDie(playerID);
            return newHp;
        }

        //玩家死亡
        private void PlayerDie(ulong playerID)
        {
            OnPlayerDie?.Invoke(playerID);
        }

        //触摸玩家
        public Player TouchPlayer(Player player, ulong playerID)
        {
            return OnTouchPlayer?.Invoke(new TouchPlayerEventArgs(player, playerID));
        }
    }
}

PlayerHpChangeEventArgs.cs

namespace Client.Event.EventArgs
{
    //玩家Hp变化事件委托参数
    public class PlayerHpChangeEventArgs : System.EventArgs
    {
        public int Hp { get; }
        public ulong PlayerID { get; }

        public PlayerHpChangeEventArgs(int hp, ulong playerID)
        {
            Hp = hp;
            PlayerID = playerID;
        }
    }
}

TouchPlayerEventArgs.cs

using Client.Object;

namespace Client.Event.EventArgs
{
    //敌人触碰到玩家事件委托参数 
    public class TouchPlayerEventArgs : System.EventArgs
    {
        public Player Player { get; }
        public ulong PlayerID { get; }

        public TouchPlayerEventArgs(Player player, ulong playerID)
        {
            Player = player;
            PlayerID = playerID;
        }
    }
}

PlayerHpChangeEventHandler.cs

using Client.Event.EventArgs;

namespace Client.Event.EventHandler
{
    //玩家Hp变化事件委托
    public delegate int PlayerHpChangeEventHandler(PlayerHpChangeEventArgs e);
}

TouchPlayerEventHandler.cs

using Client.Event.EventArgs;
using Client.Object;

namespace Client.Event.EventHandler
{
    //敌人触碰到玩家事件委托
    public delegate Player TouchPlayerEventHandler(TouchPlayerEventArgs e);
}

Player.cs

using Client.Event;
using Client.Event.EventArgs;
using Unity.Netcode;
using UnityEngine;

namespace Client.Object
{
    public class Player : NetworkBehaviour
    {
        private int _hp = 4;

        #region 订阅
        
        private void OnEnable()
        {
            EventCenter.Instance.OnPlayerHpChange += HandlePlayerHpChange;
            EventCenter.Instance.OnPlayerDie += HandlePlayerDie;
        }

        private void OnDisable()
        {
            EventCenter.Instance.OnPlayerHpChange -= HandlePlayerHpChange;
            EventCenter.Instance.OnPlayerDie -= HandlePlayerDie;
        }
        #endregion
        //OnPlayerHpChange触发后执行HandlePlayerHpChange
        private int HandlePlayerHpChange(PlayerHpChangeEventArgs e)
        {
            Debug.Log("HandlePlayerHpChange");
            if (e.PlayerID != GetPlayerID()) return e.Hp;
            Debug.Log(_hp);
            return _hp += e.Hp;

        }
        //OnPlayerDie触发后执行HandlePlayerDie
        private void HandlePlayerDie(ulong playerID)
        {
            if (playerID == GetPlayerID())
            {
                Debug.Log("HandlePlayerDie");
            }
        }

        public int GetPlayerHp()
        {
            return _hp;
        }

        public ulong GetPlayerID()
        {
            return NetworkManager.Singleton.LocalClientId;
        }
    }
}

Enemy.cs

using Client.Event;
using Client.Event.EventArgs;
using UnityEngine;

namespace Client.Object
{
    public class Enemy : MonoBehaviour
    {
        private void OnEnable()
        {
            EventCenter.Instance.OnTouchPlayer += HandleTouchPlayer;
        }

        private void OnDisable()
        {
            EventCenter.Instance.OnTouchPlayer -= HandleTouchPlayer;
        }

        public int damage = 1;
        //当触碰到玩家时执行TouchPlayer触发OnTouchPlayer事件，执行HandleTouchPlayer，执行PlayerHpChange触发OnPlayerHpChange
        private void OnTriggerEnter2D(Collider2D other)
        {
            if (other.TryGetComponent<Player>(out var player))
            {
                EventCenter.Instance.TouchPlayer(player, player.GetPlayerID());
            }
        }

        private Player HandleTouchPlayer(TouchPlayerEventArgs e)
        {
            Debug.Log("HandleTouchPlayer");
            EventCenter.Instance.PlayerHpChange(-damage, e.PlayerID);
            return e.Player;
        }
    }
}

拓展改良后展开拓展改良后隐藏

实际上是将原来的各种事件Handler和EventArg封装取消，使用string管理。
在原来的基础上实现了取消事件。

EventManager.cs

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

namespace Events
{
    public class EventManager : Singleton<EventManager>
    {
        // 使用泛型事件字典来存储事件和处理程序
        private readonly Dictionary<string, Delegate> _eventHandlers = new();

        // 注册事件
        public void RegisterEvent<T>(string eventName, Func<T, object> handler)
        {
            if (!_eventHandlers.TryAdd(eventName, handler))
            {
                _eventHandlers[eventName] = Delegate.Combine(_eventHandlers[eventName], handler);
            }
        }

        // 注销事件
        public void UnregisterEvent<T>(string eventName, Func<T, object> handler)
        {
            if (_eventHandlers.ContainsKey(eventName))
            {
                _eventHandlers[eventName] = Delegate.Remove(_eventHandlers[eventName], handler);
            }
        }

        // 触发事件并返回结果
        public object TriggerEvent<T>(string eventName, T args)
        {
            if (!_eventHandlers.TryGetValue(eventName, out var eventHandler)) return null;
            if (eventHandler is Func<T, object> handler)
            {
                return handler(args);
            }

            return null;
        }

        private void OnDisable()
        {
            _eventHandlers.Clear(); // 清空所有事件处理程序
        }

        // 取消事件
        public void CancelEvent(string eventName)
        {
            if (_eventHandlers.ContainsKey(eventName))
            {
                _eventHandlers[eventName] = null;
                Debug.Log($"Event {eventName} cancelled");
            }
        }
    }
}

Player.cs

using Events;
using UnityEngine;

namespace Objects
{
    public class Player : MonoBehaviour
    {
        private int _hp = 100;
        private ulong _playerID = 12345;
        private bool _hasBasket; // 模拟玩家是否拥有果篮

        #region 订阅

        private void OnEnable()
        {
            // 注册事件
            EventManager.Instance.RegisterEvent<int>("OnPlayerHpChange", HandlePlayerHpChange);
            EventManager.Instance.RegisterEvent<ulong>("OnPlayerDie", HandlePlayerDie);
            EventManager.Instance.RegisterEvent<Player>("OnPlayerPickItem", HandlePlayerPickItem);
            EventManager.Instance.RegisterEvent<ulong>("OnPlayerLogin", HandlePlayerLogin);
        }

        private void OnDisable()
        {
            // 注销事件
            EventManager.Instance.UnregisterEvent<int>("OnPlayerHpChange", HandlePlayerHpChange);
            EventManager.Instance.UnregisterEvent<ulong>("OnPlayerDie", HandlePlayerDie);
            EventManager.Instance.UnregisterEvent<Player>("OnPlayerPickItem", HandlePlayerPickItem);
            EventManager.Instance.UnregisterEvent<ulong>("OnPlayerLogin", HandlePlayerLogin);
        }

        #endregion

        // 玩家登录事件处理程序
        private object HandlePlayerLogin(ulong playerId)
        {
            Debug.Log($"Player {playerId} logged in");
            return null;
        }

        // 玩家血量变化事件的处理程序
        private object HandlePlayerHpChange(int hpChange)
        {
            _hp += hpChange;
            Debug.Log($"玩家血量变化: {_hp}");

            // 如果血量归零，触发死亡事件
            if (_hp <= 0)
            {
                EventManager.Instance.TriggerEvent("OnPlayerDie", _playerID);
            }

            return _hp; // 返回新的血量
        }

        // 玩家死亡事件的处理程序
        private object HandlePlayerDie(ulong playerID)
        {
            Debug.Log($"玩家 {playerID} 死亡！");
            return playerID;
        }

        // 玩家拾取物品事件的处理程序
        private object HandlePlayerPickItem(Player player)
        {
            if (!_hasBasket)
            {
                Debug.Log("玩家没有果篮，取消拾取物品事件");
                return null; // 事件被取消
            }

            Debug.Log("玩家拾取了物品");
            return player; // 返回玩家对象，表示事件继续
        }

        // 用于测试血量变化
        public void ChangeHp(int hpChange)
        {
            // 触发血量变化事件，并传递血量变化值，返回新血量
            var newHp = EventManager.Instance.TriggerEvent("OnPlayerHpChange", hpChange);
            Debug.Log($"玩家新血量: {newHp}");
        }

        // 用于测试拾取物品
        public void PickItem()
        {
            // 触发拾取物品事件
            var result = EventManager.Instance.TriggerEvent("OnPlayerPickItem", this);
            if (result == null)
            {
                Debug.Log("物品拾取事件被取消");
            }
        }

        // 用于测试改变玩家是否有果篮
        public void SetHasBasket(bool hasBasket)
        {
            _hasBasket = hasBasket;
        }

        public void PlayerLogin()
        {
            EventManager.Instance.TriggerEvent("OnPlayerLogin", _playerID);
            EventManager.Instance.CancelEvent("OnPlayerLogin");
            EventManager.Instance.TriggerEvent("OnPlayerLogin", _playerID);
        }
    }
}

GameController.cs(测试用)

using Objects;
using UnityEngine;

public class GameController : MonoBehaviour
{
    private void Start()
    {
        var player = FindObjectOfType<Player>();

        player.ChangeHp(-50);
        player.ChangeHp(-60);


        // 玩家没有果篮，尝试拾取物品
        player.SetHasBasket(false);
        player.PickItem(); // 事件应该被取消

        // 玩家有果篮，尝试拾取物品
        player.SetHasBasket(true);
        player.PickItem(); // 事件应该继续执行

        player.PlayerLogin();
    }
}

使用C# Attribute 展开使用C# Attribute 隐藏

用到了反射部分的内容Attribute。

EventManager.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
using Utils;

namespace Events
{
    public class EventManager : Singleton<EventManager>
    {
        // 使用泛型事件字典来存储事件和处理程序
        private readonly Dictionary<string, Delegate> _eventHandlers = new();

        // 注册事件处理程序
        public void RegisterEvent<T>(string eventName, Func<T, object> handler)
        {
            if (!_eventHandlers.TryAdd(eventName, handler))
            {
                _eventHandlers[eventName] = Delegate.Combine(_eventHandlers[eventName], handler);
            }
        }

        // 注销事件处理程序
        public void UnregisterEvent<T>(string eventName, Func<T, object> handler)
        {
            if (_eventHandlers.ContainsKey(eventName))
            {
                _eventHandlers[eventName] = Delegate.Remove(_eventHandlers[eventName], handler);
            }
        }

        // 触发事件并返回结果（带返回值版本，支持多个参数）
        public object TriggerEvent<T>(string eventName, T args)
        {
            if (!_eventHandlers.TryGetValue(eventName, out var eventHandler)) return null;
            if (eventHandler is Func<T, object> handler)
            {
                return handler(args);
            }

            return null;
        }


        // 取消指定事件
        public void CancelEvent(string eventName)
        {
            if (!_eventHandlers.ContainsKey(eventName)) return;
            _eventHandlers[eventName] = null;
            Debug.Log($"Event {eventName} cancelled");
        }

        public void UnregisterAllEventsForObject(object targetObject)
        {
            // 将事件名称存入列表以避免遍历时修改集合
            var eventNames = new List<string>(_eventHandlers.Keys);

            foreach (var eventName in eventNames)
            {
                var eventHandler = _eventHandlers[eventName];
                if (eventHandler == null) continue;

                var handlers = eventHandler.GetInvocationList();

                // 遍历并移除与目标对象相关的处理程序
                foreach (var handler in handlers)
                {
                    if (handler.Target == targetObject)
                    {
                        _eventHandlers[eventName] = Delegate.Remove(_eventHandlers[eventName], handler);
                    }
                }

                // 检查并移除空的事件
                if (_eventHandlers[eventName] == null || _eventHandlers[eventName].GetInvocationList().Length == 0)
                {
                    _eventHandlers.Remove(eventName);
                }
            }

            Debug.Log($"All events unregistered for object: {targetObject}");
        }


        // 注销所有事件
        public void UnregisterAllEvents()
        {
            _eventHandlers.Clear();
            Debug.Log("All events have been unregistered.");
        }

        // 从带有 EventSubscribe 特性的方法中自动注册事件处理程序
        public void RegisterEventHandlersFromAttributes(object target)
        {
            var methods = target.GetType()
                .GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
            foreach (var method in methods)
            {
                var attributes = method.GetCustomAttributes(typeof(EventSubscribeAttribute), false);
                foreach (var attribute in attributes)
                {
                    if (attribute is not EventSubscribeAttribute eventSubscribe) continue;
                    var eventName = eventSubscribe.EventName;
                    var handler = Delegate.CreateDelegate(
                        typeof(Func<,>).MakeGenericType(method.GetParameters()[0].ParameterType, method.ReturnType),
                        target, method);
                    if (!_eventHandlers.TryAdd(eventName, handler))
                    {
                        _eventHandlers[eventName] = Delegate.Combine(_eventHandlers[eventName], handler);
                    }
                }
            }
        }
    }

    // 特性类，用于标记事件订阅方法
    [AttributeUsage(AttributeTargets.Method)]
    public class EventSubscribeAttribute : Attribute
    {
        public string EventName { get; }

        public EventSubscribeAttribute(string eventName)
        {
            EventName = eventName;
        }
    }
}

Player.cs

using Events;
using UnityEngine;

// ReSharper disable UnusedMember.Local

namespace Objects
{
    public class Player : MonoBehaviour
    {
        private int _hp = 100;
        private ulong _playerID = 12345;
        private bool _hasBasket; // 模拟玩家是否拥有果篮

        // 玩家血量
        public int Hp
        {
            get => _hp;
            set
            {
                _hp = value;
                if (_hp <= 0)
                {
                    EventManager.Instance.TriggerEvent("OnPlayerDie", _playerID);
                }
            }
        }

        // 玩家是否有果篮
        public void SetHasBasket(bool hasBasket)
        {
            _hasBasket = hasBasket;
        }

        public ulong GetPlayerID() => _playerID;

        [EventSubscribe("OnPlayerHpChange")]
        private object HandlePlayerHpChange(int hpChange)
        {
            Hp += hpChange;
            Debug.Log($"玩家血量变化: {Hp}");

            return Hp; // 返回新血量
        }

        [EventSubscribe("OnPlayerDie")]
        private object HandlePlayerDie(ulong playerID)
        {
            Debug.Log($"玩家 {playerID} 死亡！");
            return playerID;
        }

        [EventSubscribe("OnPlayerPickItem")]
        private object HandlePlayerPickItem(Player player)
        {
            if (!_hasBasket)
            {
                Debug.Log("玩家没有果篮，取消拾取物品事件");
                return null; // 事件被取消
            }

            Debug.Log("玩家拾取了物品");
            return player; // 返回玩家对象，表示事件继续
        }

        [EventSubscribe("OnPlayerLogin")]
        private object HandlePlayerLogin(ulong playerId)
        {
            Debug.Log($"Player {playerId} logged in");
            return null;
        }

        private void Awake()
        {
            EventManager.Instance.RegisterEventHandlersFromAttributes(this);
        }

        private void OnDestroy()
        {
            EventManager.Instance.UnregisterAllEventsForObject(this);
        }
    }
}

GameController.cs(测试类)

using Events;
using Objects;
using UnityEngine;

public class GameController : MonoBehaviour
{
    private void Start()
    {
        var player = FindObjectOfType<Player>();

        // 模拟触发事件，减少玩家的血量
        TriggerPlayerHpChangeEvent(-50);
        TriggerPlayerHpChangeEvent(-60); // 血量低于0时会触发死亡事件

        // 模拟拾取物品事件
        // 玩家没有果篮，尝试拾取物品
        player.SetHasBasket(false);
        TriggerPlayerPickItemEvent(player); // 事件应该被取消

        // 玩家有果篮，尝试拾取物品
        player.SetHasBasket(true);
        TriggerPlayerPickItemEvent(player); // 事件应该继续执行

        // 模拟玩家登录事件
        TriggerPlayerLoginEvent(player.GetPlayerID());
    }

    private void TriggerPlayerHpChangeEvent(int hpChange)
    {
        // 触发血量变化事件，并传递血量变化值
        var newHp = EventManager.Instance.TriggerEvent("OnPlayerHpChange", hpChange);
        Debug.Log($"事件返回的新血量: {newHp}");
    }

    private void TriggerPlayerPickItemEvent(Player player)
    {
        // 触发拾取物品事件
        var result = EventManager.Instance.TriggerEvent("OnPlayerPickItem", player);
        if (result == null)
        {
            Debug.Log("物品拾取事件被取消");
        }
    }

    private void TriggerPlayerLoginEvent(ulong playerId)
    {
        // 触发玩家登录事件
        EventManager.Instance.TriggerEvent("OnPlayerLogin", playerId);
    }
}