¿Cómo obtengo un bytearray de IL de DynamicMethod?

Question

Como novedad, trato de ver qué tan diferente se ve la IL del código de peso ligero en el tiempo de ejecución frente al código generado por el compilador VS, ya que noté que el código VS tiende a ejecutarse con un perfil de rendimiento diferente para cosas como moldes.

Así que escribió el siguiente código ::

Func<object,string> vs = x=>(string)x; 
Expression<Func<object,string>> exp = x=>(string)x; 
var compiled = exp.Compile(); 
Array.ForEach(vs.Method.GetMethodBody().GetILAsByteArray(),Console.WriteLine); 
Array.ForEach(compiled.Method.GetMethodBody().GetILAsByteArray(),Console.WriteLine); 

Desafortunadamente, esto arroja una excepción, ya GetMethodBody es aparentemente una operación ilegal en el código generado por los árboles de expresión. ¿Cómo puedo hacerlo de una manera bibliotecaria (es decir, no con una herramienta externa a menos que la herramienta tenga una API) mire el código generado por código usando codegen ligero?

Editar: el error ocurre en la línea 5, compiled.Method.GetMethodBody() arroja la excepción.

Edit2: ¿Alguien sabe cómo recuperar las variables locales declaradas en el método? ¿O no hay forma de GetVariables?

Answer 1

Sí, no funciona, el método es generado por Reflection.Emit. El IL se almacena en ILGenerator del MethodBuilder. Puedes desenterrarlo pero tienes que estar bastante desesperado. Se necesita reflexión para llegar a los miembros internos y privados. Esta trabajado en .NET 3.5SP1:

using System.Linq.Expressions; 
using System.Reflection; 
using System.Reflection.Emit; 
... 

     var mtype = compiled.Method.GetType(); 
     var fiOwner = mtype.GetField("m_owner", BindingFlags.Instance | BindingFlags.NonPublic); 
     var dynMethod = fiOwner.GetValue(compiled.Method) as DynamicMethod; 
     var ilgen = dynMethod.GetILGenerator(); 
     var fiBytes = ilgen.GetType().GetField("m_ILStream", BindingFlags.Instance | BindingFlags.NonPublic); 
     var fiLength = ilgen.GetType().GetField("m_length", BindingFlags.Instance | BindingFlags.NonPublic); 
     byte[] il = fiBytes.GetValue(ilgen) as byte[]; 
     int cnt = (int)fiLength.GetValue(ilgen); 
     // Dump <cnt> bytes from <il> 
     //... 

En .NET 4.0 que tendrá que utilizar ilgen.GetType() BaseType.GetField (...) porque el generador de IL fue cambiado, DynamicILGenerator, deriva de. ILGenerator.

Answer 2

base del trabajo de Hans Passant pude profundizar un poco más parece que hay un método que debe llamar, llama BakeByteArray por lo que las siguientes obras ::

var dynMethod = fiOwner.GetValue(compiled.Method) as DynamicMethod; 
var ilgen =dynamicMethod.GetILGenerator(); 
byte[] il = ilgen.GetType().GetMethod("BakeByteArray", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(ilgen, null) as byte[]; 

Esto sin duda ayuda, pero todavía no tengo manera de resolver VariableInfo's todavía que es algo que ayudaría en mi trabajo.

Answer 3

La escucha de ILReader debería funcionar.

ILVisualizer 2010 Solución

http://blogs.msdn.com/b/haibo_luo/archive/2010/04/19/9998595.aspx

Answer 4

Las soluciones actuales de aquí no están abordando la situación actual en .NET 4 muy bien. Puede usar DynamicILInfo o ILGenerator para crear el método dinámico, pero las soluciones enumeradas aquí no funcionan con DynamicILInfo métodos dinámicos en total.

Si usa el método DynamicILInfo de generar IL o el método ILGenerator, el bytecode IL termina en DynamicMethod.m_resolver.m_code. No es necesario que compruebe ambos métodos y es una solución menos compleja.

Esta es la versión que debe utilizar:

public static byte[] GetILBytes(DynamicMethod dynamicMethod) 
{ 
    var resolver = typeof(DynamicMethod).GetField("m_resolver", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(dynamicMethod); 
    if (resolver == null) throw new ArgumentException("The dynamic method's IL has not been finalized."); 
    return (byte[])resolver.GetType().GetField("m_code", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(resolver); 
} 

See this answer para más métodos de ayuda y una solución para el problema de resolución símbolo DynamicMethod.