如何将Expression.Lambda附加到任何所有者类型？

Question

I want this test to pass:

[Test]
public void LambdaTest()
{
    var m = Expression.Lambda(typeof(Func<int>), Expression.Constant(0)).Compile();
    Assert.That(m.Method.DeclaringType, Is.Not.Null);
}

This is necessary to make stack-walking lagacy code to work correctly. What's the simpliest way to do it?

I would prefer the most portable way.

Answer 1

You can build a new type at runtime and then compile the expression into a method of that type.

You need to create a new assembly and a new module at run time. Once you create those, you can use them to create as many types as you like. Here is a code sample to create the assembly and the module:

var assemblyBuilder =
    AppDomain.CurrentDomain.DefineDynamicAssembly(
        new AssemblyName {Name = "MyNewAssembly"},
        AssemblyBuilderAccess.Run);

var moduleBuilder = assemblyBuilder.DefineDynamicModule("MyNewModule");

Now, you can use the module builder to define a new type like this:

var typeBuilder = moduleBuilder.DefineType("MyNewType"); 

And then a new method like this:

var methodBuilder = 
    typeBuilder.DefineMethod(
        "MyNewMethod",
        MethodAttributes.Public | MethodAttributes.Static,
        typeof(int), //returns an int
        new Type[]{}); //takes no parameters

Please note that the method signature should match your expression delegate type.

Next, we compile the expression into the new method using the CompileToMethod method:

var expression = Expression.Lambda(typeof(Func<int>), Expression.Constant(0));

expression.CompileToMethod(methodBuilder);

We generate the actual type from the type builder:

var type = typeBuilder.CreateType();

Then we use the Delegate.CreateDelegate method to create a delegate to the newly created static method like this:

Func<int> func =
    (Func<int>)Delegate.CreateDelegate(
        typeof(Func<int>),
        type.GetMethod("MyNewMethod"));

int value = func(); //Test

Now func.Method.DeclaringType would return our dynamically created type.

You can easily use this code to generate some helper methods to make it easy to use.

Answer 2

Ok, I found it myself but I'm not sure how it will work in .NET Core and which framework may or may not support this. If you have a better (more elegant or portable) solution please feel free to post your answer.

The key is to use CompileToMethod of Lambda expression.

[Test]
public void LambdaTest2()
{
    var asm = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("test"), AssemblyBuilderAccess.Run);
    var masm = asm.DefineDynamicModule("main");

    var type = masm.DefineType("TestType");
    var mb = type.DefineMethod("TestMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new Type[0]);

    // your lambda
    ConstantExpression expressionTree = Expression.Constant(0);
    Expression.Lambda(typeof(Func<int>), expressionTree).CompileToMethod(mb);

    var m = (Func<int>)Delegate.CreateDelegate(typeof(Func<int>), type.CreateType().GetMethod("TestMethod"));

    Assert.That(m.Method.DeclaringType, Is.Not.Null);

    // you can create another in the same module but with another type (because type can't be changed)
    var type2 = masm.DefineType("TestType2");
    var mb2 = type2.DefineMethod("TestMethod2", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new Type[0]);

    // your lambda 2
    ConstantExpression expresisonTree2 = Expression.Constant(1);
    Expression.Lambda(typeof(Func<int>), expresisonTree2).CompileToMethod(mb2);

    var m2 = (Func<int>)Delegate.CreateDelegate(typeof(Func<int>), type2.CreateType().GetMethod("TestMethod2"));

    Assert.That(m2.Method.DeclaringType, Is.Not.Null);

    // check correctness
    Assert.That(m(), Is.EqualTo(0));
    Assert.That(m2(), Is.EqualTo(1));
}

Answer 3

A lambda expression compiles to a DynamicMethod, which is always null for the DeclaringType property.

See DynamicMethod definition

See this SO answer also

Would make my life easier as well if I could find a way around that.