Private field captured in anonymous delegate

Question

class A
{
   public event EventHandler AEvent;
}
class B
{
   private A _foo;
   private int _bar;

   public void AttachToAEvent()
   {
      _foo.AEvent += delegate()
         


        

Answer 1

This is easiest understood by looking at the code generated by the compiler, which is similar to:

public void AttachToAEvent()
{
    _foo.AEvent += new EventHandler(this.Handler);
}

[CompilerGenerated]
private void Handler(object sender, EventArgs e)
{
    this.UseBar(this._bar);
}

As can be plainly seen, the delegate created is an instance-delegate (targets an instance method on an object) and must therefore hold a reference to this object instance.

Since delegate captures variable this._bar, does it implicitly hold to the instance of B?

Actually, the anonymous method captures just this (not this._bar). As can be seen from the generated code, the constructed delegate will indeed hold a reference to the B instance. It has to; how else could the field be read on demand whenever the delegate is executed? Remember that variables are captured, not values.

Since in my case an instance of A lives far longer and is far smaller than an instance of B, I'm worried to cause "memory leak" by doing this.

Yes, you have every reason to be. As long as the A instance is reachable, the B event-subscriber will still be reachable. If you don't want to go fancy with weak-events, you need to rewrite this so the handler is unregistered when it is no longer required.

Would it be different if _bar was a local variable of the AttachToAEvent method?

Yes, it would, as the captured variable would then become the bar local rather than this. But assuming that UseBar is an instance-method, your "problem" (if you want tot think of it that way) has just gotten worse. The compiler now needs to generate an event-listener that "remembers" both the local and the containing B object instance.

This is accomplished by creating a closure object and making it (really an instance method of it) the target of the delegate.

public void AttachToAEvent(int _bar)
{
    Closure closure = new Closure();
    closure._bar = _bar;
    closure._bInstance = this;
    _foo.AEvent += new EventHandler(closure.Handler);
}

[CompilerGenerated]
private sealed class Closure
{
    public int _bar;
    public B _bInstance;

    public void Handler(object sender , EventArgs e)
    {
        _bInstance.UseBar(this._bar);
    }
}