Calling a Generic Method using Lambda Expressions (and a Type only known at runtime)

Question

You can use Lambda Expression Objects to represent a lambda as an expression.

How do you create a Lambda Expression Object representing a generic method call, if you only know the type -that you use for the generic method signature- at runtime?

For example:

I want to create a Lambda Expression Objects to call: public static TSource Last<TSource>( this IEnumerable<TSource> source )

But I only know what TSource is at runtime.

Istic

This isn't entirely clear. Which method on which object are you trying to create? Do you want a reference to the Last generic method with a lambda expression? – Conservatoire

@CasperOne: Hi Casper! a) I'm trying to create an instance of TheObject, that references to TheMethod. b) yes, I want to reference the last method with a lambda expression (lambda expression object I mean). Thanks : ) – Istic

Answer 1

static Expression<Func<IEnumerable<T>, T>> CreateLambda<T>()
{
    var source = Expression.Parameter(
        typeof(IEnumerable<T>), "source");

    var call = Expression.Call(
        typeof(Enumerable), "Last", new Type[] { typeof(T) }, source);

    return Expression.Lambda<Func<IEnumerable<T>, T>>(call, source)
}

or

static LambdaExpression CreateLambda(Type type)
{
    var source = Expression.Parameter(
        typeof(IEnumerable<>).MakeGenericType(type), "source");

    var call = Expression.Call(
        typeof(Enumerable), "Last", new Type[] { type }, source);

    return Expression.Lambda(call, source)
}

Devoid

Answer 2

I don't fully understand the question, but the code that dtb wrote could be written simply as:

class MyUtils {
  public static Expression<Func<IEnumerable<T>, T>> CreateLambda<T>() { 
    return source => source.Last();
  }
}

The code in the sample by dtb is pretty much the same thing as what the C# compiler automatically generates for you from this lambda expression (compiled as expression tree, because the return type is Expression).

If you know the type at runtime, then you can either use the solution by dtb or you can invoke the CreateLambda method (above) using Reflection, which may be slower, but allows you to write the code in the lambda in the natural C#:

var createMeth = typeof(MyUtils).GetMethod("CreateLambda");
LambdaExpression l = createMeth.MakeGenericMethod(yourType).Invoke();

The nice thing about this approach is that the code in CreateLambda can be much more complicated, which would be really hard to do using expression trees explicitly.

Allodium

Hi Tomas! I need to improve my programming communication skills I know, I know hahahha (but don't worry I'm working on it : ). I updated the question to represent what I really meant. Nice refactor! +1 – Istic

@SDReyes: "at runtime" was the important point. You can still use the nice C# syntax for this though (without explicitly constructing expression trees). See my updated answer. – Allodium

Hi Tomas!, I agree with you. this approach let you implement easily complex lambdas inside the CreateLambda method (with just a performance tradeoff). I'm gonna use the dtb approach this time, because we are already using lots of expressions in the component we're working on, and I want to keep coherence among the code : ). but I'm going to be glad to implement yours in next scenarios too! Nice job Tomas! regards. SD – Istic