C# Custom Events assigning to different delegates based on parameters

Question

I'm trying to use events to use the nice += -= syntax.

Here is my problem: I have a lot of different events, so instead of creating many events, I would like to use only one, where the registrant additionally supplies an additional parameter (string[]) detailing which (sub)events one wants to listen to.

The is basically what I'm doing now:

public delegate void dMethod(int index);
private Dictionary<string, dMethod> events;
public void RegisterEvents(dMethod m, string[] subEvents){
    foreach(string subEvent : subEvents){
        events[subEvent] += m;
    }
}

Instead I would like to do something like this:

public delegate void dMethod(int index);
private Dictionary<string, dMethod> events;

public event dMethod Events(string[] subEvents) {
 add {
        foreach(string subEvent : subEvents){
            events[subEvent] += value;
        }
 }
 remove {
        foreach(string subEvent : subEvents){
            events[subEvent] -= value;
        }
 }
}

Is something like passing additional parameters upon event registration somehow possible? The simplest solution I thought of was to use the delegates return value (changing it to string[]). But that is just hacky and not worth it.

If it is not possible, is there some way I can define += -= myself?

Answer 1

Why exactly don't you want to use one event per... event ?

What you're trying to do would add an indirection step (which will hurt performance), and more importantly deny you the advantages of compile-time error detection and code analysis (what if your string doesn't match an existing event? wouldn't it be nice to find out about the error at compile-time rather than runtime? What about the "find all references" tool?)

If all of your events are really separate events (which have nothing to do with one another), you should create those events. Creating one single event for all kinds of things would be a bit like creating one big sql table with 255 Columns instead of a true database design.

On the other hand, you may be able to find an abstraction of all those events, and add an argument to the event handler (not to the subscription logic) specifying what sub-event has been called. See IBindingList for an example of this technique. Note the use of an enumeration instead of strings to avoid spelling mistakes.

Could you give us some example (business-wise) of the events you're working on ?

Answer 2

This isn't an answer to your main question, but for ease of use I'd add the "params" keyword to your method, like so:

public void RegisterEvents(dMethod m, params string[] subEvents)

This will let you call the method like this:

RegisterEvents(m, "Bob", "Doug", "Susie");

instead of:

RegisterEvents(m, new string[] { "Bob", "Doug", "Susie" });

Answer 3

The simplest solution I thought of was to use the delegates return value (changing it to string[]).

I dont quite understand what you mean by this. Would the event handler return the events it wants to handle?

I don't think that what you want to do is an option. It may be possible (if you abandon the .Net event system) to use the += syntax by creating a custom class and some implicit conversion operators to produce code something like:

SomePropertyThatIsntARealEvent[new string[] {"event1", "event2"}] += someDelegate
// or even
SomePropertyThatIsntARealEvent["event1"]["event2"] += someDelegate

Note that, if it's even doable, it would be messy and hacky and not really worth it anyways. Also, unfortunately, you can't use params for indexers.

I would recommend that you just stick with the un-pretty way.