c# 动态事件订阅和退订

Question

I want to be able to have an object add one of its methods to an EventHandler that is passed to it and give said method the ability to remove itself from the EventHandler .

public class EventRaiser {
    public event EventHandler event1
    public event EventHandler event2
    public void fire() {
        event1?.Invoke(this, null);
        event2?.Invoke(this, null);
    }
}

public class EventSubscriber {
    EventHandler eh;
    public EventSubscriber(EventHandler eh) {
        this.eh = eh;
        eh += receive;
    }

    public void receive(object obj, EventArgs data) {
        // Do stuff.
        if(condition) eh -= receive;
    }
}

public class MainClass {
    public void Main() {
        EventRaiser er = new EventRaiser();
        EventSubscriber es1 = new EventSubscriber(er.event1);
        EventSubscriber es2 = new EventSubscriber(er.event2);
        er.fire();
    }
}

The above code does not compile as I cannot even pass er.event1 or er.event2 to EventSubscriber ("The event can only appear in the left hand side of +=..."). Removing the event keyword from the EventHandler s fixes this issue but unsubscribing does not work properly. Is there a way to make this work? Use pointers maybe?

Answer 1

The problem here comes from you passing an EventHandler , not the list holding the delegate s behind it itsself. Basically the "list of method pointers" to your handlers.

As you can see, in the declaration of event1 you have the keyword event , which is missing when you pass it somewhere else. Unfortunately you cannot extract the " delegate holder" of an event easily.

Basically at the time you want to register your handler to an event you somehow need a compile time reference to it, in order to be able to += and -= to it.

You could do the following:

public class EventRaiser
{
    public delegate void Event1(string args);
    public List<Event1> handlers = new List<Event1>();

    public void register(Event1 handler)
    {
        handlers.Add(handler);
    }

    public void unregister(Event1 handler)
    {
        handlers.Remove(handler);
    }
    
    public void fire()
    {
        handlers.ForEach(handler => handler("myEventArgs"));
    }
}

public class EventSubscriber
{
    Action<Event1> registerAction;
    Action<Event1> unregisterAction;
    public EventSubscriber(Action<Event1> register, Action<Event1> unregister)
    {
        registerAction = register;
        unregisterAction = unregister;
        registerAction(receive);
    }

    public void receive(string args)
    {
        // Do stuff.
        unregisterAction(receive);
    }
}

public class MainClass
{
    public void Main()
    {
        EventRaiser er = new EventRaiser();
        EventSubscriber es1 = new EventSubscriber(er.register, er.unregister);                
        er.fire();
    }
}