Unity Practical framework （ 3、 ... and ） The event system

stay Unity Based on the event registration provided , Implement a more flexible event system .

Event

First , Define a common event base class for all possible events . The base class contains ： The originator of the incident （UNITY object ）、 How to respond （ Synchronous or asynchronous ） And whether the event is destroyed after processing .

public abstract class Event : IDisposable
{
    private GameObject publisher;
    private bool responce;
    private bool disposeAfterUsed;
}

that , Any type should inherit from Event, It can be used as an event in MessageSystem Release and monitor inside . Of course , If each event has a separate type , It may make the number of classes too large , All events under the same module can be encapsulated into one Event Among the subclasses of , Then perform secondary search through string or enumeration . For example, the following way ：

public class NetWorkConnectionEvent : Event{
    ...
    enum Type{
        EventType1,
        EventType2,
        ...
    } 
    ...
}

If you use this way of writing ,MessageSystem It will be more complicated , For convenience , Let's assume that all events are inherited from Event, Every Event Represents and only represents one event .

IEventListener

A type implements the interface , To show that you are a type that can listen for events . This interface needs to implement the listening function

public interface IEventListener
{
    bool OnEvent(Event e);
}

MessageSystem

Subscribe/Unsubscribe

A basic event system should at least be able to publish and subscribe events . First , We define the following lists , To store subscriber information .

private Dictionary<Event, List<IEventListener>> Listeners;
private List<KeyValuePair<Event, IEventListener> subscribeRequests;
private List<KeyValuePair<Event, IEventListener> > unsubscribeRequests

Dictionaries Listeners Stores all listeners registered to an event , The usage is very clear , So what's the use of the following two lists ？ Because there will be dynamic event registration and deregistration at any time in the scene , therefore , The following two variables are used in MessageSystem.Update Function , The newly registered Listener Update to Listener in , Or from Listener Remove . When Listener One of the Key Corresponding Value It's empty time ( That is, a certain one. Event Not registered by any listener ), So this KEY Will be removed , Accordingly , And if the newly registered listener finds Listener There is no corresponding Event, A corresponding Key. With this dynamic registration method , It can avoid a large number of useless registration information in the event system to improve operation efficiency .

stay Subscribe/Unsubscribe in , Will need Subscribe/Unsubscribe Listeners of add to the corresponding list .

subscribeRequests.Add(new KeyValuePair<Event, IEventListener>(e, listener);
unsubscribeRequests.Add(new KeyValuePair<Event, IEventListener>(e, listener);

stay Update in , Update them to Listener:

foreach (var subReq in subscribeRequests)
{
    List<IEventListener> callbacks = null;
    if (Listeners.TryGetValue(subReq.Key, out callbacks))
    {
        callbacks.Add(subReq.Value);
    }
    else
    {
        callbacks = new List<IEventListener>();
        callbacks.Add(subReq.Value);
        listeners.Add(subReq.Key, callbacks);
    }
}
subscribeRequests.Clear();

var infoToUnsubscribe = new SubscribeCallbackInfo(null, false);
foreach (var unsubReq in unsubscribeRequests)
{
    List<IEventListener> callbacks = null;
    if (Listeners.TryGetValue(unsubReq.Key, out callbacks))
    {
        if (callbacks.Remove(unsubReq.Value))
        {
            if (callbacks.Count == 0)
            {
                subscribeCallbacks.Remove(unsubReq.Key);
            }
        }
    }
}
unsubscribeRequests.Clear();

Publish

Now we have the subscription information , Need one Publish Function to publish events .

public void Publish(Event e);

The publisher decides how the event is handled （ Sync - asynchronous ） And the way of destruction , For asynchronous calls , Direct loop traversal Listener Corresponding List that will do ：

List<IEventListener> listeners;
if(Listeners.TryGetValue(e, out listeners)){
    for(listener in listeners){
        listener.OnEvent(e);
    }
}

For synchronous calls , use StartCoroutine Coroutine instead of direct call ：

StartCoroutine(listener.OnEvent(e));

Sometimes , We just need the event to be handled by any listener , It doesn't need all listeners to deal with it , therefore , Publishers can put Event.disposeAfterUsed Set as true, stay publish in , As long as a listener handles the event , Then destroy the event , There is no need to pass it down .

List<IEventListener> listeners;
if(Listeners.TryGetValue(e, out listeners)){
    for(listener in listeners){
        if(listener.OnEvent(e)){
            e.dispose();
            break;
        }
    }
}

Update time ：2022.7.17