Compiling a lambda expression results in delegate with Closure argument

admin

Administrator
Staff member
When I use
Code:
Expression.Lambda( ... ).Compile()
in order to create a delegate from an expression tree, the result is a delegate of which the first argument is <a href="http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.closure.aspx">
Code:
Closure
</a>.

Code:
public static Func&lt;T, T, T&gt; CreateTest&lt;T&gt;()
{
    ParameterExpression a = Expression.Parameter( typeof( T ) );
    ParameterExpression b = Expression.Parameter( typeof( T ) );
    Expression addition = Expression.Add( a, b );

    return (Func&lt;T, T, T&gt;)Expression.Lambda( addition, a, b ).Compile();
}

...

// 'addition' equals
// Int32 lambda_method(
//     System.Runtime.CompilerServices.Closure,
//     Int32,
//     Int32 )
Func&lt;int, int, int&gt; addition = DelegateHelper.CreateTest&lt;int&gt;();
int result = addition( 5, 5 );

I can easily call the delegate through ordinary code without passing a
Code:
Closure
object, but where does this
Code:
Closure
come from?

How can I call this delegate dynamically?

Code:
// The following does not work.
// Exception: MethodInfo must be a runtime MethodInfo object.    
MethodInfo additionMethod = addition.Method;
int result = (int)additionMethod.Invoke( null, new object[] { 5, 5 } );

Using expression trees it looks like I have to pass the
Code:
Closure
object.

Code:
PropertyInfo methodProperty
    = typeof( Delegate ).GetProperty( "Method", typeof( MethodInfo ) );
MemberExpression getDelegateMethod
    = Expression.Property( Expression.Constant( addition ), methodProperty );
Func&lt;MethodInfo&gt; getMethodInfo
    = (Func&lt;MethodInfo&gt;)Expression.Lambda( getDelegateMethod ).Compile();
// Incorrect number of arguments supplied for call to method
// 'Int32 lambda_method(System.Runtime.CompilerServices.Closure, Int32, Int32)'
Expression call
    = Expression.Call(
        getMethodInfo(),
        Expression.Constant( 5 ), Expression.Constant( 5 ) );

This is a simplified example which doesn't make sense in its own right. What I am actually trying to achieve is to be able to wrap e.g.
Code:
Func&lt;Action&lt;SomeObject&gt;&gt;
with
Code:
Func&lt;Action&lt;object&gt;&gt;
. I can already do this for non nested delegates. This is useful during reflection, <a href="http://whathecode.wordpress.com/2011/07/02/casting-to-less-generic-types/">as discussed here</a>.

How should I correctly initialize this
Code:
Closure
object, or how do I prevent it from being there?