Unity3d的事件分发系统的实现

最新推荐文章于 2024-09-16 14:38:13 发布
最新推荐文章于 2024-09-16 14:38:13 发布
阅读量848 收藏 2
点赞数
分类专栏： Unity框架 文章标签： unity3d 软件框架 事件模块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26468099/article/details/104310887
版权

                                                                 Unity3d的事件分发系统的实现

       肺炎期间在家自行隔离，在家无聊，学习一下，看到了siki学院的Carson老师的《Unity高度解耦和 - 事件的监听与广播系统》课程，这里感谢Carson老师。对比自己学习工作的项目中事件分发系统。总结出一些体会。

      事件分发系统是一个大的项目必不可少的模块，一个较大的项目，各个模块如果耦合度太高，维护起来成本就比较高，故障率就会不断的增大，记得大学课本上说到的软件工程中的一个概念-判断软件设计好坏的标准“高内聚，低耦合”。事件分发系统就是用来解耦的。

      首先需要了解一下委托的概念，c#基础这里就不做陈述。其次了解什么观察者模式，这里用到了设计模式中常见的观察者模式。当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

观察者模式的优缺点：优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

废话不多说，先上代码

这是Carson老师的代码

1.EventCenter.cs

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

public class EventCenter
{
    private static Dictionary<EventType, Delegate> eventDic = new Dictionary<EventType, Delegate>();

    private static void OnListenerAdding(EventType eventType, Delegate callBack)
    {
        if (!eventDic.ContainsKey(eventType))
        {
            eventDic.Add(eventType, null);
        }
        Delegate d = eventDic[eventType];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试为事件{0}添加不同类型的委托，当前事件所对应的委托是{1}，要添加的委托类型为{2}", eventType, d.GetType(), callBack.GetType()));
        }
    }
    private static void OnListenerRemoving(EventType eventType, Delegate callBack)
    {
        if (eventDic.ContainsKey(eventType))
        {
            Delegate d = eventDic[eventType];
            if (d == null)
            {
                throw new Exception(string.Format("移除监听错误：事件{0}没有对应的委托", eventType));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除监听错误：尝试为事件{0}移除不同类型的委托，当前委托类型为{1}，要移除的委托类型为{2}", eventType, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除监听错误：没有事件码{0}", eventType));
        }
    }
    private static void OnListenerRemoved(EventType eventType)
    {
        if (eventDic[eventType] == null)
        {
            eventDic.Remove(eventType);
        }
    }
    //no parameters
    public static void AddListener(EventType eventType, CallBack callBack)
    {
        OnListenerAdding(eventType, callBack);
        eventDic[eventType] = (CallBack)eventDic[eventType] + callBack;
    }
    //Single parameters
    public static void AddListener<T>(EventType eventType, CallBack<T> callBack)
    {
        OnListenerAdding(eventType, callBack);
        eventDic[eventType] = (CallBack<T>)eventDic[eventType] + callBack;
    }
    //two parameters
    public static void AddListener<T, X>(EventType eventType, CallBack<T, X> callBack)
    {
        OnListenerAdding(eventType, callBack);
        eventDic[eventType] = (CallBack<T, X>)eventDic[eventType] + callBack;
    }
    //three parameters
    public static void AddListener<T, X, Y>(EventType eventType, CallBack<T, X, Y> callBack)
    {
        OnListenerAdding(eventType, callBack);
        eventDic[eventType] = (CallBack<T, X, Y>)eventDic[eventType] + callBack;
    }
    //four parameters
    public static void AddListener<T, X, Y, Z>(EventType eventType, CallBack<T, X, Y, Z> callBack)
    {
        OnListenerAdding(eventType, callBack);
        eventDic[eventType] = (CallBack<T, X, Y, Z>)eventDic[eventType] + callBack;
    }
    //five parameters
    public static void AddListener<T, X, Y, Z, W>(EventType eventType, CallBack<T, X, Y, Z, W> callBack)
    {
        OnListenerAdding(eventType, callBack);
        eventDic[eventType] = (CallBack<T, X, Y, Z, W>)eventDic[eventType] + callBack;
    }

    //no parameters
    public static void RemoveListener(EventType eventType, CallBack callBack)
    {
        OnListenerRemoving(eventType, callBack);
        eventDic[eventType] = (CallBack)eventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    //single parameters
    public static void RemoveListener<T>(EventType eventType, CallBack<T> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        eventDic[eventType] = (CallBack<T>)eventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    //two parameters
    public static void RemoveListener<T, X>(EventType eventType, CallBack<T, X> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        eventDic[eventType] = (CallBack<T, X>)eventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    //three parameters
    public static void RemoveListener<T, X, Y>(EventType eventType, CallBack<T, X, Y> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        eventDic[eventType] = (CallBack<T, X, Y>)eventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    //four parameters
    public static void RemoveListener<T, X, Y, Z>(EventType eventType, CallBack<T, X, Y, Z> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        eventDic[eventType] = (CallBack<T, X, Y, Z>)eventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    //five parameters
    public static void RemoveListener<T, X, Y, Z, W>(EventType eventType, CallBack<T, X, Y, Z, W> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        eventDic[eventType] = (CallBack<T, X, Y, Z, W>)eventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }


    //no parameters
    public static void Broadcast(EventType eventType)
    {
        Delegate d;
        if (eventDic.TryGetValue(eventType, out d))
        {
            CallBack callBack = d as CallBack;
            if (callBack != null)
            {
                callBack();
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }
    //single parameters
    public static void Broadcast<T>(EventType eventType, T arg)
    {
        Delegate d;
        if (eventDic.TryGetValue(eventType, out d))
        {
            CallBack<T> callBack = d as CallBack<T>;
            if (callBack != null)
            {
                callBack(arg);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }
    //two parameters
    public static void Broadcast<T, X>(EventType eventType, T arg1, X arg2)
    {
        Delegate d;
        if (eventDic.TryGetValue(eventType, out d))
        {
            CallBack<T, X> callBack = d as CallBack<T, X>;
            if (callBack != null)
            {
                callBack(arg1, arg2);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }
    //three parameters
    public static void Broadcast<T, X, Y>(EventType eventType, T arg1, X arg2, Y arg3)
    {
        Delegate d;
        if (eventDic.TryGetValue(eventType, out d))
        {
            CallBack<T, X, Y> callBack = d as CallBack<T, X, Y>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }
    //four parameters
    public static void Broadcast<T, X, Y, Z>(EventType eventType, T arg1, X arg2, Y arg3, Z arg4)
    {
        Delegate d;
        if (eventDic.TryGetValue(eventType, out d))
        {
            CallBack<T, X, Y, Z> callBack = d as CallBack<T, X, Y, Z>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3, arg4);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }
    //five parameters
    public static void Broadcast<T, X, Y, Z, W>(EventType eventType, T arg1, X arg2, Y arg3, Z arg4, W arg5)
    {
        Delegate d;
        if (eventDic.TryGetValue(eventType, out d))
        {
            CallBack<T, X, Y, Z, W> callBack = d as CallBack<T, X, Y, Z, W>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3, arg4, arg5);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
            }
        }
    }
}

2.CallBack.cs

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 arg2, Y arg3);
public delegate void CallBack<T, X, Y, Z>(T arg1, X arg2, Y arg3, Z arg4);
public delegate void CallBack<T, X, Y, Z, W>(T arg1, X arg2, Y arg3, Z arg4, W arg5);

下面的是曾经用过的一个事件分发系统

/**
 *Copyright(C) 2015 by #FrameworkStudyDemo#
 *All rights reserved.
 *FileName:     #EventDispatcher.cs#
 *Author:       #zhangliang#
 *Version:      #1.0#
 *UnityVersion：#2018.4.2f#
 *Date:         #2020/2/14#
 *Description:   事件派发器：用于添加事件监听，移除事件监听，事件是否存在监听，事件派发（执行监听的事件）
 *History:
*/


using System.Collections.Generic;
using UnityEngine;


#region 事件参数

/// <summary>
/// 事件参数
/// </summary>
public interface IEventParam
{

}

public class StringEventParam : IEventParam
{
    public string value;
    public StringEventParam(string str)
    {
        this.value = str;
    }
}
public class IntEventParam : IEventParam
{
    public int value;

    public IntEventParam(int param)
    {
        this.value = param;
    }

}

public class ObjectEventParam : IEventParam
{
    public object value;

    public ObjectEventParam(object param)
    {
        this.value = param;
    }

}

#endregion


/// <summary>
/// 事件派发器对外接口
/// </summary>
public interface IEventDispatcher
{
    /// <summary>
    /// 添加事件监听
    /// </summary>
    void AddEventListener(EventType eventType, EventDelegate eventDelegate);
    /// <summary>
    /// 移除事件监听
    /// </summary>
    void RemoveEventListener(EventType eventType, EventDelegate eventDelegate);
    /// <summary>
    /// 是否存在事件监听
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="eventDelegate"></param>
    /// <returns></returns>
    bool HasEventListener(EventType eventType, EventDelegate eventDelegate);
    /// <summary>
    /// 派发事件
    /// </summary>
    void DispatcherEvent(EventType eventType, IEventParam eventParam);
    /// <summary>
    /// 清除所有监听
    /// </summary>
    void RemoveAllListener();
}

/// <summary>
/// 委托定义
/// </summary>
/// <param name="IE"></param>
public delegate void EventDelegate(IEventParam IE);
public class EventDispatcher : IEventDispatcher
{
    private static EventDispatcher instance;
    /// <summary>
    /// 单例
    /// </summary>
    public static EventDispatcher Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new EventDispatcher();
            }
            return instance;
        }
    }
    /// <summary>
    /// 已经注册的事件字典
    /// </summary>
    private Dictionary<EventType, List<EventDelegate>> eventDic = new Dictionary<EventType, List<EventDelegate>>();

    /// <summary>
    /// 添加事件监听
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="eventDelegate"></param>
    public void AddEventListener(EventType eventType, EventDelegate eventDelegate)
    {
        if (eventDic == null)
        {
            eventDic = new Dictionary<EventType, List<EventDelegate>>();
        }

        if (!eventDic.ContainsKey(eventType))
        {
            List<EventDelegate> delegateList = new List<EventDelegate>();
            delegateList.Add(eventDelegate);
            eventDic.Add(eventType, delegateList);
        }
        else
        {
            List<EventDelegate> delegateList = eventDic[eventType];
            if (!delegateList.Contains(eventDelegate))
            {
                delegateList.Add(eventDelegate);
                eventDic[eventType] = delegateList;
            }

        }
    }

    /// <summary>
    /// 移除事件监听
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="eventDelegate"></param>
    public void RemoveEventListener(EventType eventType, EventDelegate eventDelegate)
    {
        if (eventDic.ContainsKey(eventType))
        {
            if (eventDic[eventType].Contains(eventDelegate))
            {
                eventDic[eventType].Remove(eventDelegate);
                if (eventDic[eventType].Count == 0)
                {
                    eventDic.Remove(eventType);
                }
            }
            else
            {
                Debug.Log(" EventType:" + eventType + " EventDelegate:" + eventDelegate.Method + " not exit");
            }
        }
        else
        {
            Debug.Log(" EventType:" + eventType + " not exit");
        }
    }

    /// <summary>
    /// 是否存在事件监听
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="eventDelegate"></param>
    /// <returns></returns>
    public bool HasEventListener(EventType eventType, EventDelegate eventDelegate)
    {
        if (eventDic.ContainsKey(eventType))
        {
            if (eventDic[eventType].Contains(eventDelegate))
            {
                return true;
            }
        }
        return false;

    }

    /// <summary>
    /// 派发事件
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="eventDelegate"></param>
    public void DispatcherEvent(EventType eventType, IEventParam eventParam)
    {
        if (eventDic.ContainsKey(eventType))
        {
            List<EventDelegate> delegateList = eventDic[eventType];
            for (int i = 0; i < delegateList.Count; i++)
            {
                delegateList[i](eventParam);
            }
        }
    }

    /// <summary>
    /// 清除所有监听
    /// </summary>
    public void RemoveAllListener()
    {
        if (eventDic.Count != 0)
        {
            eventDic.Clear();
        }
    }

}
 

 

这两个事件派发器大致类似，只是第二种对于同一个事件可以有多个响应，例如，一个项目中，一个大的模块中有多个小的模块，由不同的开发进行开发，当某个事件发生时，需要出发多有小模块里的刷新，这是我们只需要监听一个事件就行了。其次是针对参数类型进行封装，这样不需要使用很多的参数，当然这个是否是优点或者缺点也因人而异了

骑着毛驴去流浪
关注
专栏目录
[Unity] 事件分发系统
sarono的博客
04-11 845
[Unity] Utilities 之 MessageDispatcher 文章目录[Unity] Utilities 之 MessageDispatcher1.设计MessageListenerMessageDispatcher2.测试测试代码测试图片3.总结 参考资料： https://gpp.tkchu.me/event-queue.html Message Dispatcher插件 1...
事件分发机制--unity碰撞器的使用
12-28
对于事件分发机制的使用，当碰到物体时，会集中调用事件
Event-SendMessage:Unity事件分发机制，实现事件分发中心
05-21
Event-SendMessage Unity事件分发机制，实现事件分发中心 Unity5.0.1f1
unity 消息分发
luyuncsd123的专栏
06-22 4639
有2种方法，第一种，封装U3D中的发消息函数，自己写一个事件机制出来。第2种，用C#内置的事件机制。 第一种方法，下面这个类是Digital-tutors出的Unity Mobile Game Development这一套教程里06.Communication with Notification Center里的事件机制类，他是用JS写的，我把这个脚本翻译成了C#的。并加了详细的中文注释。本
Unity简单事件中心
最新发布
qq_40300093的博客
09-16 740
在Unity游戏开发中我们会遇到很多基于事件的交互，比如玩家拾取了某件物品、做了某件事，这些事件可能会造成一些后续效果，那么我们就要对能够造成后续效果的脚本传递对应的消息。当然就是通过传递事件来实现，那么我们就需要一个公共的事件中心来实现对事件触发、传递的功能。把事件管理器的一种实现方法，保存在这里防止以后忘记了。
【Unity】简单的事件分发系统
阿黄的博客
06-19 1006
/// /// 事件触发机制（CMD RPC） /// Dictionary dic = new Dictionary(); public void AddToDictionary(string key, Delegate d) { if (!dic.ContainsKey(key)) { d
Unity3d C#实现UGUI的界面可拖拽移动和选中置顶工程源码
08-03
Unity3D的Unity Graphical User Interface (UGUI)系统为开发者提供了强大的工具来创建丰富的交互式界面。本工程源码着重于利用C#编程语言实现UGUI界面的拖拽移动和选中置顶功能，极大地增强了用户体验。 首先，让...
Unity 3D背包系统源码解析与实现
3. Unity 3D背包系统实现：在Unity 3D中实现背包系统，需要使用C#编程语言。开发者需要编写代码来实现背包界面的设计、物品的添加和删除、物品的属性修改等功能。此外，还需要考虑背包系统的存储和管理机制，以确保...
高分项目，基于Unity3D开发实现的一方净土游戏，内含完整源码+资源+unitypackage
06-16
游戏中的社交功能，如聊天、组队、好友系统等，是通过Unity3D内置的网络系统和脚本编程实现的。开发者可能使用C#语言编写脚本来处理玩家间的交互，同时利用Unity的UI系统设计用户界面，让玩家可以方便地进行社交活动...
管理系统系列--Unity3D AssetBundle 打包与管理系统.zip
02-25
Unity3D AssetBundle打包与管理系统是游戏开发中的一个重要环节，它涉及到资源的高效管理、优化加载和更新。AssetBundle是Unity引擎提供的一种机制，用于将游戏中的资源（如模型、纹理、音频等）以独立的文件形式...
Unity3Dmingling.rar_Unity3d web_unity3d
09-24
7. 在线更新与内容分发：Unity3D支持在线更新功能，开发者可以随时发布新内容，玩家无需重新下载整个游戏。 综上所述，"Unity3Dmingling.pdf"这个文件可能包含了关于Unity3D如何处理图像、如何进行Web开发的详细...
unity 消息分发机制demo
01-23
使用委托与事件机制实现 Unity消息分发机制，此文件是一个unitypackage类型，可直接运行，unity版本号是5.6.1
Unity事件分发器
abc1090275833的博客
03-18 1046
事件分发机制也被称之为事件监听派发系统，在每个游戏框架中都是不可或缺的一个模块。起作用主要是用来解耦，监听网络消息，或者做一些异步的操作等，下面是使用C#在Unity游戏开发中的事件分发处理机制的简单实现，希望能帮到大家。 using UnityEngine; using System.Collections; using System.Collections.Generic; ...
Unity游戏开发之设计模式之事件分发系统
weixin_42422809的博客
12-07 1580
Unity游戏开发—事件系统 记得刚刚毕业时候，好不容易找到第一份工作，上班的第一天，主程就给我讲了游戏开发中最常见的几种设计模式，当时听得一头雾水。只知道事件分发，事件监听，事件注册。那么到底是怎么实现的呢？下面我们慢慢的揭开。 先了解一下什么是委托。这是C#基础，这里就不在陈述了。 了解什么观察者模式。简单的说：就是完美的将观察者和被观察的对象分离开，观察者设计模式定义了对象间的一种一...
silverlight 2.0 beta 2 之 blend 2.5 (12) 如何实现silverlight 2.0 在HTML上层透明显示
weixin_30932215的博客
07-30 116
如何让我们做的silverlight 在HTML上层透明显示,其实非常简单 当我们把一个默认的silverlight项目嵌入在Html中的代码.默认的silverlight背景为白色.代码如下所示 <objectdata="data:application/x-silverlight,"type="application/x-silverlight-2-b2"width...
Unity虚拟摇杆（事件分发器实现）
m0_52021450的博客
03-12 3922
目录 搭建UI 编写代码 搭建UI ①创建一个image 命名为ControlArea 作为按钮识别的检测范围 并将透明度设置为1（透明度为0不触发事件检测） ②如下图的父子关系添加 image 并命名 找到合适的素材拖给相应的image 设置合适的大小（根据自己的喜好和素材的大小自行设置） ③注意选中joystick 的 锚点（花）放到左下角 防止因为分辨率改变使得按钮位置改变 中心点（pivot）的位置设置为（0.5，0.5）如下图 实现脚本 ...
Unity 中不同方式的事件分发和监听
weixin_42565127的博客
01-05 784
Unity 中的事件分发和监听
关于对 Unity 3D Strange IoC 框架事件分发器的认识
ykr168age的专栏
02-06 827
------ ------ ------ ------ ------ ------ ------ ------ ------ ------ ------ ------ 关于事件分发器的认识 public IEventDispatcher dispatcher { get; set; } ------ ------ ------ ------ ------ ------
Unity 事件派发
极客七
01-25 571
方法 功能 备注 Watcher.on 注册监听 注册一个事件监听j Watcher.off 移除监听 移除一个事件监听 Watcher.Dispatch 派发事件 广播事件 前言: 由事件类和监听接口组成 自定义一个事件前，必须提供一个事件的监听方法以及一个事件标签。 好处: 各个模块专心的做自己的事情，不需要过问其他模块的事情 解耦 代码部分~ using System; using System.Col...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值