Unity系统消息广播

# 1.前言
Unity自带消息系统，如SendMessage等，此方法利用的反射，且会反射游戏物体上的全部组件，对性能不友好。并且因为参数为方法名称，因此若是使用代码混淆，则会没法调用 方法，且难以追踪问题。通常消息发送采用事件或者委托进行。可是对于一些跨线程操做，或者涉及系统底层（通常也再也不主线程）消息时也会更新UI（确切的说是渲染问题）错误。因此在此基于脚本update方法，造成一个统一的消息机制。

# 2.消息系统组成
主要有三部分组成，消息中心、消息处理器和消息通道。
## 2.1 消息中心
此部分主要用来管理消息，包括存储、注册等。

```csharp
using System;
using System.Collections.Generic;
using UnityEngine;

namespace MSG
{
public delegate void MessageHandler(Message message);

public class MessageCenter
{
#region Instance
private static MessageCenter instance;
private static MessageProcessor messageProcessor;
private static bool instanceCreated = false;

public static MessageCenter GetInstance()
{
if (!instanceCreated)
{
instance = new MessageCenter();

GameObject processor = new GameObject("MessageProcessor");
messageProcessor = processor.AddComponent<MessageProcessor>();
instanceCreated = true;
}

return instance;
}

private MessageCenter() { }
#endregion

private Dictionary<MsgChannel, MessageHandler> messageHandlers = new Dictionary<MsgChannel, MessageHandler>();
private Queue<Message> messageQueue = new Queue<Message>();

public void BroadcastMessage(Message message)
{
messageQueue.Enqueue(message);
}

public Message PostMessage()
{
Message message = null;

if (messageQueue.Count != 0)
{
message = messageQueue.Dequeue();
}
return message;
}

public void RegisterMessageHandler(MsgChannel type,MessageHandler messageHandler)
{
MessageHandler handler = null;
bool exist = messageHandlers.TryGetValue(type, out handler);

if (!exist)
{
Debug.Log("Add message handler " + messageHandler.Method.Name);
messageHandlers.Add(type, messageHandler);
}
else
{
//若是已经注册，则不会重复注册
Delegate[] handlers = handler.GetInvocationList();
if (Array.IndexOf(handlers, messageHandler) == -1)
{
Debug.Log("Plus message handler " + messageHandler.Method.Name);
handler += messageHandler;
messageHandlers[type] = handler;
}
}
}

public void UnregisterMessageHandler(MsgChannel type,MessageHandler messageHandler)
{
MessageHandler handler;
bool exist = messageHandlers.TryGetValue(type, out handler);

if (exist)
{
handler -= messageHandler;

if (handler == null)
{
Debug.Log("Message handler to be unregistered is null now" + messageHandler.Method.Name);
messageHandlers.Remove(type);
}
else
{
Debug.Log("Message handler to be unregistered is unregistered " + messageHandler.Method.Name);
messageHandlers[type] = handler;
}
}
}

public MessageHandler GetMessageHandler(MsgChannel type)
{
MessageHandler handler;
messageHandlers.TryGetValue(type, out handler);

return handler;
}
}
}
```
## 2.2 消息处理器
此部分功能负责发送消息。

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace MSG
{
public class MessageProcessor : MonoBehaviour
{
public bool ProcessorActive = true;

private void ProcessMessages()
{
Message message = MessageCenter.GetInstance().PostMessage();

if (message != null)
{
MessageHandler handler = MessageCenter.GetInstance().GetMessageHandler(message.what);

if (handler != null)
{
handler(message);
}
}
}

private void Update()
{
ProcessMessages();
}
}
}

```
## 2.3 消息通道
消息通道为枚举类型，决定了此消息经过什么通道发送，可自行添加。并经过Message类及其子类传递参数

```csharp
using UnityEngine;

namespace MSG
{
public enum MsgChannel
{
NONE = 0,
TEST_MSG1 = 1,
TEST_MSG2 = 2
}

/// <summary>
/// Base Message class imitating android Message class.
/// arg一、arg2 and message are used to store simple values.
/// </summary>
public class Message
{
public MsgChannel what = MsgChannel.NONE;
public int arg1 = 0;
public int arg2 = 0;
public string message;

public Message(MsgChannel what, int arg1 = 0, int arg2 = 0, string message = "")
{
this.what = what;
this.arg1 = arg1;
this.arg2 = arg2;
this.message = message;
}

public Message() { }
}

/// <summary>
/// Extend Message class and carry more infomation
/// </summary>
public class NetworkMessage : Message
{
public Texture2D t2d;

public NetworkMessage(MsgChannel what,Texture2D t2d, int arg1 = 0, int arg2 = 0, string message = "")
:base(what,arg1,arg2,message)
{
this.t2d = t2d;
}
}
}

```
## 2.4 问题标记
MessageCenter的单例采用以下，是出于如下几点考虑。

```csharp
#region Instance
private static MessageCenter instance;
private static MessageProcessor messageProcessor;
private static bool instanceCreated = false;

public static MessageCenter GetInstance()
{
if (!instanceCreated)
{
instance = new MessageCenter();

GameObject processor = new GameObject("MessageProcessor");
messageProcessor = processor.AddComponent<MessageProcessor>();
GameObject.DontDestroyOnLoad(messageProcessor);
instanceCreated = true;
}

return instance;
}

private MessageCenter() { }
#endregion
```
### 2.4.1 MessageProcessor可能会被销毁
GameObject.DontDestroyOnLoad(messageProcessor);来实现不被销毁
### 2.4.2 最初方案引起的问题
最初方案以下：

```csharp
#region Instance
private static MessageCenter instance;
private static MessageProcessor messageProcessor;

private static bool instanceCreated = false;

public static MessageCenter GetInstance()
{
if (!instanceCreated)
{
instance = new MessageCenter();

//GameObject processor = new GameObject("MessageProcessor");
//messageProcessor = processor.AddComponent<MessageProcessor>();
instanceCreated = true;
}

if (messageProcessor == null)
{
GameObject processor = new GameObject("MessageProcessor");
messageProcessor = processor.AddComponent<MessageProcessor>();
}

return instance;
}

private MessageCenter() { }
#endregion
```
最初方案中instance和messageProcessor是单独处理的，可是在使用过程当中，在OnDisable方法中调用了MessageCenter的单例（如3.调用方法）。则当unity关闭，随机销毁对象时，若是MessageCenter先销毁，在销毁MessageProcessor时，则会在OnDestroy方法中先调用OnDisable方法。此时会从新生成MessageCenter的单例，此时就会报以下错误：
**Some objects were not cleaned up when closing the scene. (Did you spawn new GameObjects from OnDestroy?**

### 2.4.3 矛盾问题
一、要想MessageProcessor一直存在，则须要当其为空时从新生成，但在关闭应用时报错。
二、不从新生成MessageProcessor，场景加载时杀掉MessageProcessor，则消息没法传递。
三、将messageProcessor独立出来，不在MessageCenter中生成。并加DontDestroyOnLoad方法。此时若是场景从新加载则会有两个MessageProcessor。

**虽然存在一些矛盾，可是能够经过场景加载时采用Additive方式，或者其余方法，找到适合本身工程的处理手段。**

# 3.调用方法

```csharp
using MSG;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class MessageSystemTest : MonoBehaviour
{
public Button button;

private void Start()
{
button.onClick.AddListener(() =>
{
MessageCenter.GetInstance().BroadcastMessage(new Message(MsgChannel.TEST_MSG1, 111));
MessageCenter.GetInstance().BroadcastMessage(new Message(MsgChannel.TEST_MSG1, 111));
MessageCenter.GetInstance().BroadcastMessage(new NetworkMessage(MsgChannel.TEST_MSG2, null));
});
}

void OnEnable ()
{
MessageCenter.GetInstance().RegisterMessageHandler(MsgChannel.TEST_MSG1, Method);
MessageCenter.GetInstance().RegisterMessageHandler(MsgChannel.TEST_MSG1, Method1);
MessageCenter.GetInstance().RegisterMessageHandler(MsgChannel.TEST_MSG2, Method2);
}

private void OnDisable()
{
MessageCenter.GetInstance().UnregisterMessageHandler(MsgChannel.TEST_MSG1, Method);
MessageCenter.GetInstance().UnregisterMessageHandler(MsgChannel.TEST_MSG1, Method1);
MessageCenter.GetInstance().UnregisterMessageHandler(MsgChannel.TEST_MSG2, Method2);
}

void Method(Message message)
{
Debug.LogFormat("Method : Message -{0}- obtained from channel {1}", message.arg1, message.what);
}

void Method1(Message message)
{
Debug.LogFormat("Method1 : Message -{0}- obtained from channel {1}", message.arg1, message.what);
}

void Method2(Message message)
{
NetworkMessage networkMessage = message as NetworkMessage;

if(networkMessage != null)
{
Debug.LogFormat("NetworkMessage obtained from channel {0}", message.what);
}
}
}

```