如何在字典初始化中声明事件？

Question

I am creating a Dictionary of events and I want to declare those events inside the initialization of that dictionary instead of declaring them somewhere else and placing the links to the dictionary.

    static event EventDelegate Event1;
    static event EventDelegate Event2;
    static event EventDelegate Event3;

    public enum EventTypes
    {
        Event1, 
        Event2,
        Event3,
    }

    public static Dictionary<EventTypes, EventDelegate> events = new Dictionary<EventTypes, EventDelegate>
    {
        {EventTypes.Event1, Event1},
        {EventTypes.Event2, Event2},
        {EventTypes.Event3, Event3},
    };

So I want to do something like that:

{EventTypes.Event1, new event EventDelegate Event1}

Is that possible?

Answer 1

How about wrapping the events?

class MyEventWrapper
{
    public event EventDelegate Handlers;

    public void Raise(object sender, EventArgs args)
    {
        Handlers?.Invoke(sender, args);
    }
}

//

Dictionary<EventTypes, MyEventWrapper> eventMap = new Dictionary<EventTypes, MyEventWrapper>
{
    { EventTypes.Event1, new MyEventWrapper() },
    { EventTypes.Event2, new MyEventWrapper() },
};

//

eventMap[EventTypes.Event1].Handlers += (s, a) => { };
eventMap[EventTypes.Event2].Handlers += (s, a) => { };

//

eventMap[EventTypes.Event1].Raise(this, new EventArgs());

Answer 2

You could declare an empty bodied delegate with the signature of your EventDelegate , and use it for the initialization of the dictionary items.

public delegate void EventDelegate(object data);
public static readonly EventDelegate EventDelegateEmptyBody = (_) => { };

public static Dictionary<EventTypes, EventDelegate> Events = new Dictionary<EventTypes, EventDelegate>
{
    {EventTypes.Event1, EventDelegateEmptyBody},
    {EventTypes.Event2, EventDelegateEmptyBody},
    {EventTypes.Event3, EventDelegateEmptyBody},
};

The downside is that this empty method will be invoked every time an event is raised, so you'll lose some performance. The upside is that you will not need to check if the delegate is empty before invoking it. It will never be empty.

Instead of an empty method you could have a method that actually do something, like logging the raising of an event.

---

Sample code demonstrating the usage of the Events dictionary:

Events[EventTypes.Event1] += (object data) =>
{
    Console.WriteLine($"Event1 first handler: {data}");
};
Events[EventTypes.Event1] += (object data) =>
{
    Console.WriteLine($"Event1 second handler: {data}");
};
Events[EventTypes.Event2] += (object data) =>
{
    Console.WriteLine($"Event2 handler: {data}");
};

Events[EventTypes.Event1].Invoke("test1");
Events[EventTypes.Event2].Invoke("test2");
Events[EventTypes.Event3].Invoke("test3");

Console output:

Event1 first handler: test1
Event1 second handler: test1
Event2 handler: test2

---

Update: It seems that the empty bodied delegate is redundant. The Events dictionary can be initialized with null values, and works just fine.

public static Dictionary<EventTypes, EventDelegate> Events = new Dictionary<EventTypes, EventDelegate>
{
    {EventTypes.Event1, null},
    {EventTypes.Event2, null},
    {EventTypes.Event3, null},
};

The only difference is that we must check for null before raising the events (the null conditional operator makes it easy).

Events[EventTypes.Event1]?.Invoke("test1");
Events[EventTypes.Event2]?.Invoke("test2");
Events[EventTypes.Event3]?.Invoke("test3");

Answer 3

If you define your dictionary like this:

public delegate void EventDelegate(object data);

public static Dictionary<EventTypes, EventDelegate> Events =
    new Dictionary<EventTypes, EventDelegate>
    {
        { EventTypes.Event1, (EventDelegate)((_) => { }) },
        { EventTypes.Event2, (EventDelegate)((_) => { }) },
        { EventTypes.Event3, (EventDelegate)((_) => { }) },
    };

public enum EventTypes
{
    Event1,
    Event2,
    Event3,
}

Then this code works a treat:

Events[EventTypes.Event1] += (object data) => Console.WriteLine($"Event1 (1): {data}");
Events[EventTypes.Event1] += (object data) => Console.WriteLine($"Event1 (2): {data}");
Events[EventTypes.Event2] += (object data) => Console.WriteLine($"Event2: {data}");

Events[EventTypes.Event1]("A");
Events[EventTypes.Event2]("B");
Events[EventTypes.Event3]("C");

The output I get is:

Event1 (1): A
Event1 (2): A
Event2: B

You are then clearly declaring those events inside the initialization of the dictionary.