Affichage du code IL généré à partir d'une expression compilé

Question

Est-il possible d'afficher le code IL généré lorsque vous appelez Compile () sur un arbre d'expression? Considérez cet exemple très simple:

class Program
{
    public int Value { get; set; }

    static void Main(string[] args)
    {
        var param = Expression.Parameter(typeof(Program));
        var con = Expression.Constant(5);
        var prop = Expression.Property(param, typeof(Program).GetProperty("Value"));
        var assign = Expression.Assign(prop, con);
        Action<Program> lambda = Expression.Lambda<Action<Program>>(assign, param).Compile();

        Program p = new Program();
        lambda(p);



        //p.Value = 5;
    }
}

Maintenant, l'arbre d'expression fait ce que la dernière ligne de dit Main. Compilez l'application, puis ouvrez-le dans le réflecteur. Vous pouvez voir le code IL de p.Value = 5; qui fait la cession. Mais l'arbre d'expression a été fait et compilé lors de l'exécution. Est-il possible d'afficher le code IL résultant de la compilation?

Answer 1

Oui! Utilisez cet outil:

https://github.com/drewnoakes/il-visualizer

Ce fut très utile quand j'exécutait et le débogage Compile, comme je suis sûr que vous pouvez imaginer.

Answer 2

Créer un DynamicAssembly, puis un DynamicModule, DynamicType et DynamicMethod. Rendre public méthode et statique et le transmettre à la méthode CompileTo () sur le lambda. Lorsque vous faites le drapeau de montage comme Save. Ensuite, appelez la méthode Save () et passer un chemin. Il sera écrit sur le disque. Pop-il ouvert dans le réflecteur.

Quelque chose comme:

var da = AppDomain.CurrentDomain.DefineDynamicAssembly(
    new AssemblyName("dyn"), // call it whatever you want
    AssemblyBuilderAccess.Save);

var dm = da.DefineDynamicModule("dyn_mod", "dyn.dll");
var dt = dm.DefineType("dyn_type");
var method = dt.DefineMethod(
    "Foo", 
    MethodAttributes.Public | MethodAttributes.Static);

lambda.CompileToMethod(method);
dt.CreateType();

da.Save("dyn.dll");