在上一篇，我们接触了单例，使用单例解决了我们脚本之间访问的问题。
脚本之间访问其实有更好的方式。
我们先分下脚本访问脚本的几种形式。
第一种，A GameObject 是 B GameObject 的 Parent，或者是中间隔着几个层级的 Parent。
那这种情况下，如果 A 脚本想调用 B 脚本的方法，直接通过 transform.Find(“XXX/YYY/ZZZ”).GetComponent<B>().DoSomething() 就可以了。
但是如果是 B 脚本想调用 A 脚本的方法，比较好的方式呢，是在 B 脚本中声明委托，然后在 A 中注册特定方法。当 B 想调用 A 脚本的方法的时候，通过委托通知就好。
除了使用委托，也可以使用消息机制，Unity 本身实现了一套消息机制，比如在 B 脚本中可以使用, this.SendMessageUpward(“MethedName”) 这样的方式。不过这种方式由于是使用字符串，并且可能用到了反射，所以网上大部分博客都不太推荐使用，但是也算是个不错的方式。
第二种情况呢是，A GameObject 和 B GameObject 是同级的，比如他们有共同的 Parent。这种情况下，笔者还是推荐用消息机制，不过不是 Unity 自带的消息机制，而是自己实现的消息机制。
第三种情况是，A GameObject 和 B GameObject 不在同一个 GameObject 树下。那么这种情况很可能就是跨模块通信了，这种情况下，还是推荐用消息机制。
所以，我们可以试试使用消息机制来解决我们的问题。
可是我们目前手里没有消息机制…
那就造一个吧。
消息机制要用到的知识:
- List 或 LinkedList 或者自己实现的链表。
- Dictionary
- 委托
关于第一条，我们选择 List 就好了，不过为了有更高的效率，我们最后会升级成链表。第三条，我们选择 Action，因为这是我们接触过的，以后也是用的比较多的。
而一般的消息机制会提供三个 API。
- 注册事件
- 注销事件
- 发送事件
我们先试着设计一下，假如我们想这样使用我们的 API
MsgDispatcher.Register("消息名",(obj)=>{ /* 处理消息 */ });
MsgDispatcher.Send("消息名","消息内容");
MsgDispatcher.UnRegister("消息名");
首先事件名，是一个字符串类型的，而事件名要对应一个委托。我们声明一个静态的字典变量就好了。
private static Dictionary<string, Action<object>> RegisteredMsgs = new Dictionary<string, Action<object>>();
为什么是静态的呢？因为，我们的消息机制呢不需要创建实例，而消息是要在整个项目内之间通信的，也就是全局的消息。全局的消息就需要放在唯一容器里注册。而这个容器就是我们的这个字典变量。
我们先实现注册事件功能。
public static void Register(string msgName, Action<object> onMsgReceived)
{
RegisteredMsgs.Add(msgName, onMsgReceived);
}
非常简单。
我们再实现注销功能。
public static void UnRegister(string msgName)
{
RegisteredMsgs.Remove(msgName);
}
也非常简单。
再实现发送功能。
public static void Send(string msgName, object data)
{
RegisteredMsgs[msgName](data);
}
非常简单。
第十二个示例代码如下:
using System;
using System.Collections.Generic;
using UnityEngine;
namespace QFramework
{
public class MsgDispatcher
{
private static Dictionary<string, Action<object>> RegisteredMsgs = new Dictionary<string, Action<object>>();
public static void Register(string msgName, Action<object> onMsgReceived)
{
RegisteredMsgs.Add(msgName, onMsgReceived);
}
public static void UnRegister(string msgName)
{
RegisteredMsgs.Remove(msgName);
}
public static void Send(string msgName, object data)
{
RegisteredMsgs[msgName](data);
}
#if UNITY_EDITOR
[UnityEditor.MenuItem("QFramework/12.简易消息机制", false, 13)]
#endif
private static void MenuClicked()
{
Register("消息1", data => { Debug.LogFormat("消息1:{0}", data); });
Send("消息1", "hello world");
UnRegister("消息1");
Send("消息1", "hello");
}
}
}
菜单执行结果如下
哈哈哈，报错啦，不过我们发现，第一次消息发送成功了，但是第二次发送的时候报错了。是因为消息进行注销了，也就是字典里没有消息名了，这时候直接从字典里取值当然会报错。
这个问题我们留在下一篇解决，在下一篇，我们要讲解关于这个消息机制的完善。
第十二个示例还没有完成。
集成到 MonoBehaviourSimplify 里。
还记得我们的简易消息机制是为了解决什么问题诞生的嘛？
是为了解决脚本间访问的问题。
我们回过头再看下 A 脚本如果想访问 B 脚本，使用消息机制，如何实现。
代码如下:
public class A : MonoBehaviour
{
void Update()
{
if(Input.GetMouseButtonDown(0))
{
MsgDispatcher.Send("DO","ok");
}
}
}
public class B : MonoBehaviour
{
void Awake()
{
MsgDispatcher.Register("DO",DoSomething);
}
void DoSomething(object data)
{
// do something
}
void OnDestroy()
{
MsgDispatcher.UnRegiter("DO",DoSomething);
}
}
用法还是很简单的。
不过假如我们的 B 脚本注册了非常多的消息，代码会变成如下:
public class B : MonoBehaviour
{
void Awake()
{
MsgDispatcher.Register("DO",DoSomething);
MsgDispatcher.Register("DO1",MsgReceiver);
MsgDispatcher.Register("DO2",MsgReceiver1);
MsgDispatcher.Register("DO3",MsgReceiver2);
}
void DoSomething(object data)
{
// do something
}
...
void OnDestroy()
{
MsgDispatcher.UnRegiter("DO",DoSomething);
MsgDispatcher.UnRegiter("DO1",MsgReceiver);
MsgDispatcher.UnRegiter("DO2",MsgReceiver1);
MsgDispatcher.UnRegiter("DO3",MsgReceiver2);
}
}
每次注册一个消息，对应地，在 OnDestroy 操作的时候就要注销一个事件。这个非常像我们写 C++ 的时候遵循的一个内存管理法则，每次申请内存就要在析构方法里进行释放。
而这样使用消息机制，初学者非常容易忘记消息的注销，从而导致引用异常等等。
那么如何解决呢？
用一个 Dictionary 记录这个脚本中已经注册过的消息，以及消息名对应的回调。
代码如下:
public class B : MonoBehaviour
{
Dictionary<string,Action<object>> mMsgRegisterRecorder = new Dictionary<string,Action<object>>();
void Awake()
{
MsgDispatcher.Register("DO",DoSomething);
mMsgRegisterRecorder.Add("DO",DoSomething);
MsgDispatcher.Register("DO1",MsgReceiver);
mMsgRegisterRecorder.Add("DO1",MsgReceiver);
MsgDispatcher.Register("DO2",MsgReceiver1);
mMsgRegisterRecorder.Add("DO2",MsgReceiver1);
MsgDispatcher.Register("DO3",MsgReceiver2);
mMsgRegisterRecorder.Add("DO3",MsgReceiver2);
}
void DoSomething(object data)
{
// do something
}
...
void OnDestroy()
{
foreach (var keyValuePair in mMsgRegisterRecorder)
{
MsgDispatcher.UnRegister(keyValuePair.Key,keyValuePair.Value);
}
mMsgRegisterRecorder.Clear();
}
}
这样，不管注册了多少个消息，只要在 OnDestroy 的时候， 进行一个遍历，这样消息就全部注销掉了。
但是这样写的话注册，就变得麻烦了，每次注册要先两行代码。
MsgDispatcher.Register("DO3",MsgReceiver2);
mMsgRegisterRecorder.Add("DO3",MsgReceiver2);
把两行提取成一个方法就好了。
提取的方法，代码如下:
private void RegisterMsg(string msgName, Action<object> onMsgReceived)
{
MsgDispatcher.Register(msgName, onMsgReceived);
mMsgRegisterRecorder.Add(msgName, onMsgReceived);
}
而注册消息的代码就会变成如下:
private void Awake()
{
RegisterMsg("Do",DoSomething);
RegisterMsg("DO1",MsgReceiver);
RegisterMsg("DO2", _=>{ });
RegisterMsg("DO3", _=>{ });
}
是不是精简了很多，而且也可以注册 Lambda 表达式了。
不过我们看下现在的 B 脚本全部代码:
public class B : MonoBehaviour
{
Dictionary<string, Action<object>> mMsgRegisterRecorder = new Dictionary<string, Action<object>>();
private void Awake()
{
RegisterMsg("Do",DoSomething);
RegisterMsg("DO1",_=>{ });
RegisterMsg("DO2", _=>{ });
RegisterMsg("DO3", _=>{ });
}
private void RegisterMsg(string msgName, Action<object> onMsgReceived)
{
MsgDispatcher.Register(msgName, onMsgReceived);
mMsgRegisterRecorder.Add(msgName, onMsgReceived);
}
void DoSomething(object data)
{
// do something
}
private void OnDestroy()
{
foreach (var keyValuePair in mMsgRegisterRecorder)
{
MsgDispatcher.UnRegister(keyValuePair.Key,keyValuePair.Value);
}
mMsgRegisterRecorder.Clear();
}
}
目前，每个要使用相同消息策略的脚本，都实现如上的代码，会产生很多的重复代码。所以这里我们要开始考虑如何让这个消息注册/注销的策略进行复用。首先用静态方法是不可能了，因为这个策略是有状态的（成员变量）。所以以我们目前掌握的知识来看，只能用继承的方式了。
继承也有两种，一种是继承一个新类，另一种是继承到 MonoBehaviourSimplify 里。
笔者选择后者，这样我们的脚本只要继承 MonoBehaviourSimplify 就会获得 API 简化和消息功能了，一举多得，而且很方便。
集成后的代码，也就是第十三个示例的代码如下:
using System;
using System.Collections.Generic;
namespace QFramework
{
public abstract partial class MonoBehaviourSimplify
{
Dictionary<string, Action<object>> mMsgRegisterRecorder = new Dictionary<string, Action<object>>();
protected void RegisterMsg(string msgName, Action<object> onMsgReceived)
{
MsgDispatcher.Register(msgName, onMsgReceived);
mMsgRegisterRecorder.Add(msgName, onMsgReceived);
}
private void OnDestroy()
{
OnBeforeDestroy();
foreach (var keyValuePair in mMsgRegisterRecorder)
{
MsgDispatcher.UnRegister(keyValuePair.Key,keyValuePair.Value);
}
mMsgRegisterRecorder.Clear();
}
protected abstract void OnBeforeDestroy();
}
public class B : MonoBehaviourSimplify
{
private void Awake()
{
RegisterMsg("Do", DoSomething);
RegisterMsg("DO1", _ => { });
RegisterMsg("DO2", _ => { });
RegisterMsg("DO3", _ => { });
}
void DoSomething(object data)
{
// do something
}
protected override void OnBeforeDestroy()
{
}
}
}
在以上代码里，笔者把 MonoBehaviourSimplify 添加了 abstract 关键字，这样用户在使用 MonoBehaviourSimplify 的时候就不能自己创建出来实例了。
而又添加了如下抽象方法:
protected abstract void OnBeforeDestroy();
做这步的目的呢，是为了提醒子类不要覆写了 OnDestroy。提醒是怎么做到的呢。
我们通过分析可以得出，使用 MonoBehaviourSimplify 的情况有两种。
一种是，在写脚本之前就想好了这个脚本要继承 MonoBehaviourSimplify，但是继承之后，编译会报错，因为有一个抽象方法，必须实现，也就是 OnBeforeDestroy。那么实现了这个，用户就会知道设计 MonoBehaviourSimplify 的人，是推荐用 OnBeforeDestroy 来做卸载逻辑的，并不推荐用 OnDestroy。这是第一种。
第二种呢，脚本本来就有了，但是在中途想要换成继承 MonoBehaviourSimplify，继承了之后，同样报错了，报错了之后发现 MonoBehaviourSimplify 推荐用 OnBeforeDestroy 来做卸载逻辑，这时候如果以前的脚本已经有了 OnDestroy 逻辑，用户就会把 OnDestroy 的逻辑迁移到 OnBeforeDestroy 里。这样也算达到了一个提醒的作用。
这就是 OnBeforeDestroy 的设计初衷，而 abstract 关键字，就应该这样用。
但是到这里呢，这套策略还是有一点小问题的。这个小问题就留在下一篇讲了。
今天的内容就这些，我们下一篇再见。
转载请注明地址：凉鞋的笔记：liangxiegame.com
更多内容
-
QFramework 地址：https://github.com/liangxiegame/QFramework
-
QQ 交流群：623597263
-
Unity 进阶小班：
- 主要训练内容：
- 框架搭建训练（第一年）
- 跟着案例学 Shader（第一年）
- 副业的孵化（第二年、第三年）
- 权益、授课形式等具体详情请查看《小班产品手册》：https://liangxiegame.com/master/intro
- 主要训练内容：
-
关注公众号：liangxiegame 获取第一时间更新通知及更多的免费内容。
