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

前言

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

一、作用

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

二、原理

1、让脚本向事件中心添加事件,监听对应的"命令"。

2、发送"命令",事件中心就会通知监听了这条"命令"的脚本,让它们自动执行对应的逻辑。

三、不使用事件管理器

新增3个测试脚本

csharp 复制代码
public class Player : MonoBehaviour {
    public void Log(){
        Debug.Log("我是玩家");
    }
}
csharp 复制代码
public class Player1 : MonoBehaviour {
    public void Log(){
        Debug.Log("我是玩家1");
    }
}
csharp 复制代码
public class Player2 : MonoBehaviour {
    public void Log(){
        Debug.Log("我是玩家2");
    }
}

调用各个脚本的log方法

csharp 复制代码
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,事件管理器

csharp 复制代码
/// <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新增如下代码,添加事件监听

csharp 复制代码
private void Start() {
	EventManager.Instance.AddEventListener("打印日志", Log);    
}

3、触发事件

在EventManagerTest中触发事件

csharp 复制代码
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,添加移除事件方法

csharp 复制代码
/// <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;
    }
}

测试调用

csharp 复制代码
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("打印日志");
        }
    }
}

效果

六、自定义枚举事件名称

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

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

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

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

修改测试调用

csharp 复制代码
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 处理不带参数的回调。这增强了代码的清晰性和可维护性。

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

1、接口 IEventInfo

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

csharp 复制代码
public interface IEventInfo { }

2、泛型类 EventInfo

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

csharp 复制代码
private class EventInfo<T> : IEventInfo
{
    public UnityAction<T> action;

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

3、非泛型类 EventInfo

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

csharp 复制代码
private class EventInfo : IEventInfo
{
    public UnityAction action;

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

4、修改EventManager

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

csharp 复制代码
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都添加带一个参数的事件监听

csharp 复制代码
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、触发事件

测试触发事件

csharp 复制代码
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、效果

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

方法一、自定义类

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

比如

csharp 复制代码
public class MyInfo
{
	public int a;
	public float b;
	public double c;
}

调用

方法二、元组

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

方法三、添加带不同数量参数的方法(推荐)

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

1、GC(垃圾回收)

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

2、装箱问题

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

3、开销和复杂性

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

九、最终代码

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

csharp 复制代码
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

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

相关推荐
XiaoLeisj2 小时前
【JavaEE初阶 — 多线程】单例模式 & 指令重排序问题
java·开发语言·java-ee
励志成为嵌入式工程师3 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
逐·風3 小时前
unity关于自定义渲染、内存管理、性能调优、复杂物理模拟、并行计算以及插件开发
前端·unity·c#
捕鲸叉3 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer3 小时前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法
Peter_chq3 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
_oP_i4 小时前
Unity Addressables 系统处理 WebGL 打包本地资源的一种高效方式
unity·游戏引擎·webgl
记录成长java5 小时前
ServletContext,Cookie,HttpSession的使用
java·开发语言·servlet
前端青山5 小时前
Node.js-增强 API 安全性和性能优化
开发语言·前端·javascript·性能优化·前端框架·node.js
睡觉谁叫~~~5 小时前
一文解秘Rust如何与Java互操作
java·开发语言·后端·rust