Centralized event system using dictionary

Question

I'm trying to make a centralized event system for my unity game - a central hub where other parts of the game can register/broadcast their own types of events. This means I have a singleton GameEventSystem that is globally accessible.

This is an example structure:

I have tried to combine multiple sources, trying to figure out how to do this, and this is where I got.
I have a Dictionary where the key is Type(that supposed to be T : GameEvent), and the value is GameEventListener<GameEvent>, GameEventListener is supposed to be Action<T : GameEvent>.
What I'm trying to achieve is a singleton class that manages Dictionary<T : GameEvent, GameEventListener<T : GameEvent>>.

The implementation of RegisterListener:

Type eventType = typeof(T);

GameEventListener<GameEvent> listenerTemp;
if (EventListeners.TryGetValue(eventType, out listenerTemp))
{
    listenerTemp += (GameEventListener<GameEvent>)listener;
    EventListeners[eventType] = listenerTemp; // Copy the newly aggregated listener back into the dictionary.
}
else
{
    listenerTemp += (GameEventListener<GameEvent>)listener;
    EventListeners.Add(eventType, listenerTemp);
}

And this would be the UnregisterListener:

Type specificGameEventType = typeof(T);
if (!AnyListeners(specificGameEventType, this.EventListeners))
{
    // No one is listening, we are done.
    return;
}

EventListeners[specificGameEventType] -= (GameEventListener<GameEvent>)listener;

Passing an Action<UnitDiedEvent> to RegisterListener will lead to InvalidCastException: Specified cast is not valid., at the following line:

listenerTemp += (GameEventListener<GameEvent>)listener;

Why can't I cast a GameEventListener<UnitDiedEvent> class, to GameEventListener<GameEvent>?

Is there a better approach to achieve a centralized event system in unity?
From my research I can't just make GameEventSystem a static class and expect it to be accessed by the rest of the game objects/components. That makes global systems/managers like this one a little problematic to instantiate and access.

I think I'm not fully grasping events/delegates and generics as a whole to tackle this on my own.

Answer 1

This looks like a situation you can tackle with the curiously recurring template pattern.

First, we'll define a generic GameEvent, that could work on payloads of some unknown type, with static methods to register/unregister listeners who care about events of that type, and broadcast the event to all listeners:

public abstract class GameEvent<T>
{
    static event System.Action<T> onEvent;

    public static void RegisterListener(System.Action<T> listener) {
        onEvent += listener;
    }

    public static void UnregisterListener(System.Action<T> listener) {
        onEvent -= listener;
    }

    public static void BroadcastEvent(T eventData) {
        onEvent?.Invoke(eventData);
    }
}

Then we can specialize it by defining derived types of GameEvent<T> where T is their own type:

public class UnitDiedEvent : GameEvent<UnitDiedEvent>
{
    public enum CauseOfDeath {
        Unknown,
        NaturalCauses,
        Murder
    }

    public GameObject deadUnit;
    public CauseOfDeath cause;
    public GameObject killer;
}

Now we can register/unregister a listener by calling a static method on the derived event type we care about:

UnitDiedEvent.RegisterListener(OnDeath);

And we can fire the event to all listeners similarly:

var death = new UnitDiedEvent();
death.deadUnit = gameObject;
death.cause = UnitDiedEvent.CauseOfDeath.NaturalCauses;

UnitDiedEvent.BroadcastEvent(death);

And we've done it all without any casting, hashing, or dictionary lookups along the way. :D

---

As to why your original attempt didn't work, it's because arguments to delegates are contravariant.

We generally find covariance most familiar:

Animal someAnimalVariable = new Animal();
Cat someCatVariable = new Cat();

// This is valid, because all cats are animals, so we preserve the meaning of
// "someAnimalVariable contains an animal"
someAnimalVariable = someCatVariable;

// This is not valid, because not all animals are cats.
someCatVariable = someAnimalVariable;
// If someAnimalVariable contained a Turtle, our code would become very
// confused when it tries to call someCatVariable.Meow() to make a turtle meow!

But delegate arguments are contravariant:

System.Action<Animal> someAnimalAction;
System.Action<Cat> someCatAction;

// This is valid. (Delegate with a less derived argument 
// assigned to a variable with a more derived argument)
someCatAction = someAnimalAction;

// This is not. (Delegate with a more derived argument
// assigned to a variable with a less derived argument)
someAnimalAction = someCatAction;

Why this difference? Think about what happens when code tries to call someCatAction:

Cat myFavouriteKitty = GetFavouriteCat();
someCatAction(myFavouriteKitty);

As long as someCatAction accepts an animal, this call is still valid, since all cats are animals. So any System.Action<Animal> is valid as a value for a delegate we want to pass cats to, like someCatAction.

Now think about what happens when code tries to call someAnimalAction:

Turtle myFavouriteTurtle = GetFavouriteTurtle();
someAnimalAction(myFavouriteTurtle);

This call looks valid, since we're calling a delegate that says it expects an animal, and passing it a turtle, which is an animal.

But if somewhere else in your code you were allowed to say this:

someAnimalAction = someCatAction;

...then now the code above is trying to invoke a delegate that expects a cat, but passing it a turtle! So if the variable is of type Action<Animal>, then only delegates that accept all animals (or possible more types) are valid values, because they're the only ones that could handle any invocation that tries to send any old animal down the pipe.