Unity事件的高级监听与广播系统

最新推荐文章于 2023-06-28 19:10:03 发布
最新推荐文章于 2023-06-28 19:10:03 发布
阅读量479 收藏 4
点赞数
分类专栏： Unity 文章标签： c# unity3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45047433/article/details/106336319
版权

        在大型的项目中，一般需要大量的事件来实现我们的功能，如果代码之间的耦合度高，相应的扩展性就会变得差一些。要改变一些要改变的代码时就要去找相应的引用，这会非常麻烦。降低代码的耦合度，可以大大提高项目的扩展性，给我们带来了方便。

基本思路是：每一个事件码对应一种事件，通过广播事件码，来触发相应的事件。

首先我们需要建立三个脚本来分别存放和处理不同方法和逻辑

1.创建一个单例模式的基类：BaseManager.cs

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

/// <summary>
/// 泛型基类:用于创建单例模式
/// </summary>
/// <typeparam name="T">类型</typeparam>
public class BaseManager <T> where T : new() {
    private static T _Instance;
	
    public static T GetInstance()
    {
        if (_Instance==null)
        {
           _Instance= new T();
        }
        return _Instance;
    }
}

 2.创建一个存放事件码的类（不需要继承MonoBehaviour）：EventType.cs

public enum EventType
{
    
}

需要触发什么事件，就把事件码写在里面。

3.创建一个用来封装我们所使用到的所有委托: CallBack.cs

public delegate void CallBack();
public delegate void CallBack<X>(X arg);
public delegate void CallBack<X, Y>(X arg1,Y arg2);
public delegate void CallBack<X, Y, Z>(X arg1, Y arg2,Z arg3);
public delegate void CallBack<X, Y, Z, W>(X arg1, Y arg2, Z arg3,W arg4);
public delegate void CallBack<X, Y, Z, W, T>(X arg1, Y arg2, Z arg3, W arg,T arg5);

 这里主要使用C#的泛型委托，这个代码还可以扩展更多的参数，只要你需要多少个参数就可以写多少个，一般5个参数就可以了。

4.创建一个用于处理不同事件类型的监听，移除监听，广播：EventCenter.cs

主要思路：1.通过C#的Dictionary存放事件码和事件的委托

                  2.添加事件：判断字典是否有该事件码，没有添加；

                                       判断当前委托类型与添加的事件码的类型是否一致

                                       最后订阅该事件

                  3.移除事件: 先判断事件码是否存在

                                     取消订阅

                                     最后判断事件码是否为空，是null则移除事件码。

                 4.广播事件：若事件委托不为null ,广播事件。

using System;
using System.Collections.Generic;

public class EventCenter : BaseManager<EventCenter>
{
    public Dictionary<EventEnum, Delegate> m_EventTable = new Dictionary<EventEnum, Delegate>();

    /// <summary>
    /// 添加事件
    /// </summary>
    /// <param name="eventEnum">事件码</param>
    /// <param name="callBack">事件委托</param>
    public void AddListener(EventEnum eventEnum, CallBack callBack)
    {
        if (!m_EventTable.ContainsKey(eventEnum))
        {
            m_EventTable.Add(eventEnum, null);
        }
        Delegate d = m_EventTable[eventEnum];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试事件为{0}添加不同类型委托，当前委托类型为{1}，要添加的委托类型为{2}", eventEnum, d.GetType(), callBack.GetType()));
        }
        m_EventTable[eventEnum] = (CallBack)m_EventTable[eventEnum] + callBack;
    }

    /// <summary>
    /// one parameter
    /// </summary>
    /// <typeparam name="X">参数1</typeparam>
    /// <param name="eventEnum">事件码</param>
    /// <param name="callBack">事件委托</param>
    public void AddListener<X>(EventEnum eventEnum, CallBack<X> callBack)
    {
        if (!m_EventTable.ContainsKey(eventEnum))
        {
            m_EventTable.Add(eventEnum, null);
        }
        Delegate d = m_EventTable[eventEnum];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试事件为{0}添加不同类型委托，当前委托类型为{1}，要添加的委托类型为{2}", eventEnum, d.GetType(), callBack.GetType()));
        }
        m_EventTable[eventEnum] = (CallBack<X>)m_EventTable[eventEnum] + callBack;
    }
    /// <summary>
    /// two parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="callBack"></param>
    public void AddListener<X,Y>(EventEnum eventEnum, CallBack<X,Y> callBack)
    {
        if (!m_EventTable.ContainsKey(eventEnum))
        {
            m_EventTable.Add(eventEnum, null);
        }
        Delegate d = m_EventTable[eventEnum];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试事件为{0}添加不同类型委托，当前委托类型为{1}，要添加的委托类型为{2}", eventEnum, d.GetType(), callBack.GetType()));
        }
        m_EventTable[eventEnum] = (CallBack<X,Y>)m_EventTable[eventEnum] + callBack;
    }

    /// <summary>
    /// three parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <typeparam name="Z"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="callBack"></param>
    public void AddListener<X, Y, Z>(EventEnum eventEnum, CallBack<X, Y, Z> callBack)
    {
        if (!m_EventTable.ContainsKey(eventEnum))
        {
            m_EventTable.Add(eventEnum, null);
        }
        Delegate d = m_EventTable[eventEnum];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试事件为{0}添加不同类型委托，当前委托类型为{1}，要添加的委托类型为{2}", eventEnum, d.GetType(), callBack.GetType()));
        }
        m_EventTable[eventEnum] = (CallBack<X, Y, Z>)m_EventTable[eventEnum] + callBack;
    }

    /// <summary>
    /// four parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <typeparam name="Z"></typeparam>
    /// <typeparam name="W"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="callBack"></param>
    public void AddListener<X, Y, Z, W>(EventEnum eventEnum, CallBack<X, Y, Z, W> callBack)
    {
        if (!m_EventTable.ContainsKey(eventEnum))
        {
            m_EventTable.Add(eventEnum, null);
        }
        Delegate d = m_EventTable[eventEnum];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试事件为{0}添加不同类型委托，当前委托类型为{1}，要添加的委托类型为{2}", eventEnum, d.GetType(), callBack.GetType()));
        }
        m_EventTable[eventEnum] = (CallBack<X, Y, Z, W>)m_EventTable[eventEnum] + callBack;
    }

    /// <summary>
    /// five parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <typeparam name="Z"></typeparam>
    /// <typeparam name="W"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="callBack"></param>
    public void AddListener<X, Y, Z, W, T>(EventEnum eventEnum, CallBack<X, Y, Z, W, T> callBack)
    {
        if (!m_EventTable.ContainsKey(eventEnum))
        {
            m_EventTable.Add(eventEnum, null);
        }
        Delegate d = m_EventTable[eventEnum];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试事件为{0}添加不同类型委托，当前委托类型为{1}，要添加的委托类型为{2}", eventEnum, d.GetType(), callBack.GetType()));
        }
        m_EventTable[eventEnum] = (CallBack<X, Y, Z, W, T>)m_EventTable[eventEnum] + callBack;
    }

    /// <summary>
    /// 移除事件
    /// </summary>
    /// <param name="eventEnum">事件码</param>
    /// <param name="callBack">事件委托</param>
    public void RemoveListener(EventEnum eventEnum, CallBack callBack)
    {
        if (m_EventTable.ContainsKey(eventEnum))
        {
            Delegate d = m_EventTable[eventEnum];
            if (d == null)
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托类型", eventEnum));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托,当前委托为{1}，要移除的事件为{2}", eventEnum, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除事件错误：没有事件码{0}", eventEnum));
        }
        m_EventTable[eventEnum] = (CallBack)m_EventTable[eventEnum] - callBack;
        if (m_EventTable[eventEnum] == null)
        {
            m_EventTable.Remove(eventEnum);
        }
    }

    /// <summary>
    /// one parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="callBack"></param>
    public void RemoveListener<X>(EventEnum eventEnum, CallBack<X> callBack)
    {
        if (m_EventTable.ContainsKey(eventEnum))
        {
            Delegate d = m_EventTable[eventEnum];
            if (d == null)
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托类型", eventEnum));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托,当前委托为{1}，要移除的事件为{2}", eventEnum, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除事件错误：没有事件码{0}", eventEnum));
        }
        m_EventTable[eventEnum] = (CallBack<X>)m_EventTable[eventEnum] - callBack;
        if (m_EventTable[eventEnum] == null)
        {
            m_EventTable.Remove(eventEnum);
        }
    }
    /// <summary>
    /// two parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="callBack"></param>
    public void RemoveListener<X,Y>(EventEnum eventEnum, CallBack<X,Y> callBack)
    {
        if (m_EventTable.ContainsKey(eventEnum))
        {
            Delegate d = m_EventTable[eventEnum];
            if (d == null)
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托类型", eventEnum));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托,当前委托为{1}，要移除的事件为{2}", eventEnum, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除事件错误：没有事件码{0}", eventEnum));
        }
        m_EventTable[eventEnum] = (CallBack<X,Y>)m_EventTable[eventEnum] - callBack;
        if (m_EventTable[eventEnum] == null)
        {
            m_EventTable.Remove(eventEnum);
        }
    }

    /// <summary>
    ///  three parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <typeparam name="Z"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="callBack"></param>
    public void RemoveListener<X, Y, Z>(EventEnum eventEnum, CallBack<X, Y, Z> callBack)
    {
        if (m_EventTable.ContainsKey(eventEnum))
        {
            Delegate d = m_EventTable[eventEnum];
            if (d == null)
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托类型", eventEnum));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托,当前委托为{1}，要移除的事件为{2}", eventEnum, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除事件错误：没有事件码{0}", eventEnum));
        }
        m_EventTable[eventEnum] = (CallBack<X, Y, Z>)m_EventTable[eventEnum] - callBack;
        if (m_EventTable[eventEnum] == null)
        {
            m_EventTable.Remove(eventEnum);
        }
    }

    /// <summary>
    /// four parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <typeparam name="Z"></typeparam>
    /// <typeparam name="W"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="callBack"></param>
    public void RemoveListener<X, Y, Z, W>(EventEnum eventEnum, CallBack<X, Y, Z, W> callBack)
    {
        if (m_EventTable.ContainsKey(eventEnum))
        {
            Delegate d = m_EventTable[eventEnum];
            if (d == null)
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托类型", eventEnum));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托,当前委托为{1}，要移除的事件为{2}", eventEnum, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除事件错误：没有事件码{0}", eventEnum));
        }
        m_EventTable[eventEnum] = (CallBack<X, Y, Z, W>)m_EventTable[eventEnum] - callBack;
        if (m_EventTable[eventEnum] == null)
        {
            m_EventTable.Remove(eventEnum);
        }
    }

    /// <summary>
    /// five parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <typeparam name="Z"></typeparam>
    /// <typeparam name="W"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="callBack"></param>
    public void RemoveListener<X, Y, Z, W, T>(EventEnum eventEnum, CallBack<X, Y, Z, W, T> callBack)
    {
        if (m_EventTable.ContainsKey(eventEnum))
        {
            Delegate d = m_EventTable[eventEnum];
            if (d == null)
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托类型", eventEnum));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除事件错误：事件{0}没有对应的委托,当前委托为{1}，要移除的事件为{2}", eventEnum, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除事件错误：没有事件码{0}", eventEnum));
        }
        m_EventTable[eventEnum] = (CallBack<X, Y, Z, W, T>)m_EventTable[eventEnum] - callBack;
        if (m_EventTable[eventEnum] == null)
        {
            m_EventTable.Remove(eventEnum);
        }
    }

    /// <summary>
    /// 广播事件
    /// </summary>
    /// <param name="eventEnum"></param>
    public void BraodCastEvent(EventEnum eventEnum)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventEnum, out d))
        {
            CallBack callBack = d as CallBack;
            if (callBack != null)
            {
                callBack();
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}有不同类型的委托", eventEnum));
            }
        }
    }

    /// <summary>
    /// one parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="arg"></param>
    public void BraodCastEvent<X>(EventEnum eventEnum, X arg)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventEnum, out d))
        {
            CallBack<X> callBack = d as CallBack<X>;
            if (callBack != null)
            {
                callBack(arg);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}有不同类型的委托", eventEnum));
            }
        }
    }

    /// <summary>
    /// two parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="arg1"></param>
    /// <param name="arg2"></param>
    public void BraodCastEvent<X, Y>(EventEnum eventEnum, X arg1, Y arg2)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventEnum, out d))
        {
            CallBack<X,Y> callBack = d as CallBack<X,Y>;
            if (callBack != null)
            {
                callBack(arg1,arg2);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}有不同类型的委托", eventEnum));
            }
        }
    }

    /// <summary>
    /// three parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <typeparam name="Z"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="arg1"></param>
    /// <param name="arg2"></param>
    /// <param name="arg3"></param>
    public void BraodCastEvent<X, Y, Z>(EventEnum eventEnum, X arg1, Y arg2, Z arg3)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventEnum, out d))
        {
            CallBack<X, Y, Z> callBack = d as CallBack<X, Y, Z>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}有不同类型的委托", eventEnum));
            }
        }
    }

    /// <summary>
    /// four parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <typeparam name="Z"></typeparam>
    /// <typeparam name="W"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="arg1"></param>
    /// <param name="arg2"></param>
    /// <param name="arg3"></param>
    /// <param name="arg4"></param>
    public void BraodCastEvent<X, Y, Z, W>(EventEnum eventEnum, X arg1, Y arg2, Z arg3, W arg4)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventEnum, out d))
        {
            CallBack<X, Y, Z, W> callBack = d as CallBack<X, Y, Z, W>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3, arg4);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}有不同类型的委托", eventEnum));
            }
        }
    }

    /// <summary>
    /// five parameter
    /// </summary>
    /// <typeparam name="X"></typeparam>
    /// <typeparam name="Y"></typeparam>
    /// <typeparam name="Z"></typeparam>
    /// <typeparam name="W"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <param name="eventEnum"></param>
    /// <param name="arg1"></param>
    /// <param name="arg2"></param>
    /// <param name="arg3"></param>
    /// <param name="arg4"></param>
    /// <param name="arg5"></param>
    public void BraodCastEvent<X, Y, Z, W, T>(EventEnum eventEnum, X arg1, Y arg2, Z arg3, W arg4, T arg5)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventEnum, out d))
        {
            CallBack<X, Y, Z, W, T> callBack = d as CallBack<X, Y, Z, W, T>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3, arg4, arg5);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}有不同类型的委托", eventEnum));
            }
        }
    }
}

 我们来做个试验，使用没有参数的。给一个场景创建一个Cube，点击按钮时显示出来

 首先在EventType脚本中添加一个事件码：

public enum EventType
{
    Test,
}

 给Cube添加一个脚本Test

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

public class Test : MonoBehaviour {

	void Start () {
        this.gameObject.SetActive(false);
        EventCenter.GetInstance().AddListener(EventType.Test, Show);
	}

    void Show()
    {
        this.gameObject.SetActive(true);
    }

    private void OnDestroy()
    {
        EventCenter.GetInstance().RemoveListener(EventType.Test, Show);
    }
}

 

创建一个Canvas，在Canvas下创建一个Button，给Button组件添加一个脚本Play.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class Player : MonoBehaviour {
    private Button button;

    private void Start()
    {
        button = GetComponent<Button>();
        button.onClick.AddListener(()=> { EventCenter.GetInstance().BraodCastEvent(EventType.Test); });
        
    }

}

点击按钮就可以看到效果了！！

接下来在进行一个测试：有参数的；在刚刚的Canvas下创建一个Text组件

修改一下上面的Test脚本

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class Test01 : MonoBehaviour {

    private Text text;
	void Start () {
        text = GameObject.Find("Text").GetComponent<Text>();
        this.gameObject.SetActive(false);
        EventCenter.GetInstance().AddListener<string,string>(EventType.Test, Show);
	}

    void Show(string str1,string str2)
    {
        this.gameObject.SetActive(true);
        text.text = str1 + str2;
    }

    private void OnDestroy()
    {
        EventCenter.GetInstance().RemoveListener<string ,string>(EventType.Test, Show);
    }
}

再次修改Play.cs脚本

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class Player : MonoBehaviour {
    private Button button;

    private void Start()
    {
        button = GetComponent<Button>();
        button.onClick.AddListener(()=> { EventCenter.GetInstance().BraodCastEvent<string,string>(EventType.Test,"你好:","Unity!!!!"); });
        
    }

}

点击按钮就可以看到效果了！！！

到此事件监听与广播系统就完成了！！！！

 

小黄羊
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity--高度解耦和(事件的监听与广播系统)
weixin_51002263的博客
04-22 512
在Unity中我们通常要通过鼠标注册事件来完成当我们点击按钮触发某一效果，或许我们可以通过鼠标注册来完成，或者通过从其他脚本中通过单例模型来解决但这样可能会产生一些不必要的影响，所以我们可以利用事件的监听以及广播来完成对此鼠标注册的替换。 例子: 如上图所示，当我们点击场景中的按钮时我们可以将文本New Text替换为你好。(未使用鼠标注册事件以及单例模型)。 1.无参类型 EventCenter脚本 作用:用于监听，广播，移除监听的脚本。 首先我们需要定义一个字典用于储存事件码，以及委托。 接着定义添
Unity：简易事件监听与广播系统
不二
03-31 1307
一个非常简单的事件监听与广播系统，功能也比较简单，但是还是挺实用的，可以用来解耦 实现功能： 添加事件监听 移除事件监听 广播消息 消息类型枚举： /// <summary> /// 事件类型枚举 /// </summary> public enum EventType { ShowText, HideText } 消息中心： usin...
Unity 事件的广播与监听
dj15870669579的博客
12-11 835
建一个枚举，存储事件码 public enum EventDefine { example1, } 声明几种委托的类型 public delegate void CallBack(); public delegate void CallBack<T>(T arg); public delegate void CallBack<T, X>(T arg1, X arg...
Unity高度解耦和，事件的监听和广播
LCHUIHUI的博客
02-15 1475
总共需要三个脚本，一个是CallBack 这个脚本里面定义了委托，包括无参的委托，带有一个参数的委托，两个参数的委托等 public delegate void CallBack(); public delegate void CallBack(T arg); public delegate void CallBack&lt;T, X&gt;(T arg1, X arg2); public de...
Unity事件的监听与广播系统教程.rar
06-30
在Unity中，事件监听与广播系统是实现对象间通信的重要机制，它使得游戏对象能够响应特定的事件并执行相应的操作。本教程将深入探讨Unity中的事件监听与广播系统，帮助开发者更好地理解和利用这一功能。 首先，事件...
Unity UGUI事件系统的监听和广播.rar
05-31
1、封装了由无参、1个参数到5个参数的委托类型 2、对应的参数的事件监听、移除监听的方法、广播 3、事件码是单独的枚举类，可自由添加
ProductivityToolkit-Unity事件监听器系统插件
04-25
ProductivityToolkit-Unity事件监听器系统插件 Unity事件监听器系统 直观且快速地设置自定义事件，用于减少对象依赖的常见方法！几乎没有额外的代码来结构化游戏逻辑，可以通过拖放在检查器中处理事件订阅，可以在...
SIki学院的高度解耦和：事件的监听与广播系统（Unity2018.1.0）资料
01-26
本资料主要探讨了如何在Unity2018.1.0版本中实现事件的监听与广播系统，以达到这一目标。以下是关于这个主题的详细知识点： 1. **事件驱动编程**： 事件驱动编程是一种编程范式，它依赖于事件处理器来响应特定的...
unity 钩子系统监听系统按键
04-22
全局使用钩子，监听鼠标与键盘 按键
Unity高度解耦和 - 事件的监听与广播系统（Unity2018）
正版游戏的受害者的博客
05-15 647
创建添加监听的方法 CallBcak.cs public delegate void CallBack(); public delegate void CallBack<T>(T arg); EventType.cs public enum EventType { } EventCenter.cs using System; using System.Collec...
事件的广播与监听系统（一）
qq_22975451的博客
05-31 456
一、类的描述： 1、在CallBack类中定义了委托，有无参的，1个参数的…到有5个参数的。这相当于U3d中的Action类。 2、EventType类中的枚举存放了事件码，后续有需要的话可以自己新加。 3、最主要的是EventCenter类，定义了不同参数的添加监听(AddListener)、移除监听(RemoveListener)和消息广播（Broadcast）。 二、使用示例： 2.1 添加事件监听 在Awake()中添加监听，如果调用的委托方法中需要传入参数，就要在AddListener<&
unity 事件监听系统
qq_39676160的博客
08-21 3637
自己写的事件监听系统 用泛型避免了拆箱装箱, 目前 : 一个事件对应一种委托类型 如需一个事件对应多种委托类型 需 自行扩展 并不难 代码如下: /**************************************************** 文件：EventManager.cs 作者：风生水虎 邮箱: 851267723@qq.com ****************...
unity 观察者模式应用(事件的广播和监听系统)
梦想是世界和平
10-05 1419
首先，分别新建以下三个脚本 脚本1，脚本名：CallBack //定义了具有不同参数数量的委托类型，提供给EventCenter使用 public delegate void CallBack(); public delegate void CallBack<T>(T arg); public delegate void CallBack<T, X>(T arg1, X arg2); public delegate void CallBack<T, X, Y>(T arg
Unity 事件监听与广播(高度解耦合，观察者模式)
明明明的博客
06-28 1204
unity 事件的监听与广播、解耦合、观察者模式
Unity事件的监听与广播系统Delegate
chh19941125的专栏
03-15 608
using System; using System.Collections; using System.Collections.Generic; using UnityEngine; public class EventManager { public static Dictionary&lt;EventType, Delegate&gt; MyEvent = new Dictio...
unity事件系统（广播系统）的学习笔记
weixin_45072334的博客
05-25 1447
最近在研究广播系统，写下来记录一下，好记性不如烂笔头。简单写了无参数广播事件系统 using System; using System.Collections; using System.Collections.Generic; using UnityEngine; public delegate void CallBack();//需要有参数的直接在这加上需要的参数就可以实现参数广播。 public enum EventTypee//广播事件 { test } public class Eve
Zjh游戏（八）客户端登陆注册的前期准备广播事件的制作，避免耦合性
赵某人
12-03 229
回调类型 public delegate void CallBack(); public delegate void CallBack<T>(T arg); public delegate void CallBack<T, X>(T arg1, X arg2); public delegate void CallBack<T, X, Y>(T arg1, X a...
Unity面板监听处理
qq_40833062的博客
03-01 671
using System.Diagnostics; using System.IO; using UnityEditor; using UnityEngine; internal class SelectionHelper { [InitializeOnLoadMethod] private static void Start() { //在Hierarchy面板按空格键相当于开关GameObject EditorApplication.hierarchyWindowItemOnG
unity事件的监听和广播
最新发布
07-11
Unity中的事件监听和广播是一种常见的消息传递机制，用于组件之间的通信。在Unity中，可以使用UnityEvent和UnityEvent<T>来定义和触发事件。 1. 定义事件： 首先，需要在一个类中定义一个事件。可以在该类中创建一个公共的UnityEvent类型的字段，并且使用UnityEvent的AddListener方法来添加监听器。 ```csharp using UnityEngine.Events; public class MyEventClass : MonoBehaviour { public UnityEvent myEvent; public void TriggerEvent() { myEvent.Invoke(); } } ``` 2. 监听事件： 其他的组件可以通过获取事件所在的类的引用，并使用AddListener方法添加监听器来监听该事件。 ```csharp public class MyListenerClass : MonoBehaviour { private MyEventClass eventClass; private void Start() { eventClass = GetComponent<MyEventClass>(); eventClass.myEvent.AddListener(OnEventTriggered); } private void OnEventTriggered() { Debug.Log("Event Triggered!"); } } ``` 3. 广播事件： 事件类可以通过调用UnityEvent的Invoke方法来触发事件，从而通知所有的监听器。 ```csharp public class MyEventClass : MonoBehaviour { public UnityEvent myEvent; public void TriggerEvent() { myEvent.Invoke(); } } ``` 以上就是Unity中事件的监听和广播的基本用法，可以通过这种方式实现组件之间的松耦合通信。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值