Declaring Func dynamically

by

You can do this by using an open generic type definition, and then making the specific type from that:

typeof(Func<,>).MakeGenericType(typeof(int), orderType);

However, what you’re trying to do (calling Lambda<TDelegate>) is not directly possible. You must call Lambda without a type parameter:

var propertyinfo = typeof(T).GetProperty(sortExpressionStr);
Type orderType = propertyinfo.PropertyType;

var param = Expression.Parameter(typeof(T), "x");
var sortExpression = Expression.Lambda(
        Expression.Convert(Expression.Property(param, sortExpressionStr),
                           orderType), 
        param));

This will create the proper Func<,> for you behind the scenes. If you want to compile the expression and use the delegate, you can only do this dynamically with

sortExpression.Compile().DynamicInvoke(param);

If you want to call the OrderBy extension method on Queryable, things get a little more complicated:

var propertyInfo = typeof(T).GetProperty(sortExpressionStr);
Type orderType = propertyInfo.PropertyType;

// first find the OrderBy method with no types specified
MethodInfo method = typeof(Queryable).GetMethods()
  .Where(m => m.Name == "OrderBy" && m.GetParameters().Length == 2)
  .Single();
// then make the right version by supplying the right types
MethodInfo concreteMethod = method.MakeGenericMethod(typeof(T), orderType);

var param = Expression.Parameter(typeof(T), "x");

// the key selector for the OrderBy method
Expression orderBy =
    Expression.Lambda(
        Expression.Property(orderParam, propertyInfo),
        orderParam);

// how to use:
var sequence = new T[0].AsQueryable(); // sample IQueryable

// because no types are known in advance, we need to call Invoke 
// through relection here
IQueryable result = (IQueryable) concreteMethod.Invoke(
                                   null, // = static
                                   new object[] { sequence, orderBy });

More Related Contents:

  1. Retrieving Property name from lambda expression
  2. Is there a reason for C#’s reuse of the variable in a foreach?
  3. Why would you use Expression rather than Func?
  4. delegate keyword vs. lambda notation
  5. How to convert a String to its equivalent LINQ Expression Tree?
  6. Mutating the expression tree of a predicate to target another type
  7. Replace parameter in lambda expression
  8. How do I create an expression tree to represent ‘String.Contains(“term”)’ in C#?
  9. Pass expression parameter as argument to another expression
  10. Expression.Lambda and query generation at runtime, simplest “Where” example
  11. Why can I not edit a method that contains an anonymous method in the debugger?
  12. Why can’t c# use inline anonymous lambdas or delegates? [duplicate]
  13. Access the value of a member expression
  14. How do I dynamically create an Expression predicate?
  15. How to use Expression Tree to safely access path of nullable objects?
  16. How do I translate an expression tree of one type to a different expression type?
  17. Getting the object out of a MemberExpression?
  18. System.Linq.Expression.Compile error
  19. How to perform Join between multiple tables in LINQ lambda
  20. Using the iterator variable of foreach loop in a lambda expression – why fails?
  21. Anonymous method in Invoke call
  22. Lambda expression not returning expected MemberInfo
  23. What is a Predicate Delegate and where should it be used?
  24. How to convert an expression tree to a partial SQL query?
  25. Generate EF orderby expression by string [duplicate]
  26. Lambda Expression using Foreach Clause [duplicate]
  27. How do I dynamically create an Expression predicate from Expression?
  28. Task.Factory.StartNew with async lambda and Task.WaitAll
  29. C#: Recursive functions with Lambdas
  30. Convert DataTable to Generic List in C#

Leave a Comment