How do lambda expressions work internally?

While looking up the answer to this question: "Why is an out parameter not allowed within an anonymous method?" I've got a little lost about how do lambda expression and anonymous methods actually work.

In the comments JaredPar states that "Imagine for instance that the out parameter referred to a local variable on the stack. The lambda can execute at any arbitrary point in the future and hence could execute when that stack frame was no longer valid".

I pointed out if wouldn't that be the case with any other variable... which basically make me wonder what to I really know about lambda expressions.

The thing I have in mind is something like this:

public void Foo(ComplexObject val, out SomeDelegate outDelegate)
{
  ComplexObject obj = new ComplexObject(val)
  SomeDelegate = delegate(int other) { return (obj.value * other); }  
}

public void Bar()
{
  SomeDelegate MyDel = null;
  Foo(5, out MyDel);
  int finalRes = MyDel(100);
  // Whatever
}

In that situation I don't really know what's happening. obj is a reference on the stack whic开发者_如何转开发h would no longer be valid on method return so the annonymous method should be able (if that works) to actually know that's a reference type and copy the reference instead of the value, if it does... why wouldn't ref params work if the "use case" is more or less the same?

I did a fairly extensive blog series on how closures work internally. It's written for the VB.Net implementation of closures but the underlying details are very similar to C#'s. It should provide the answers you're looking for

Here is the link to part 6 which links to all of the other articles

• http://blogs.msdn.com/jaredpar/archive/2007/08/06/closures-in-vb-part-6-limitations.aspx

Jon Skeet wrote an in-depth description.

Basically, the compiler turns the outer method into a class, and turns all of the variables that are accessed by the anonymous methods into fields on the class. The anonymous methods become regular instance methods on the class.