在C＃中创建简单的全局事件系统的最佳方法是什么？

Question

I'm looking to create a quick event system in C# but I'm not sure the best way to approach it. Here's how I would like it to work:

Messenger

This is where I'd like all events to be stored. The class would look something like this:

public static class Messenger
{
    // This event would have a few params, like GameState, Ammo, and Lives, or something
    public static GameStateMessage OnGameStateChanged;

    // This event could be generic, with no args
    public static Message OnGameStarted;
}

Subscribers

I'd like anything to be able to subscribe to these messages by doing something like this:

// Handler, which will be passed to the event
private void OnGameStartedHandler(GameState gameState, int ammo, int lives)
{
    // Do something
}


// Event would be subscribed to like this:
Messenger.OnGameStarted += OnGameStartedHandler;

// or this:
Messenger.OnGameStarted.Subscribe(OnGameStartedHandler);

Dispatchers

Finally, I'd like anything to be able to dispatch any of these events like so:

Messenger.OnGameStarted(gameState, ammoCount, livesCount);

// or

Messenger.OnGameStarted.Invoke(gameState, ammoCount, livesCount);

Is there any way to do something like this easily and cleanly? I'd like for it to be very fast to create new events (without having to create new classes or any boilerplate code)

Basically The Messenger class would act as a central hub for specific events, something that can easily be referenced and managed from a single location.

Answer 1

I would suggest using the standard .NET events mechanism. You need both the event declaration and the raising method to reside inside the static class, because external code is allowed only to subscribe/unsubscribe to the events (directly).

public static class Messenger
{
    public static event Action<GameStateMessage> GameStateChanged;
    public static void OnGameStateChanged (GameStateMessage arg) => GameStateChanged?.Invoke(arg);

    public static event Action<Message> GameStarted;
    public static void OnGameStarted (Message arg) => GameStarted?.Invoke(arg);
}

Messenger.GameStarted += (Message arg) => // Subscribing to the event
{
    Console.WriteLine(arg);
};

Messenger.OnGameStarted(new Message("Get ready!")); // Raising the event

The null conditional operator ?. is required because events without subscriptions are null references. It also takes care of race conditions in multithreaded scenarios.

---

Update: Regarding memory leaks, every time that an object subscribes to an event of another object, a connection is created between the two objects. The basic principal is:

The subscribers don't keep references of publishers. Only the publishers keep references of subscribers.

This means that long-lived publishers may prevent short-lived subscribers from being garbage collected. This is something to have in mind when subscribing to an event. Is the publisher expected to out-live me? If the answer is yes, then I must unsubscribe before I die. In the specific case the publisher is a static class, that will never be garbage collected, so all objects with a life-span shorter that the life-span of the application should unsubscribe from the static events they subscribed earlier. Otherwise memory leaks will occur. Here is an example of subscribing-unsubscribing:

public class Player : IDisposable
{
    public Player() // Constructor
    {
        Messenger.GameStarted += Messenger_GameStarted; // Subscribe
    }

    private void Messenger_GameStarted(Message arg) // Event handler
    {
        Console.WriteLine(arg);
    }

    public void Dispose() // This method must be called when the object is about to perish
    {
        Messenger.GameStarted -= Messenger_GameStarted; // Unsubscribe
    }
}