Clearing or checking for event handlers in C#

I have some C# code that updates some properties of an object. I have an event handler def开发者_如何学Goined to help me respond when the update process is done. Unfortunately, I've learned that this event is getting fired multiple times. I suspect this is happening because the event handler is being set at the wrong time. Currently, it is being set like the following:

myObject.Update_Succeeded += new EventHandler(myObject_Update_Succeeded);

Due to the complexity of the code, I'm having a difficult time of tracking down where it should be set. I would like to only set the event handler it hasn't been previously set. Because of this, I want to do something like this:

ClearEventHandlers(myObject);

or

myObject.Update_Succeeded = null;
myObject.Update_Succeeded += new EventHandler(myObject_Update_Succeeded);

Is there a way to accomplish what I'm trying?

Thank you!

---

Yes, you can customize the add/remove accessors of your event. This article describes these accessors. But you can do something like:

class MyClass
{
    private EventHandler _myEvent;

    public event EventHandler MyEvent
    {
        [MethodImpl(MethodImplOptions.Synchronized)]
        add 
        { 
            _myEvent = (EventHandler)Delegate.Combine(_myEvent, value);
        }
        [MethodImpl(MethodImplOptions.Synchronized)]
        remove 
        { 
            _myEvent = (EventHandler)Delegate.Remove(_myEvent, value); 
        }
    }

    public void ClearMyEvent() {
        _myEvent = null;
    }
    ...
}

---

You should be able to remove a handler using the subtract operator like below

myObject.Update_Succeeded -= new EventHandler(myObject_Update_Succeeded);

Or check this out for a way to remove all event handler if you are in doubt

How to remove all event handlers from a control

---

Proper way should be to detach the handler from each event after you no longer use it:

public class MyObjectListener
{
     private readonly MyObject _object;
     public class MyObjectListener(MyObject obj)
     {
          _object = obj;
          Attach();
     }

     // adds event handlers
     private void Attach()
     {
         obj.UpdateSucceeded += UpdateSuceededHandler;
         obj.UpdateFailed += UpdateFailedHandler;
     }

     // removes event handlers
     private void Detach()
     {
         obj.UpdateSucceeded -= UpdateSuceededHandler;
         obj.UpdateFailed -= UpdateFailedHandler;
     }

     ...
}

The only thing you need to decide is where to call the Detach method. For example, you can call it in the handler itself:

     private void UpdateSuceededHandler(object sender, Data args)
     {
         Detach();
         // do something when it succeeds
     }

     private void UpdateFailedHandler(object sender, Data args)
     {
         Detach();
         // do something when it fails
     }

Or, you could allow users of MyObjectListener to tell it that it no longer needs to listen to the attached object:

     public void StopListening()
     {
         Detach();
     }

An object which raises an event should not allow its listeners to modify the event invocation list. Each event listener should subscribe or unsubscribe its own event handlers only.

---

You better set event handler on the initialization of your object i.e. in your Constructor.