\nYou may not even have realized that\nthere are two types of anonymous methods.\nI’ll call them the easy kind and the hard kind,\nnot because they’re actually easy and hard for you the programmer,\nbut because they are easy and hard for the compiler.\n<\/p>\n
\nThe easy kind is the anonymous method that doesn’t use any local variables\nfrom its lexically-enclosing method.\nThese are anonymous methods that could have been their own separate\nmember functions; all the anonymization does is save you\nthe trouble of coming up with names for them:\n<\/p>\n
\nclass MyClass1 {\n int v = 0;\n delegate void MyDelegate(string s);\n MyDelegate MemberFunc()\n {\n int i = 1;\n return delegate(string s) {\n System.Console.WriteLine(s);\n };\n }\n}\n<\/pre>\n\nThis particular anonymous method doesn’t access any MyClass1<\/code>\nmembers, nor does it access the local variables of the\nMemberFunc<\/code> function; therefore, it can be\nconverted to a static method of the MyClass1<\/code> class:\n<\/p>\n\nclass MyClass1_converted {\n int v = 0;\n delegate void MyDelegate(string s);\n \/\/ Autogenerated by the compiler\n static void __AnonymousMethod$0<\/font>(string s)\n {\n System.Console.WriteLine(s);\n }\n MyDelegate MemberFunc()\n {\n int i = 1;\n return __AnonymousMethod$0<\/font>;\n \/\/ which is in turn shorthand for\n \/\/ return new MyDelegate(MyClass1.__AnonymousMethod$0);\n }\n}\n<\/pre>\n\nAll the compiler did was give your anonymous methods a name\nand use that name in place of the “delegate (...) { ... }<\/code>“.\n(Note that all compiler-generated names I use here are\npurely illustrative.\nThe actual compiler-generated name will be something different.)\n<\/p>\n\nOn the other hand, if your anonymous method used the this<\/code>\nparameter, then that makes it an instance method instead of a\nstatic method:\n<\/p>\n\nclass MyClass2 {\n int v = 0;\n delegate void MyDelegate(string s);\n MyDelegate MemberFunc()\n {\n int i = 1;\n return delegate(string s) {\n System.Console.WriteLine(\"{0} {1}\", v, s);\n };\n }\n}\n<\/pre>\n\nThe anonymous method in MyClass2<\/code>\nuses the this<\/code> keyword\nimplicitly (to access the member variable v<\/code>).\nTherefore, the conversion is to an instance member rather\nthan to a static member.\n<\/p>\n\nclass MyClass2_converted {\n int v = 0;\n delegate void MyDelegate(string s);\n \/\/ Autogenerated by the compiler\n void __AnonymousMethod$0<\/font>(string s)\n {\n System.Console.WriteLine(\"{0} {1}\", v, s);\n }\n MyDelegate MemberFunc()\n {\n int i = 1;\n return this.__AnonymousMethod$0<\/font>;\n \/\/ which is in turn shorthand for\n \/\/ return new MyDelegate(this.__AnonymousMethod$0);\n }\n}\n<\/pre>\n\nSo far, we’ve only dealt with the easy cases.\nThe transformation is local and not particularly complicated.\nThese are the sorts of transformations you could make yourself\nwithout too much difficulty\nin the absence of anonymous methods.\n<\/p>\n
\nThe hard case is where things get interesting.\nThe body of an anonymous method is permitted to access the\nlocal variables of its lexically-enclosing method,\nin which case the compiler needs to keep those variables alive\nso that the body of your anonymous method can access them.\nHere’s a sample anonymous method that accesses local variables\nfrom its lexically-enclosing method:\n<\/p>\n
\nclass MyClass3 {\n int v = 0;\n delegate void MyDelegate(string s);\n MyDelegate MemberFunc()\n {\n int i = 1;\n return delegate(string s) {\n System.Console.WriteLine(\"{0} {1} {2}\", i++, v, s);\n };\n }\n}\n<\/pre>\n\nIn this example, the anonymous method prints\n“1 v s” the first time it is called,\nthen “2 v s” the second time it is called,\nand so on, with the integer increasing by one.\n(And where v s<\/code> are the current values of v<\/code>\nand s<\/code>, of course.)\nThis happens because the i<\/code> variable that the\nanonymous method is accessing is the same one each time,\nand it’s the same i<\/code> that the MemberFunc<\/code>\nmethod was using, too.\nIf the function were rewritten as\n<\/p>\n\nclass MyClass4 {\n int v = 0;\n delegate void MyDelegate(string s);\n MyDelegate MemberFunc()\n {\n int i = 0;\n MyDelegate d = delegate(string s) {\n System.Console.WriteLine(\"{0} {1} {2}\", i++, v, s);\n };\n i = 1;\n return d;\n }\n}\n<\/pre>\n\nthe behavior would be the same as in MyClass3<\/code>.\nThe creation of the delegate from the anonymous method does\nnot<\/strong> make a copy of the i<\/code>\nvariable;\nchanges to the i<\/code> variable in the MemberFunc<\/code>\nare visible to the anonymous method because both are accessing\nthe same<\/strong>\nvariable.\n<\/p>\n\nWhen faced with this “hard” type of anonymous method, wherein variables\nare shared with the lexically-enclosing method,\nthe compiler generates a helper class:\n<\/p>\n
\nclass MyClass3_converted {\n int v = 0;\n delegate void MyDelegate(string s);\n \/\/ Autogenerated by the compiler\n class __AnonymousClass$0 {\n MyClass this$0;\n int i;\n public void __AnonymousMethod$0<\/font>(string s)\n {\n System.Console.WriteLine(\"{0} {1} {2}\", i++, this$0<\/font>.v, s);\n }\n }<\/font>\n MyDelegate MemberFunc()\n {\n __AnonymousClass$0 locals$ = new __AnonymousClass$0();\n locals$.this$0 = this;\n locals$.<\/font>i = 0;\n return locals$.__AnonymousMethod$0<\/font>;\n \/\/ which is in turn shorthand for\n \/\/ return new MyDelegate(locals$.__AnonymousMethod$0);\n }\n}\n<\/pre>\n\nWow, there was a lot of rewriting this time.\nA helper class was created to contain the local variables\nthat were shared between the MemberFunc<\/code> function\nand the anonymous method (in this case, just the variable i<\/code>),\nas well as the hidden this<\/code> parameter\n(which I have called this$<\/code>).\nIn the MemberFunc<\/code> function,\naccess to that shared variable is done through\nthis anonymous class, and the anonymous method that you wrote\nis an anonymous method on the anonymous class.\n<\/p>\n\nNotice that the assignment to i<\/code> in\nMemberFunc<\/code> modifies the copy inside locals$<\/code>,\nwhich is the same object that the anonymous method will be using when it runs.\nThat’s why it prints “1 v s” the first time:\nThe value had already been changed to 1 by the time the\ndelegate ran for the first time.\n<\/p>\n\nThose who have done a good amount of C++ programming\n(or C# 1.0 programming) are well familiar with this technique,\nsince C++ callbacks typically are given only one context variable;\nthat context variable is usually a pointer to a larger structure\nthat contains all the complex context you really want to operate on.\nC# 1.0 programmers went through a similar exercise.\nThe “hard” type of anonymous method provides syntactic sugar\nthat saves you the hassle of having to declare and manage the helper class.\n<\/p>\n
\nIf you thought about it some, you’d have realized that\nthe way it’s done is pretty much the only way it could have been done.\nIt turns out that most computer programming doesn’t consist of being\nclever or making hard decisions.\nYou just have one kernel of an idea (“hey let’s have anonymous\nmethods”) and then the rest is just doing what has to be done,\nno actual decisions needed.\nYou just do the obvious thing.\nMost programming consists of just doing the obvious thing.\n<\/p>\n
\nOkay, so that’s a quick introduction to the implementation of\nanonymous methods in C#.\nMind you, this information isn’t just for your personal edification.\nIt’s actually important that you understand how these works\n(and not just treat it as “magic”),\nbecause lack of said understanding can lead to subtle programming errors.\nWe’ll look at those types of errors over the next few days.\n<\/p>\n