Centralized event system using dictionary

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. 😁

---

You can improve on this approach by separating the type for data being passed to the event from the type that handles the registration/broadcast. This would let you make the data type a struct, so you don't incur the same allocation/GC overhead when firing a lot of short-lived event payloads.

I elaborate on this technique for events in another answer, showing how to combine it with an event queue that can store multiple different kinds of events interleaved and process them in the order they were registered.

---

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.