Heurística para "esto" y cierres ¿está bien? (árboles de expresión)

Question

Tenga en cuenta la siguiente expresión:

class A { 
    int x; 
    public void Method(int y) { 
     Expression<Func<bool>> expr=() => x == y; 
     //... 

Aquí, la expresión implica un cierre creado automáticamente para y, y una referencia a this de tipo A para la (implícita) this.x. Ambos se representarán como MemberExpression en un ConstantExpression en el árbol de expresiones. Dada una expresión como expr o una expresión más complicada con esta referencia y/o cierre, quiero identificar que un particular ConstantExpression es en realidad "este" o un cierre implícitamente construido para poder regenerar C# desde un árbol de expresiones (ExpressionToCode).

Creé una "solución" usando algunas heurísticas ya que no parece haber una solución perfecta.

• cierres y this en lambda de siempre están en ConstantExpressions.
• Cierres y this nunca son null.
• Ambos son clases, no tipos de valores: no se puede capturar una referencia a this desde una estructura. Eso es bastante afortunado, porque decir default(StructType).Method() desde this.Method() sería imposible siempre que this == default(StructType).
• tipos internos (String, enumeraciones, decimales, Tipo, todas las primitivas) son constantes en realidad de verdad, no this o un cierre
• Los cierres y los tipos anónimos empezar con < y están anotados con CompilerGeneratedAttribute
  • nombres de cierre contienen el cadena DisplayClass, tipos anónimos contienen AnonymousType
  • Los tipos anónimos son genéricos, los cierres no lo son.
  • Los cierres son clases anidadas, los tipos anónimos no lo son.
• this debe ser un tipo normal: no CompilerGenerated y no se inicia con <

¿Son las heurísticas anteriores suficientes para distinguir entre reales constantes, this, los cierres y los tipos anónimos? Es decir. ¿Hay casos en que estos heurísticos fallan o me falta alguno? ¿Es probable que se rompa en futuras versiones de .NET?

Editar: primero hice esta pregunta en una forma abierta, sin resultado; Reescribí la pregunta para incluir lo que he encontrado hasta ahora. Cualquier sugerencia muy apreciadas - mañana en expiración de la recompensa, alguna idea es bienvenida ...

Answer 1

Ok, me las arreglo para encontrar sobre el Tipo A partir de la expresión:

class Program 
{ 
    class A 
    { 
     int x; 
     public Expression<Func<bool>> Method(int y) 
     { 
      Expression<Func<bool>> expr =() => x == y; 
      return expr; 
     } 
    } 

    static void Main(string[] args) 
    { 
     var expr = new A().Method(10); 

     dynamic body = expr.Body; 

     A instance = body.Left.Expression.Value; 

     Console.Write(instance.ToString()); 

     Console.ReadKey(); 
    } 
} 

La dinámica es sólo para ir rápido.

editar 2: lo tengo