Unity中利用委托与监听解耦合的思路
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Unity中利用委托与监听解耦合的思路，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14625字，纯文字阅读大概需要21分钟。
内容图文
这篇随笔是一篇记录性的随笔，记录了从http://www.sikiedu.com/my/course/304，这门课程中学到的内容，附带了一些自己的思考。
一.单例模式的应用
首先假想一种情况，现在需要有一个按钮和一个Text,当按下按钮时，Text上显示“你好”两个字。
一个最常见的方法是在按钮下挂载一个脚本BtnClick，它持有一个Text组件，它由外部的Text拖入来赋值。
在初始化时BtnClick会获取当前游戏物体下的Button组件并为其添加监听，当按下按钮时会修改Text组件中的文本内容。
具体的效果图和代码如下：
using
System.Collections;
using
System.Collections.Generic;
using
UnityEngine;
using
UnityEngine.UI;
public
class
BtnClick : MonoBehaviour {
//
Use this for initialization
public
Text myText;
void
Awake ()
{
GetComponent<Button>().onClick.AddListener(()=>
{
myText.text = "你好";
});
}
}
BtnClick中为Button组件添加的监听的方法是用lambda表达式写的，不懂的自行查阅资料。
这种方式有两个问题，一是耦合度过高，假如Text组件不小心被删除，点击按钮会因为找不到Text组件而报错。 二是只能作一对一的操作，无法实现复杂的交互，举个例子，假如现在有3个如上图所示的按钮，同时只有1个Text，现在要实现一个“累加”的功能，任意一个按钮被按下时，计数会加1，当累计计数到3时，让按钮显示“你好”两个字。
假如修改代码如下：
using
System.Collections;
using
System.Collections.Generic;
using
UnityEngine;
using
UnityEngine.UI;
public
class
BtnClick : MonoBehaviour {
//
Use this for initialization
public
Text myText;
private
int
number;
void
Awake ()
{
GetComponent<Button>().onClick.AddListener(()=>
{
number++;
if (number >= 3)
{
myText.text = "你好";
}
});
}
}
此时对一个按钮按3下可以让按钮显示“你好”两个字，那如果我们复制3个相同的按钮，将Text组件拖放到3个按钮的BtnClick脚本中，是否可以满足要求？很显然，不行，因为定义的number属于类本身，3个脚本各自有属于自己的number，所以3个按钮的点击会分别叠加，没有累加效果。
那怎么办？难道要定义个全局变量来累加吗？那太蠢了，而且会很混乱。
我们先来解决问题二：
一个最常见的解决方法是为要操作的组件添加交互脚本，并在脚本中使用单例模式：
我们可以在Text组件下挂载一个脚本ShowText，脚本有一个计数器number,并提供一个Show方法，每次调用Show方法会增加计数，当计数满足条件时会获取Text组件并修改上面的内容。同时在按钮下挂载另一个脚本BtnClick，它在初始化时会获取Button组件并为其添加监听，当按下按钮时会调用ShowText脚本中的Show方法，这样可以起到累加的作用。
具体的效果图和代码如下：
using
System.Collections;
using
System.Collections.Generic;
using
UnityEngine;
using
UnityEngine.UI;
public
class
ShowText : MonoBehaviour
{
public
static
ShowText Instance;
private
int
number;
private
void
Awake()
{
Instance = this;
}
publicvoid Show(string str)
{
number++;
if (number >= 3)
{
GetComponent<Text>().text = str;
}
}
}
using
System.Collections;
using
System.Collections.Generic;
using
UnityEngine;
using
UnityEngine.UI;
public
class
BtnClick : MonoBehaviour {
//
Use this for initialization
void
Awake ()
{
GetComponent<Button>().onClick.AddListener(()=>
{
ShowText.Instance.Show("你好");
});
}
}
你可能会有疑惑，为什么要用单例模式？
要知道，我们这里之所以能实现累加，是因为3个Button的BtnClick都调用了同一个ShowText脚本中的Show方法，从而使计数能被累加。单例模式是为了保证3个BtnClick获取到的都是同一个ShowText实例对象。假如我们不用单例模式，BtnClick中点击事件的回调方法要想调用ShowText中的Show方法，就只能实例化一个对象,先不说Unity下继承自MonoBehaviour的类无法通过new来实例化，就算它可以，我们就只能这样做：
ShowText myShowText = new ShowText(); myShowText.Show();
显然，这种情况下3个按钮下BtnClick获取到的是3个不同的新创建的ShowText脚本，里面的number属性自然也无法一起累加，只能各自累加了。
虽然使用单例模式为我们解决了问题二，但仍没有解决问题一，若Text意外被删除，BtnClick会因为获取不到ShowText的单例对象而报错。
此外，即使不考虑问题一，我们考虑一种情况：假若现在不是3个按钮共同控制1个Text，而是1个按钮控制3个Text，当按下按钮时，需要让3个Text同时显示出"你好"。若用单例模式处理，在BtnClick的添加的监听方法中，需要获取每一个Text的单例对象，假若这一个按钮不只有这些Text要控制，还要控制许多其他的UI控件，那会使代码变得十分臃肿。
如何解决这两个问题？
其实这两个问题主要的症结在于当按钮被按下时，我们在按钮下挂载的脚本中直接去访问了Text组件，大大增加耦合度的同时使代码变得十分臃肿。那为了使按钮按下时不去直接访问Text组件，我们必须设计一层中间的过渡脚本，按钮按下时会到过渡脚本中访问Text组件中的方法，而且在过渡脚本中也不能直接访问Text组件下的脚本，否则一旦Text被删，一样会导致报错，但这是不可能的，过渡脚本若不访问Text组件下的脚本，怎么调用脚本中的方法呢？
我们可以退一步思考，若在Text被删的时候自动让过渡脚本知道，Text下挂载的脚本中的方法已经不存在，从而不再访问，而在Text被创建时也能让过渡脚本知道，此方法已经可以被调用了，是不是可以解决这两个问题呢？显然是的，这么做的话耦合度被大大降低，BtnClick只负责访问过渡脚本，过渡脚本中自己可以识别Text下挂载的脚本的方法是否存在，不存在就不调用，即使Text被意外删除，调用BtnClick也不会报错。
用什么机制来实现呢？用委托与监听来解决，使用委托是为了解决BtnClick关联到许多Text时需要获取很多单例带来的代码臃肿问题，委托可以看作一种函数指针，C#中可以把某些方法作为参数进行传递，参数的类型就是委托，而委托有一种很关键的特性，就是可以相加，一个委托+另一个委托，相当于同时关联了两个方法，调用这个委托时相当于同时对这两个方法进行调用。(当然，委托必须是同类型的才能叠加，比如方法的参数个数，类型要相等)，我们可以利用委托的这种特性完成一个BtnClick对许多ShowText脚本下方法的同时调用。
委托的简要介绍可以参考：http://www.runoob.com/csharp/csharp-delegate.html
二.利用委托与监听解耦合
现在来描述具体实现思路：
过渡脚本中维护一个字典，字典中存放事件码(作为键)和对应的委托(作为值)，事件码是一个枚举类型，由一个文件单独定义，每个事件码对应一种监听事件，比如按钮的点击，当有新的交互事件要定义时，可以手动添加新的事件码定义。字典中的值是委托类型，但委托对应的方法可以有参数，可以没参数，参数不同的委托无法相加，因此需要一个文件专门声明不同类型的委托，在过渡脚本中需要暴露3个方法，1个用来添加委托，这时就要作委托类型匹配的判断。另外一个用来移除委托，同样要类型验证，还要有一个广播方法，用来供按钮点击后调用，按钮点击时传递事件码，广播方法在字典中找到相应的委托并调用。
那什么时候进行委托的添加和移除呢？肯定是在Text初始化和销毁时，继承自MonoBehavior的类由Unity负责初始化和销毁，Unity初始化它时会调用Awake方法，销毁时会调用Destroy方法，我们在Awake时把供外部调用的方法添加到过渡脚本中的字典中，Destroy时从字典移除此委托，这就相当于让Unity来帮我们维护它们，这样，万一发生意外情况，Text被销毁了，Unity一定会调用Destroy，相应的委托就会从字典中消失，这样即使广播方法在字典中找不到对应的委托，也不至于报错，因为它并没有直接去获取并使用Text上的组件
这样，我们就需要3个文件，1个用来定义事件码，1个用来定义不同参数的委托，1个用来维护管理事件码委托的字典，并提供外部调用。
先来最简单的，事件码的文件的代码，文件名:EventType.cs，代码如下:
public
enum
EventType
{
ShowText
}
当前只添加了一个事件码，需要时可手动添加
随后是定义不同参数委托的文件，文件名:CallBack.cs,代码如下：
public
delegate
void
CallBack();
public
delegate
void CallBack<T>(T arg);
publicdelegatevoid CallBack<T, X>(T arg1, X arg2);
publicdelegatevoid CallBack<T, X, Y>(T arg1, X arg2, Y arg3);
publicdelegatevoid CallBack<T, X, Y, Z>(T arg1, X arg2, Y arg3, Z arg4);
publicdelegatevoid CallBack<T, X, Y, Z, W>(T arg1, X arg2, Y arg3, Z arg4, W arg5);
这里重载了6个同名的委托，使用泛型使委托可以适应更多的情况，这些委托覆盖了参数个数从0到5的所有情况，相应地，在添加委托到字典时，就要设计多个重载的AddListener和RemoveListener函数，以便在添加和删除委托时使用相应的方法。
下面是过渡脚本，文件名:EventCenter.cs,代码如下:
using
System;
using
System.Collections;
using
System.Collections.Generic;
using
UnityEngine;
public
class
EventCenter
{
private
static Dictionary<EventType, Delegate> m_EventTable = new Dictionary<EventType, Delegate>();
privatestaticvoid OnListenerAdding(EventType eventType, Delegate callBack)
{
if (!m_EventTable.ContainsKey(eventType))
{
m_EventTable.Add(eventType, null);
}
Delegate d = m_EventTable[eventType];
if (d != null && d.GetType() != callBack.GetType())
{
thrownew Exception(string.Format("尝试为事件{0}添加不同类型的委托，当前事件所对应的委托是{1}，要添加的委托类型为{2}", eventType, d.GetType(), callBack.GetType()));
}
}
privatestaticvoid OnListenerRemoving(EventType eventType, Delegate callBack)
{
if (m_EventTable.ContainsKey(eventType))
{
Delegate d = m_EventTable[eventType];
if (d == null)
{
thrownew Exception(string.Format("移除监听错误：事件{0}没有对应的委托", eventType));
}
elseif (d.GetType() != callBack.GetType())
{
thrownew Exception(string.Format("移除监听错误：尝试为事件{0}移除不同类型的委托，当前委托类型为{1}，要移除的委托类型为{2}", eventType, d.GetType(), callBack.GetType()));
}
}
else
{
thrownew Exception(string.Format("移除监听错误：没有事件码{0}", eventType));
}
}
privatestaticvoid OnListenerRemoved(EventType eventType)
{
if (m_EventTable[eventType] == null)
{
m_EventTable.Remove(eventType);
}
}
//no parameterspublicstaticvoid AddListener(EventType eventType, CallBack callBack)
{
OnListenerAdding(eventType, callBack);
m_EventTable[eventType] = (CallBack)m_EventTable[eventType] + callBack;
}
//Single parameterspublicstaticvoid AddListener<T>(EventType eventType, CallBack<T> callBack)
{
OnListenerAdding(eventType, callBack);
m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] + callBack;
}
//two parameterspublicstaticvoid AddListener<T, X>(EventType eventType, CallBack<T, X> callBack)
{
OnListenerAdding(eventType, callBack);
m_EventTable[eventType] = (CallBack<T, X>)m_EventTable[eventType] + callBack;
}
//three parameterspublicstaticvoid AddListener<T, X, Y>(EventType eventType, CallBack<T, X, Y> callBack)
{
OnListenerAdding(eventType, callBack);
m_EventTable[eventType] = (CallBack<T, X, Y>)m_EventTable[eventType] + callBack;
}
//four parameterspublicstaticvoid AddListener<T, X, Y, Z>(EventType eventType, CallBack<T, X, Y, Z> callBack)
{
OnListenerAdding(eventType, callBack);
m_EventTable[eventType] = (CallBack<T, X, Y, Z>)m_EventTable[eventType] + callBack;
}
//five parameterspublicstaticvoid AddListener<T, X, Y, Z, W>(EventType eventType, CallBack<T, X, Y, Z, W> callBack)
{
OnListenerAdding(eventType, callBack);
m_EventTable[eventType] = (CallBack<T, X, Y, Z, W>)m_EventTable[eventType] + callBack;
}
//no parameterspublicstaticvoid RemoveListener(EventType eventType, CallBack callBack)
{
OnListenerRemoving(eventType, callBack);
m_EventTable[eventType] = (CallBack)m_EventTable[eventType] - callBack;
OnListenerRemoved(eventType);
}
//single parameterspublicstaticvoid RemoveListener<T>(EventType eventType, CallBack<T> callBack)
{
OnListenerRemoving(eventType, callBack);
m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] - callBack;
OnListenerRemoved(eventType);
}
//two parameterspublicstaticvoid RemoveListener<T, X>(EventType eventType, CallBack<T, X> callBack)
{
OnListenerRemoving(eventType, callBack);
m_EventTable[eventType] = (CallBack<T, X>)m_EventTable[eventType] - callBack;
OnListenerRemoved(eventType);
}
//three parameterspublicstaticvoid RemoveListener<T, X, Y>(EventType eventType, CallBack<T, X, Y> callBack)
{
OnListenerRemoving(eventType, callBack);
m_EventTable[eventType] = (CallBack<T, X, Y>)m_EventTable[eventType] - callBack;
OnListenerRemoved(eventType);
}
//four parameterspublicstaticvoid RemoveListener<T, X, Y, Z>(EventType eventType, CallBack<T, X, Y, Z> callBack)
{
OnListenerRemoving(eventType, callBack);
m_EventTable[eventType] = (CallBack<T, X, Y, Z>)m_EventTable[eventType] - callBack;
OnListenerRemoved(eventType);
}
//five parameterspublicstaticvoid RemoveListener<T, X, Y, Z, W>(EventType eventType, CallBack<T, X, Y, Z, W> callBack)
{
OnListenerRemoving(eventType, callBack);
m_EventTable[eventType] = (CallBack<T, X, Y, Z, W>)m_EventTable[eventType] - callBack;
OnListenerRemoved(eventType);
}
//no parameterspublicstaticvoid Broadcast(EventType eventType)
{
Delegate d;
if (m_EventTable.TryGetValue(eventType, out d))
{
CallBack callBack = d as CallBack;
if (callBack != null)
{
callBack();
}
else
{
thrownew Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
}
}
}
//single parameterspublicstaticvoid Broadcast<T>(EventType eventType, T arg)
{
Delegate d;
if (m_EventTable.TryGetValue(eventType, out d))
{
CallBack<T> callBack = d as CallBack<T>;
if (callBack != null)
{
callBack(arg);
}
else
{
thrownew Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
}
}
}
//two parameterspublicstaticvoid Broadcast<T, X>(EventType eventType, T arg1, X arg2)
{
Delegate d;
if (m_EventTable.TryGetValue(eventType, out d))
{
CallBack<T, X> callBack = d as CallBack<T, X>;
if (callBack != null)
{
callBack(arg1, arg2);
}
else
{
thrownew Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
}
}
}
//three parameterspublicstaticvoid Broadcast<T, X, Y>(EventType eventType, T arg1, X arg2, Y arg3)
{
Delegate d;
if (m_EventTable.TryGetValue(eventType, out d))
{
CallBack<T, X, Y> callBack = d as CallBack<T, X, Y>;
if (callBack != null)
{
callBack(arg1, arg2, arg3);
}
else
{
thrownew Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
}
}
}
//four parameterspublicstaticvoid Broadcast<T, X, Y, Z>(EventType eventType, T arg1, X arg2, Y arg3, Z arg4)
{
Delegate d;
if (m_EventTable.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
{
thrownew Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
}
}
}
//five parameterspublicstaticvoid Broadcast<T, X, Y, Z, W>(EventType eventType, T arg1, X arg2, Y arg3, Z arg4, W arg5)
{
Delegate d;
if (m_EventTable.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
{
thrownew Exception(string.Format("广播事件错误：事件{0}对应委托具有不同的类型", eventType));
}
}
}
}
这里有很多要注意的点：
1.先看AddListener系列的方法，6个方法分别对应传入6种不同参数个数的委托，之所以每个里面要分两步完成，是为了进行代码精简，OnListenerAdding将6种AddListener的相同部分抽取了出来，注意为了实现抽取使用了多态，用Delegate容纳不同CallBack参数。
简单讲述下AddListener的逻辑：
1.先判断字典中有无对应事件码，没有就添加新的，新的事件码对应的的委托方法设为null
2.取出事件码对应的委托，如果这个委托不是null，且它的类型和传入的CallBack类型不同，则抛出异常。
3.经历了以上两步，显然此时事件码对应的委托要不就是null，要不就是和传入的CallBack类型相同，此时根据AddListener的不同将事件码对应的委托转换 成相同的类型并进行相加，重新赋回到字典中的对应项。
这里有一点很关键：仔细想，为什么我们要把AddListener分成那么多类型，传入不同的CallBack,能不能利用多态，第二个参数能不能直接传入Delegate？
答案是不行，因为上面的第2步会将字典中的相应Delegate与传入的CallBack进行类型比较，在同类型的情况下，第3步会把事件码对应的委托转换成传入的CallBack的类型并加回到字典中，假如传入的就是Delegate,那在第3步根本不存在类型转换，那存入字典的就一定是Delegate类型，那就根本没法在下一个第2步找出类型不同的情况。
同理，叙述一下RemoveListener的逻辑：
1.先判断字典中有无对应事件码，没有就直接抛出异常。
2.有的话取出事件码对应的委托，如果这个委托为null，抛出异常。如果不为null且它的类型和传入的CallBack类型不同，也抛出异常。
3.经历了以上两步，显然此时事件码对应的委托一定和传入的CallBack类型相同，此时根据AddListener的不同将事件码对应的委托转换成相同的类型并进行相减。
4.减完后要判断事件码对应的委托是不是null，是的话移除事件码及对应的委托。
BroadCast也一样要分多种参数类型，因为有可能要传入不同数量的参数，BroadCast的逻辑：
1.用TryGet获取对应事件码的委托，若获取失败不做任何操作(这一条保证了不会报错)
2.若获取成功，将此委托强转为对应的CallBack，这一条很重要，这就是为什么BroadCast也要分多种参数类型原因，不分的话，不知道要把委托转换成哪种具体的CallBack，而以Delegate为类型，自然无法调用相应的参数。
3.判断强转的CallBack是不是null，是代表强转失败，这是因为事件码对应的委托的参数并不是此类BroadCast能处理的，此时要抛出异常。
4.若CallBack不是null，代表强转成功，直接调用方法即可。
接下来给出测试用的ShowText脚本(挂载在Text组件上)和BtnClick脚本(挂载在按钮上)
using
System.Collections;
using
System.Collections.Generic;
using
UnityEngine;
using
UnityEngine.UI;
public
class
ShowText : MonoBehaviour
{
private
void
Awake()
{
gameObject.SetActive(
false
);
EventCenter.AddListener<string, string, float, int, int>(EventType.ShowText, Show);
}
privatevoid OnDestroy()
{
EventCenter.RemoveListener<string, string, float, int, int>(EventType.ShowText, Show);
}
privatevoid Show(string str,string str1,float a, int b, int c)
{
gameObject.SetActive(true);
GetComponent<Text>().text = str + str1 + a + b + c;
}
}
using
System.Collections;
using
System.Collections.Generic;
using
UnityEngine;
using
UnityEngine.UI;
public
class
BtnClick : MonoBehaviour {
//
Use this for initialization
private
void
Awake ()
{
GetComponent<Button>().onClick.AddListener(()=>
{
EventCenter.Broadcast(EventType.ShowText,"你好","呀",1.0f,1,2);
});
}
}
这个没什么好说的，ShowText在Awake时把Show方法(这里用5个参数的作演示)添加到字典，在Destroy中作移除。
BtnClick在被点击时调用BroadCast并传入相应的参数。
有一点要注意:AddListener的调用要明确指明使用的泛型，<string,string,float,int,int>，若直接
EventCenter.AddListener(EventType.ShowText, Show);
会报错，这是因为不同版本的AddListener参数个数是相同的，因此调用时若不指定调用的AddListener版本，程序不知道调用哪个。RemoveListener也是同理。但是，对BroadCast的调用则不必指定版本，因为不同版本的BroadCast参数个数不同，根据传入的参数个数，程序能自动识别调用哪个版本的BroadCast。
这种利用委托和监听解耦合的思路也是有缺点的，就是调用时顺序必须匹配，若ShowText以<string,string,float,int,int>的方式添加了委托，则调用时也必须以同样的顺序传入参数，而我们事先无法得知具体的顺序是怎样的，要在BtnClick实现调用，就只能通过跳转代码，跳转到ShowText的源代码中去了解调用顺序。
另外，我自己的看法是，这种方式可能会破坏封装性，因为ShowText中的Show方法，在ShowText中是被定义为private的，而这个方法又在ShowText被初始化的时候作为委托被添加到了EventCenter中的字典里，按下按钮时根据事件码从字典中找到对应的委托并调用，相当于在ShowText类外部可以随意对类内的私有private方法进行随意调用，安全性似乎有点问题。但这不是由这种思路带来的，而是委托机制本身带来的缺陷，抛开这门课不讲，一个方法可以通过委托传递可以让人接受，但一个类中的私有方法可以通过委托被传递，从而供外部函数随意调用，就有点奇怪了，在我看来，至少也应该设计成只有类中的公有方法才能通过委托传递才对啊，C#里的这种委托机制真的不会带来安全性的隐患吗？这只是我的一点小疑惑，可能是目前对委托的理解不够深，等以后明白了再回来填坑吧。
原文：https://www.cnblogs.com/czw52460183/p/10494285.html
内容总结
以上是互联网集市为您收集整理的Unity中利用委托与监听解耦合的思路全部内容，希望文章能够帮你解决Unity中利用委托与监听解耦合的思路所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。