How can you identify anonymous methods via reflection?
                +3 
                A: 
                
                
              Look at the attributes of the method, and see if the method is decorated with CompilerGeneratedAttribute.
Anonymous methods (as well as other objects, such as auto-implemented properties, etc) will have this attribute added.
For example, suppose you have a type for your class. The anonymous methods will be in:
Type myClassType = typeof(MyClass);
IEnumerable<MethodInfo> anonymousMethods = myClassType
    .GetMethods(
          BindingFlags.NonPublic
        | BindingFlags.Public 
        | BindingFlags.Instance 
        | BindingFlags.Static)
    .Where(method => 
          method.GetCustomAttributes(typeof(CompilerGeneratedAttribute)).Any());
This should return any anonymous methods defined on MyClass.
                  Reed Copsey
                   2010-03-23 20:27:47
                
              And so can any other method (or member/type).
                  leppie
                   2010-03-23 20:31:25
                True - you can define this manually on any method, and fool it, but typically, this is used for anonymous methods and other compiler generated information.
                  Reed Copsey
                   2010-03-23 20:37:22
                For auto properties too, and on property getters and setters.
                  leppie
                   2010-03-23 20:39:24
                Granted, this is not a fail-safe way to do this, as there is no such thing as "anonymous", but "anonymous" typically means a compiler-generated type.
                  Reed Copsey
                   2010-03-23 20:39:49
                @Leppie: I just changed the language - that help?
                  Reed Copsey
                   2010-03-23 20:40:43
                leppie - auto property getter/setter methods have the IsAccessor == true.
                  devlife
                   2010-03-23 23:59:58
                
                +3 
                A: 
                
                
              You cannot, because there is no such thing as an anonymous method on IL level - they're all named, and all belong to named types. And the way C# and VB compilers translate anonymous methods to named methods and types is entirely implementation-defined, and cannot be relied on (which means that, for example, it can change with any update, even in minor releases / hotfixes).
                  Pavel Minaev
                   2010-03-23 20:38:44
                
              +1: This is, technically, the "correct" answer - but [CompilerGenerated] works fairly reliably in practice.
                  Reed Copsey
                   2010-03-23 20:44:38