Hi Chris, thanks for your reply.

I forgot to mention, that *I am* using the '-=' operator. If you'll
read my other "additions" post (posted AFTER you have posted your
reply...), then you'll see my thoughts regarding anonymous delegates
and removing the delegate from the EventHandlerList/Invocation List.

I've mentioned the Dispose, just in case someone would have replied
'use Dispose()'...

Once again, just to make sure: using the '-=' operator on a
'non-anonymous' event handler works great. It is the anonymous event
handler which makes all the trouble. And again - in my "additions" post
you can see that I wasn't able to reproduce this on a test application,
using anonymous delegates. This is what's so weird about it.

My guess is that sometimes you are explicitly saving the event
handler, and sometimes you are not.

Code like

 // subscribe
 EventDelegate Registered = new EventDelegate(validMethod);
 Event += Registered;

 // cancel, as in IDispose.Dispose
 Event Event -= Registered;

will work with delegates to named methods. It's not necessary, though.
You can just code

 // subscribe
 Event += new EventDelegate(validMethod);
 // or "Event += validMethod", in 2

 // cancel, as in IDispose.Dispose
 Event Event -= new EventDelegate(validMethod);

The -= doesn't care about delegate reference equality. It just matches
instance reference and method reference. If (all) match, the delegate
is removed. But with anonymous methods,

 // subscribe
 Event += delegate
 {
   // whatever
 };

 // cancel, as in IDispose.Dispose
 Event Event -= delegate
 {
   // it doesn't help if you replicate the code exactly!
 };

is pointing to different code. Does

 // subscribe
 EventDelegate Registered = delegate
 {
   // whatever
 };
 Event += Registered;

 // cancel, as in IDispose.Dispose
 Event Event -= Registered;

work for you?

They're only useless in the situations where you *need* to remove event
handlers. Most of the time when I write event handlers, the object
"owning" the event becomes eligible for garbage collection at the same
logical time as the target of the event handler, so it's not an issue.