I was just reading an earlier thread about how events are strong
references and that subscribing to an event ties your object's lifetime
to that of the event source.

Here's my question: In the next release of the C# language, that is
supposed to support anonymous delegates, how would you be able to bind
an anonymous delegate to an event without causing a memory leak?

Here's an example to illustrate my question: I have a method that, for
the duration of the method's execution, I would like to subscribe to
another object's events.  Using anonymous delegates, this would look
like (I'm guessing at the syntax here):

int nCount = 0;
someobject.SomeEvent +=
   
someobject.Process();

Now, after I've made my Process() method call, I actually have no way to
remove my anonymous delegate (without called GetInvocationList())!
Should the language even allow this to happen?  The delegate would end
up pinning my calling object!

I'm guessing that this might work, but how many developers would expect
the previous code snippet to cause a memory leak?

int nCount = 0;
EventHandler handler =
    new EventHandler( object sender, EventArgs args )
    { nCount++; }
someobject.SomeEvent += handler;
someobject.Process();
someobject.SomeEvent -= handler;

One way might be to have a "weak-reference" delegate that derived from
Delegate, but only held a weak reference to the target of the delegate.
 This could be used any time an anonymous delegate was used.  It would
need to be able to an invoke when its target disappeared (however that
might work).

Any ideas?  I know this stuff isn't available yet, but this situation
will likely come up.

Matt.