Question

I have two lists, one with events, one with Actions(functions)

The reason for the lists is to allow a user to connect the two together through an interface. So I am trying to create a method which takes the event and has the action added to it.

I want to be able to do TheEvent += TheAction, and then be able to remove it later with -=.

I am sorry if how to do this is obvious, I couldn’t come up with the right keywords to search for, “connect action to event” is the best I thought of and it is pretty useless in a search.

Nothing I have come up with will allow me to add an action to an event, but perhaps I am going about it wrong. Any advice on the best way to allow a user to select an event and a function to trigger from the event would be appreciated.

Answer 1

Events are immutable. If you add or remove an event handler, a new event (or multicast delegate) is created. This also means, that you must be careful when adding events to a list. This will not work

public event EventHandler Event0;
public event EventHandler Event1;
public event EventHandler Event2;

public List<EventHandler> Events;

public void AddEvents( )
{
    Events = new List<EventHandler> { Event0, Event1, Event2 };
    Event0 += new EventHandler(EventHandler0);
    Events[1] += new EventHandler(EventHandler1);
}

If you add an event handler to Event0 the corresponding list entry will still reference the old Event0! If you add an event handler to Events[1], Event1 will not be updated!

---

I do not know if this is what you mean, however, if you have these two lists

public List<EventHandler> Events;
public List<Action<object, EventArgs>> Actions;

You can add en event hander (an action) to an event like this:

Events[i] += new EventHandler(Actions[j]);

and raise an event like this

EventHandler eh = Events[i];
if (eh != null) {
    eh(this, EventArgs.Empty);
}

---

EDIT (in response to your comment):

Here again, you must act on the original event list and not on an event passed as parameter, because of this immutable problem explained above. If necessary, you could also pass the list itself as an additional parameter.

public void AddActionToEvent(Action<object, EventArgs> action, int eventIndex)
{
    Events[eventIndex] += new EventHandler(action);
}

For your other problem of how to let the user select events and actions, I would suggest of either having four lists, where as the events and action lists would be paralleled with two corresponding string lists with the names of the events and actions. Alternatively, you could wrap the events and actions in a class containing them and their names

public class EventWrapper
{
    public string Name { get; set; }
    public event EventHandler Event;

    public override string ToString()
    {
        return Name;
    }

    public void RaiseEvent(object sender)
    {
        EventHandler eh = Event;
        if (eh != null) {
            eh(sender, EventArgs.Empty);
        }
    }
}

public class ActionWrapper
{
    public string Name { get; set; }
    public Action<object, EventArgs> Action { get; set; }

    public override string ToString()
    {
        return Name;
    }
}

Then you would define the lists like this

public List<EventWrapper> EventsWithNames;
public List<ActionWrapper> ActionsWithNames;

Now you can use these lists directly as data source in combo boxes or list boxes. The overridden ToString methods of the wrappers automatically provide a string to display.

The add method can now be rewritten as

public void AddActionToEvent(ActionWrapper actionWrapper, EventWrapper eventWrapper)
{
    eventWrapper.Event += new EventHandler(actionWrapper.Action);
}

The wrappers also defuse the immutable situation, since we do not pass the event as parameter but its wrapper.