【unity进阶知识3】封装一个事件管理系统

🕗 发布于 2024-09-26 14:24 unity 架构游戏引擎 开发语言 游戏

前言

框架的事件系统主要负责高效的方法调用与数据传递，实现各功能之间的解耦，通常在调用某个实例的方法时，必须先获得这个实例的引用或者新实例化一个对象，低耦合度的框架结构希望程序本身不去关注被调用的方法所依托的实例对象是否存在，通过事件系统做中转将功能的调用封装成事件，使用事件监听注册、移除和事件触发完成模块间的功能调用管理。常用在UI事件、跨模块事件上。

一、作用

访问其它脚本时，不直接访问，而是通过发送一条类似“命令”，让监听了这条“命令”的脚本自动执行对应的逻辑。

二、原理

1、让脚本向事件中心添加事件，监听对应的“命令”。
2、发送“命令”，事件中心就会通知监听了这条“命令”的脚本，让它们自动执行对应的逻辑。
在这里插入图片描述

三、不使用事件管理器

在这里插入图片描述

新增3个测试脚本

public class Player : MonoBehaviour {
    public void Log(){
        Debug.Log("我是玩家");
    }
}

public class Player1 : MonoBehaviour {
    public void Log(){
        Debug.Log("我是玩家1");
    }
}

public class Player2 : MonoBehaviour {
    public void Log(){
        Debug.Log("我是玩家2");
    }
}

调用各个脚本的log方法

public class EventManagerTest: MonoBehaviour
{

    private void Start()
    {
        GameObject go = GameObject.Find("Player");
        go.GetComponent<Player>().Log();    

        GameObject go1 = GameObject.Find("Player1");
        go1.GetComponent<Player1>().Log();

        GameObject go2 = GameObject.Find("Player2");
        go2.GetComponent<Player2>().Log();
    }
}

效果
在这里插入图片描述

四、使用事件管理器

1、事件管理器

新增EventManager，事件管理器

/// <summary>
/// 事件管理器
/// </summary>
public class EventManager : Singleton<EventManager>
{
    Dictionary<string, UnityAction> eventsDictionary = new Dictionary<string, UnityAction>();

    /// <summary>
    /// 事件监听
    /// </summary>
    /// <param name="eventName">事件名称</param>
    /// <param name="action">监听方法</param>
    public void AddEventListener(string eventName, UnityAction action)
    {
        if (eventsDictionary.ContainsKey(eventName))
        {
            eventsDictionary[eventName] += action;
        }
        else
        {
            eventsDictionary.Add(eventName, action);
        }
    }

    /// <summary>
    /// 触发事件
    /// </summary>
    /// <param name="eventName">事件名称</param>
    public void Dispatch(string eventName){
        if(eventsDictionary.ContainsKey(eventName)){
            eventsDictionary[eventName]?.Invoke();
        }
    }
}

2、添加事件监听

在这里插入图片描述

分别在Player、Player1、Player2新增如下代码，添加事件监听

private void Start() {
EventManager.Instance.AddEventListener("打印日志", Log);    
}

3、触发事件

在这里插入图片描述

在EventManagerTest中触发事件

public class EventManagerTest : MonoBehaviour
{
    private void Start()
    {
        // GameObject go = GameObject.Find("Player");
        // go.GetComponent<Player>().Log();    

        // GameObject go1 = GameObject.Find("Player1");
        // go1.GetComponent<Player1>().Log();

        // GameObject go2 = GameObject.Find("Player2");
        // go2.GetComponent<Player2>().Log();

        EventManager.Instance.Dispatch("打印日志");
    }
}

4、结果

在这里插入图片描述

五、移除事件

比如有几个小怪，都添加了事件监听，杀死后会被销毁，如果不把事件移除，直接再次执行命令则会报错:
MissingReferenceException:The object of type 'Capsule'has been destroyed but you are still trying to access it.
在这里插入图片描述
修改EventManager，添加移除事件方法

/// <summary>
/// 移除事件某个监听方法
/// </summary>
/// <param name="eventName">事件名称</param>
/// <param name="action">监听方法</param>
public void RemoveEventListener(string eventName, UnityAction action){
    if(eventsDictionary.ContainsKey(eventName)){
        eventsDictionary[eventName] -= action;
    }
}

/// <summary>
/// 移除整个事件
/// </summary>
/// <param name="eventName">名称</param>
public void RemoveEvent(string eventName){
    if(eventsDictionary.ContainsKey(eventName)){
        eventsDictionary[eventName] = null;
    }
}

测试调用

public class EventManagerTest : MonoBehaviour
{ 
    private void OnGUI()
    {
        if (GUI.Button(new Rect(0, 0, 150, 50), "触发事件"))
        {
            EventManager.Instance.Dispatch("打印日志");
        }
        if (GUI.Button(new Rect(0, 50, 150, 50), "移除Player事件监听"))
        {
            GameObject go = GameObject.Find("Player");
            EventManager.Instance.RemoveEventListener("打印日志", go.GetComponent<Player>().Log); 
        }
        if (GUI.Button(new Rect(0, 100, 150, 50), "移除整个事件"))
        {
            EventManager.Instance.RemoveEvent("打印日志");
        }
    }
}

效果
在这里插入图片描述

六、自定义枚举事件名称

目前事件名称是字符串，手打容易出错，我们可以选择使用枚举的方式

/// <summary>
/// 事件名称枚举
/// </summary>
public enum EventNameEnum{
    Log,    //打印
    AddHealth   //群体回血
}

修改EventManager，新增获取事件名称方法

/// <summary>
/// 获取事件名称
/// </summary>
/// <param name="eventNameEnum">事件枚举</param>
/// <returns>事件名称</returns>
private string GetEnventName(object EventNameEnum){
    return EventNameEnum.GetType().Name + "_" + EventNameEnum.ToString();
}

修改测试调用

public class EventManagerTest : MonoBehaviour
{ 
    private void OnGUI()
    {
        if (GUI.Button(new Rect(0, 0, 150, 50), "触发事件"))
        {
            EventManager.Instance.Dispatch(EventNameEnum.Log);
        }
        if (GUI.Button(new Rect(0, 50, 150, 50), "移除Player事件监听"))
        {
            GameObject go = GameObject.Find("Player");
            EventManager.Instance.RemoveEventListener(EventNameEnum.Log, go.GetComponent<Player>().Log); 
        }
        if (GUI.Button(new Rect(0, 100, 150, 50), "移除整个事件"))
        {
            EventManager.Instance.RemoveEvent(EventNameEnum.Log);
        }
    }
}

结果，和之前一样
在这里插入图片描述

七、传递带有一个参数的事件

如果我们想要传递带有一个参数的事件，可以遵循里氏替换原则（Liskov Substitution Principle），即子类可以替换父类而不会影响程序的正确性。

里氏替换原则
通过使用 IEventInfo 接口，可以确保 EventInfo<T> 和 EventInfo 类可以在需要 IEventInfo 的上下文中被替换而不影响程序的功能。这使得事件管理器能够处理不同类型的事件回调。
单一职责原则
每个 EventInfo 类都有自己的职责：EventInfo<T> 处理带参数的回调，而 EventInfo 处理不带参数的回调。这增强了代码的清晰性和可维护性。

这种设计提供了灵活性，使得事件管理系统能够处理多种类型的事件，同时也遵循了面向对象设计的原则。你可以根据需要扩展或修改 IEventInfo 和 EventInfo 类，以支持更多的事件类型和逻辑。

1、接口 IEventInfo

定义一个标记接口 IEventInfo，用于标识事件信息的类型。这样可以在系统中使用多态性，确保遵循里氏替换原则。

public interface IEventInfo { }

2、泛型类 EventInfo

EventInfo 类实现了 IEventInfo 接口。这个类用于处理带有参数的事件回调（UnityAction），允许在事件触发时传递参数。action 字段用于保存事件回调。

private class EventInfo<T> : IEventInfo
{
    public UnityAction<T> action;

    public EventInfo(UnityAction<T> call)
    {
        action += call; // 将传入的回调添加到 action 上
    }
}

3、非泛型类 EventInfo

另一个 EventInfo 类用于处理没有参数的事件回调（UnityAction）。这种设计使得可以处理不同类型的事件。

private class EventInfo : IEventInfo
{
    public UnityAction action;

    public EventInfo(UnityAction call)
    {
        action += call; // 将传入的回调添加到 action 上
    }
}

4、修改EventManager

事件名称记得修改一下，不然我们可能很难分出哪个是带传参的，我们可以选择把这个参数的类型的名字也传进去

Dictionary<string, IEventInfo> eventsDictionary = new Dictionary<string, IEventInfo>();

/// <summary>
/// 无参数的事件监听
/// </summary>
/// <param name="EventNameEnum">事件枚举</param>
/// <param name="action">监听方法</param>
public void AddEventListener(object EventNameEnum, UnityAction call)
{
    string eventName = GetEnventName(EventNameEnum);
    if (eventsDictionary.ContainsKey(eventName))
    {
        (eventsDictionary[eventName] as EventInfo).action += call;
    }
    else
    {
        eventsDictionary.Add(eventName, new EventInfo(call));
    }
}

/// <summary>
/// 带1个参数的事件监听
/// </summary>
public void AddEventListener<T>(object EventNameEnum, UnityAction<T> call)
{
    string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T).Name;
    if (eventsDictionary.ContainsKey(eventName))
    {
        (eventsDictionary[eventName] as EventInfo<T>).action += call;
    }
    else
    {
        eventsDictionary.Add(eventName, new EventInfo<T>(call));
    }
}

//其他类似

IEventInfo是我们人为制造出来的一个副接口，这样的话就可以成功把有参数的事件和无参数的事件都存到字典里面去了

5、事件监听

Player、Player1、Player2都添加带一个参数的事件监听

public class Player : MonoBehaviour
{
    private void Start()
    {
        EventManager.Instance.AddEventListener(EventNameEnum.Log, Log);
        EventManager.Instance.AddEventListener<int>(EventNameEnum.AddHealth, AddHealth);
    }

    public void Log()
    {
        Debug.Log("我是玩家");
    }

    public void AddHealth(int health)
    {
        Debug.Log($"玩家恢复+{health + 1}血");
    }
}

6、触发事件

测试触发事件

public class EventManagerTest : MonoBehaviour
{
    private void OnGUI()
    {
        if (GUI.Button(new Rect(150, 0, 150, 50), "触发带1个参数事件"))
        {
            EventManager.Instance.Dispatch<int>(EventNameEnum.AddHealth, 1);
        }
        if (GUI.Button(new Rect(150, 50, 150, 50), "移除Player带1个参数事件监听"))
        {
            GameObject go = GameObject.Find("Player");
            EventManager.Instance.RemoveEventListener<int>(EventNameEnum.AddHealth, go.GetComponent<Player>().AddHealth); 
        }
        if (GUI.Button(new Rect(150, 100, 150, 50), "移除整个带1个参数事件"))
        {
            EventManager.Instance.RemoveEvent<int>(EventNameEnum.AddHealth);
        }
    }
}

7、效果

在这里插入图片描述

八、传递带有多个参数的事件

方法一、自定义类

相当于将多个参数合并到一个类里，在传递进去

比如

public class MyInfo
{
public int a;
public float b;
public double c;
}

调用
在这里插入图片描述

方法二、元组

相当于通过元组把多个参数合并，传递进去

方法三、添加带不同数量参数的方法（推荐）

这种办法虽然最麻烦，但是不会有性能问题，可以避免下面的问题

1、GC（垃圾回收）

创建元组或自定义类实例会导致额外的内存分配，从而增加垃圾回收的压力。在高频率调用的场景下，频繁分配和回收内存会导致性能下降，影响游戏的帧率。

2、装箱问题

对于值类型（如 int、struct 等），使用元组或对象时可能会导致装箱和拆箱，增加内存开销和降低性能。这在使用泛型时尤为明显，因为值类型会被包装为对象。

3、开销和复杂性

封装多个参数在一个元组或自定义类中，虽然提高了代码的可读性，但也增加了开销，特别是在事件频繁触发的情况下，开销可能会显著。

九、最终代码

这里我添加最多支持添加4个参数的事件，一般都够了，如果觉得还是不够，可以模仿我的方式继续添加即可

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

/// <summary>
/// 事件管理器，之所以这么多函数，主要是出于性能考虑，避免产生GC、装箱问题
/// </summary>
public class EventManager : Singleton<EventManager>
{

    Dictionary<string, IEventInfo> eventsDictionary = new Dictionary<string, IEventInfo>();

    /// <summary>
    /// 获取事件名称
    /// </summary>
    /// <param name="eventNameEnum">事件枚举</param>
    /// <returns>事件名称</returns>
    private string GetEnventName(object EventNameEnum)
    {
        return EventNameEnum.GetType().Name + "_" + EventNameEnum.ToString();
    }

    #region 事件监听
    /// <summary>
    /// 无参数的事件监听
    /// </summary>
    /// <param name="EventNameEnum">事件枚举</param>
    /// <param name="action">监听方法</param>
    public void AddEventListener(object EventNameEnum, UnityAction call)
    {
        string eventName = GetEnventName(EventNameEnum);
        if (eventsDictionary.ContainsKey(eventName))
        {
            (eventsDictionary[eventName] as EventInfo).action += call;
        }
        else
        {
            eventsDictionary.Add(eventName, new EventInfo(call));
        }
    }

    /// <summary>
    /// 带1个参数的事件监听
    /// </summary>
    public void AddEventListener<T>(object EventNameEnum, UnityAction<T> call)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T).Name;
        if (eventsDictionary.ContainsKey(eventName))
        {
            (eventsDictionary[eventName] as EventInfo<T>).action += call;
        }
        else
        {
            eventsDictionary.Add(eventName, new EventInfo<T>(call));
        }
    }

    /// <summary>
    /// 带2个参数的事件监听
    /// </summary>
    public void AddEventListener<T0, T1>(object EventNameEnum, UnityAction<T0, T1> call)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name;
        if (eventsDictionary.ContainsKey(eventName))
        {
            (eventsDictionary[eventName] as EventInfo<T0, T1>).action += call;
        }
        else
        {
            eventsDictionary.Add(eventName, new EventInfo<T0, T1>(call));
        }
    }

    /// <summary>
    /// 带3个参数的事件监听
    /// </summary>
    public void AddEventListener<T0, T1, T2>(object EventNameEnum, UnityAction<T0, T1, T2> call)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name + "_" + typeof(T2).Name;
        if (eventsDictionary.ContainsKey(eventName))
        {
            (eventsDictionary[eventName] as EventInfo<T0, T1, T2>).action += call;
        }
        else
        {
            eventsDictionary.Add(eventName, new EventInfo<T0, T1, T2>(call));
        }
    }

    /// <summary>
    /// 带4个参数的事件监听
    /// </summary>
    public void AddEventListener<T0, T1, T2, T3>(object EventNameEnum, UnityAction<T0, T1, T2, T3> call)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name + "_" + typeof(T2).Name + "_" + typeof(T3).Name;
        if (eventsDictionary.ContainsKey(eventName))
        {
            (eventsDictionary[eventName] as EventInfo<T0, T1, T2, T3>).action += call;
        }
        else
        {
            eventsDictionary.Add(eventName, new EventInfo<T0, T1, T2, T3>(call));
        }
    }
    #endregion

    #region 触发事件
    /// <summary>
    /// 触发事件
    /// </summary>
    /// <param name="EventNameEnum">事件枚举</param>
    public void Dispatch(object EventNameEnum)
    {
        string eventName = GetEnventName(EventNameEnum);
        if (eventsDictionary.ContainsKey(eventName))
        {
            (eventsDictionary[eventName] as EventInfo).action?.Invoke();
        }
    }
    /// <summary>
    /// 触发带1个参数事件
    /// </summary>
    public void Dispatch<T>(object EventNameEnum, T parameter)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T).Name;
        //如果字典中该事件的名字存在，且该事件不为空，则执行该事件，不存在则什么也不做。
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T>).action?.Invoke(parameter);
    }
    /// <summary>
    /// 触发带2个参数事件
    /// </summary>
    public void Dispatch<T0, T1>(object EventNameEnum, T0 parameter0, T1 parameter1)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name;
        //如果字典中该事件的名字存在，且该事件不为空，则执行该事件，不存在则什么也不做。
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T0, T1>).action?.Invoke(parameter0, parameter1);
    }
    /// <summary>
    /// 触发带3个参数事件
    /// </summary>
    public void Dispatch<T0, T1, T2>(object EventNameEnum, T0 parameter0, T1 parameter1, T2 parameter2)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name + "_" + typeof(T2).Name;
        //如果字典中该事件的名字存在，且该事件不为空，则执行该事件，不存在则什么也不做。
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T0, T1, T2>).action?.Invoke(parameter0, parameter1, parameter2);
    }
    /// <summary>
    /// 触发带4个参数事件
    /// </summary>
    public void Dispatch<T0, T1, T2, T3>(object EventNameEnum, T0 parameter0, T1 parameter1, T2 parameter2, T3 parameter3)
    {
        string eventName = GetEnventName(EventNameEnum) +  "_" + typeof(T0).Name + "_" + typeof(T1).Name + "_" + typeof(T2).Name + "_" + typeof(T3).Name;
        //如果字典中该事件的名字存在，且该事件不为空，则执行该事件，不存在则什么也不做。
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T0, T1, T2, T3>).action?.Invoke(parameter0, parameter1, parameter2, parameter3);
    }
    #endregion

    #region 移除事件某个监听方法
    /// <summary>
    /// 移除无参数事件某个监听方法
    /// </summary>
    /// <param name="EventNameEnum">事件枚举</param>
    /// <param name="call">监听方法</param>
    public void RemoveEventListener(object EventNameEnum, UnityAction call)
    {
        string eventName = GetEnventName(EventNameEnum);
        if (eventsDictionary.ContainsKey(eventName))
        {
            (eventsDictionary[eventName] as EventInfo).action -= call;
        }
    }
    /// <summary>
    /// 移除带1个参数事件某个监听方法
    /// </summary>
    public void RemoveEventListener<T>(object EventNameEnum, UnityAction<T> call)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T).Name;
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T>).action -= call;
    }
    /// <summary>
    /// 移除带2个参数事件某个监听方法
    /// </summary>
    public void RemoveEventListener<T0, T1>(object EventNameEnum, UnityAction<T0, T1> call)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name;
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T0, T1>).action -= call;
    }
    /// <summary>
    /// 移除带3个参数事件某个监听方法
    /// </summary>
    public void RemoveEventListener<T0, T1, T2>(object EventNameEnum, UnityAction<T0, T1, T2> call)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name + "_" + typeof(T2).Name;
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T0, T1, T2>).action -= call;
    }
    /// <summary>
    /// 移除带4个参数事件某个监听方法
    /// </summary>
    public void RemoveEventListener<T0, T1, T2, T3>(object EventNameEnum, UnityAction<T0, T1, T2, T3> call)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name + "_" + typeof(T2).Name + "_" + typeof(T3).Name;
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T0, T1, T2, T3>).action -= call;
    }
    #endregion

    #region 移除整个事件
    /// <summary>
    /// 移除整个不带参数的事件
    /// </summary>
    /// <param name="EventNameEnum">事件枚举</param>
    public void RemoveEvent(object EventNameEnum)
    {
        string eventName = GetEnventName(EventNameEnum);
        if (eventsDictionary.ContainsKey(eventName))
        {
            (eventsDictionary[eventName] as EventInfo).action = null;
        }
    }
    /// <summary>
    /// 移除整个带1个参数的事件
    /// </summary>
    public void RemoveEvent<T>(object EventNameEnum)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T).Name;
        //如果字典中存在要移除的命令，则把这个命令的所有事件移除掉。
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T>).action = null;
    }
    /// <summary>
    /// 移除整个带2个参数的事件
    /// </summary>
    public void RemoveEvent<T0, T1>(object EventNameEnum)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name;
        //如果字典中存在要移除的命令，则把这个命令的所有事件移除掉。
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T0, T1>).action = null;
    }
    /// <summary>
    /// 移除整个带3个参数的事件
    /// </summary>
    public void RemoveEvent<T0, T1, T2>(object EventNameEnum)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name + "_" + typeof(T2).Name;
        //如果字典中存在要移除的命令，则把这个命令的所有事件移除掉。
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T0, T1, T2>).action = null;
    }
    /// <summary>
    /// 移除整个带4个参数的事件
    /// </summary>
    public void RemoveEvent<T0, T1, T2, T3>(object EventNameEnum)
    {
        string eventName = GetEnventName(EventNameEnum) + "_" + typeof(T0).Name + "_" + typeof(T1).Name + "_" + typeof(T2).Name + "_" + typeof(T3).Name;
        //如果字典中存在要移除的命令，则把这个命令的所有事件移除掉。
        if (eventsDictionary.ContainsKey(eventName))
            (eventsDictionary[eventName] as EventInfo<T0, T1, T2, T3>).action = null;
    }
    #endregion

    /// <summary>
    /// 移除事件中心的所有事件。可以考虑在切换场景时调用。
    /// </summary>
    public void RemoveAllEvent()
    {
        eventsDictionary.Clear();
    }

    #region 里氏替换原则
    private interface IEventInfo { }

    private class EventInfo : IEventInfo
    {
        public UnityAction action;

        public EventInfo(UnityAction call)
        {
            action += call;
        }
    }

    private class EventInfo<T> : IEventInfo
    {
        public UnityAction<T> action;

        public EventInfo(UnityAction<T> call)
        {
            action += call;
        }
    }

    private class EventInfo<T0, T1> : IEventInfo
    {
        public UnityAction<T0, T1> action;

        public EventInfo(UnityAction<T0, T1> call)
        {
            action += call;
        }
    }

    private class EventInfo<T0, T1, T2> : IEventInfo
    {
        public UnityAction<T0, T1, T2> action;

        public EventInfo(UnityAction<T0, T1, T2> call)
        {
            action += call;
        }
    }

    private class EventInfo<T0, T1, T2, T3> : IEventInfo
    {
        public UnityAction<T0, T1, T2, T3> action;

        public EventInfo(UnityAction<T0, T1, T2, T3> call)
        {
            action += call;
        }
    }
    #endregion
}

完结

赠人玫瑰，手有余香！如果文章内容对你有所帮助，请不要吝啬你的点赞评论和关注，你的每一次支持都是我不断创作的最大动力。当然如果你发现了文章中存在错误或者有更好的解决方法，也欢迎评论私信告诉我哦！

好了，我是向宇，https://xiangyu.blog.csdn.net

一位在小公司默默奋斗的开发者，闲暇之余，边学习边记录分享，站在巨人的肩膀上，通过学习前辈们的经验总是会给我很多帮助和启发！如果你遇到任何问题，也欢迎你评论私信或者加群找我，虽然有些问题我也不一定会，但是我会查阅各方资料，争取给出最好的建议，希望可以帮助更多想学编程的人，共勉~
在这里插入图片描述

原文地址：https://blog.csdn.net/qq_36303853/article/details/142500845

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【css】常见布局概述
下一篇：1.1.5 计算机网络的性能指标（上）

leetcode289:生命游戏
根据，简称为，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。给定一个包含m × n个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态：1即为（live），或0即为
阅读更多2024-10-20
MongoDB数据恢复
注意：两个MongoDB的版本要一致，本文使用的是mongo:4.2.24。先把K8S上面的MongoDB 容器停止（可以把副本改成0）。1、将容器挂载MongoDB的数据目录备份到本地。经常是数据文
阅读更多2024-10-20
C#中实现事务
C#中实现事务
阅读更多2024-10-20
【LeetCode每日一题】——560.和为 K 的子数组
给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。
阅读更多2024-10-20
「漏洞复现」满客宝智慧食堂系统 selectUserByOrgId 未授权访问漏洞
请勿利用文章内的相关技术从事非法测试，由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，作者不为此承担任何责任。工具来自网络，安全性自测，如有侵权请联系删除。本次
阅读更多2024-10-20
React面试题目（从基本到高级）
React前端面试常见题目涵盖了React的基础概念、组件、状态管理、生命周期、性能优化等多个方面。
阅读更多2024-10-20
12.个人博客系统（Java项目基于spring和vue）
1 在校学习的学生，可用于日常学习使用或是毕业设计使用 2 毕业一到两年的开发人员，用于锻炼自己的独立功能模块设计能力，增强代码编写能力。 3 亦可以部署为商化项目使用。 4 需要完整资料及源码
阅读更多2024-10-20
YoloV8改进策略：注意力改进|DeBiFormer，可变形双级路由注意力|引入DeBiLevelRoutingAttention注意力模块（全网首发）
本次改进的核心在于将DeBiLevelRoutingAttention模块嵌入到YoloV8的主干网络中，具体位置是在SPPF（Spatial Pyramid Pooling Fast）模块之后。这一
阅读更多2024-10-20
word取消自动单词首字母大写
情况说明：在word输入单词后首字母会自动变成大写取消单词首字母大写步骤：（1）点击菜单栏文件（2）点击“更多”——>“选项”（3）点击“校对”——>“自动更正选项”（4）取消“句首字母大
阅读更多2024-10-20
web前端网页用户注册页面
【代码】web前端网页用户注册页面。
阅读更多2024-10-20

【unity进阶知识3】封装一个事件管理系统

前言

一、作用

二、原理

三、不使用事件管理器

四、使用事件管理器

1、事件管理器

2、添加事件监听

3、触发事件

4、结果

五、移除事件

六、自定义枚举事件名称

七、传递带有一个参数的事件

1、接口 IEventInfo

2、泛型类 EventInfo

3、非泛型类 EventInfo

4、修改EventManager

5、事件监听

6、触发事件

7、效果

八、传递带有多个参数的事件

方法一、自定义类

方法二、元组

方法三、添加带不同数量参数的方法（推荐）

1、GC（垃圾回收）

2、装箱问题

3、开销和复杂性

九、最终代码

完结

相关文章