How to Call a Generic Method using "Expression.Parameter" and "Expression.Call" APIs

c# expression-trees generics

Question

Using the Expression Tree API I want to generate code for code that looks like this:

FieldInfo enumFieldInfo = enumFieldInfoSet.SingleOrDefault(fieldInfo => fieldInfo.Name == enumName);

I have written this code but it's not working:

var enumerableType = typeof(Enumerable);
var enumerableGenericType = typeof(IEnumerable<>).MakeGenericType(typeof(FieldInfo));
var predicateGenericType =  typeof(Func<>).MakeGenericType(typeof(Func<FieldInfo, bool>));

ParameterExpression fieldInfoSource = Expression.Parameter(enumerableGenericType, "fieldInfoSource");
ParameterExpression predicateSource = Expression.Parameter(predicateGenericType, "funcPredicateOnFieldInfo");

var arrayOfTypes = new Type[] { enumerableGenericType, predicateGenericType };

MethodCallExpression SingleOrDefaultMethodCall = Expression.Call(enumerableType, "SingleOrDefault",arrayOfTypes, fieldInfoSource, predicateSource);

Here is the runtime error: No generic method 'SingleOrDefault' on type 'System.Linq.Enumerable' is compatible with the supplied type arguments and arguments. No type arguments should be provided if the method is non-generic.

I have tried a number of combinations of type coercion but still have not stumbled on the right combination. I know that the SingleOrDefault is an Extension method on the Enumerable class and that it needs two parameters; I've look at the code via the debugger and have written to code inspect its properties at run-time; what am I missing.

Accepted Answer

The problem is that you are using the Expression.Call overload which takes a type, and for a static method you need an overload with MethodInfo.

void Main()
{
    Expression<Func<IEnumerable<FieldInfo>, Func<FieldInfo,bool>, FieldInfo>> singleOrDefaultExpr = (l,p) => l.SingleOrDefault(p);
    var callSource = (MethodCallExpression)singleOrDefaultExpr.Body;

    var method = callSource.Method;

    var collectionParameter = Expression.Parameter(typeof(IEnumerable<FieldInfo>), "enumFieldInfoSet");
    var enumNamePredicateParameter = Expression.Parameter(typeof(Func<FieldInfo,bool>), "enumNamePredicate");

    var body = Expression.Call(method, collectionParameter, enumNamePredicateParameter);

    var lambda = Expression.Lambda<Func<IEnumerable<FieldInfo>, Func<FieldInfo, bool>, FieldInfo>>(body, collectionParameter, enumNamePredicateParameter);
    var f = lambda.Compile();

    Console.WriteLine(f(typeof(Apple).GetFields(), fi => fi.Name == "color").Name);
}

class Apple
{
    public string color;
}

Also, you can use another method to find the required MethodInfo:

var method = typeof(Enumerable)
    .GetMethods()
    .Single(m => m.Name == "SingleOrDefault" && m.GetParameters().Count() == 2)
    .MakeGenericMethod(new[] {typeof(FieldInfo)});

UPDATE:

There is actually a simpler method, and you were on the right track, but your code had en error.

var collectionParameter = Expression.Parameter(typeof(IEnumerable<FieldInfo>), "enumFieldInfoSet");
var enumNamePredicateParameter = Expression.Parameter(typeof(Func<FieldInfo,bool>), "enumNamePredicate");
var body = Expression.Call(typeof(Enumerable), "SingleOrDefault", new[] { typeof(FieldInfo)}, collectionParameter, enumNamePredicateParameter);
var lambda = Expression.Lambda<Func<IEnumerable<FieldInfo>, Func<FieldInfo, bool>, FieldInfo>>(body, collectionParameter, enumNamePredicateParameter);

The problem was that SingleOrDefault has only one generic type parameter: 'FieldInfo' in this case:

SingleOrDefault<FieldInfo>(....

Don't mix it up with the method parameters, there are two of them:

SingleOrDefault<GenericParameter>(
    this IEnumerable<GenericParameter> firstMethodParameter,
    Func<GenericParameter, bool> secondMethodParameter
)

Popular Answer

George did a great job in getting me on the right track and did provide me a partial answer; I re-fashion my code so that is was clear to me. This is an example of code that I wanted to machine generate in testing our Meta-programming runtime. I am providing more code than is necessary for the specific problem but I wanted the others to see the greater context.

// Code to Generate Enum Field Metadata ...

string enumName   = Enum.GetName(theEnumType, theOrdinalEnumValue);
Array  enumValues = Enum.GetValues(theEnumType);
object enumValue  = enumValues.GetValue(theOrdinalEnumValue);
object enumObject = Enum.ToObject(theEnumType, theOrdinalEnumValue);

// Create Local variables of the types targeted for assignment expressions that we will make in the generated code

var enumVariables = Expression.RuntimeVariables(Expression.Variable(typeof(string), "gcEnumName"),
                                                Expression.Variable(typeof(Array), "gcEnumValues"),
                                                Expression.Variable(typeof(object), "gcEnumValue"),
                                                Expression.Variable(theEnumType, "gcEnumObject"),
                                                Expression.Variable(typeof(FieldInfo), "gcFieldInfoOnEnum"));

// Setup the Input Parameters for calls into Enum and Array Types in preperation for Assignments

ParameterExpression theInputOfEnumType     = Expression.Variable(typeof(Type), "theInputOfEnumType");
ParameterExpression theEnumFieldNameValue  = Expression.Variable(typeof(string), "theEnumFieldNameValue");
ParameterExpression aEnumObjectIndexValue  = Expression.Variable(typeof(int), "aEnumObjectIndexValue");
ParameterExpression anArrayOfEnumObjects   = Expression.Variable(typeof(Array), "anArrayOfEnumObjects");
ParameterExpression anEnumerableObject     = Expression.Variable(typeof(Enumerable), "anEnumerableObject");
ParameterExpression directEnumTypeResolved = Expression.Variable(theEnumType, "directEnumTypeResolved");
ParameterExpression fieldInfoOnEnum        = Expression.Variable(typeof(FieldInfo), "fieldInfoOnEnum");

var fieldInfoEnumerableRepresentation = typeof(Enumerable);

In perpetration of making calls to "Expression.Call" we need to get some MethodInfo data

// We need to generate MethodInfo on the Methods we want to call in the generated code. This is metadata
// we need to call the Expression.Call API.

MethodInfo enumGetNameMethodInfo   = enumMetadata.GetMethods().FirstOrDefault(info => info.Name == "GetName");
MethodInfo enumGetValuesMethodInfo = enumMetadata.GetMethods().FirstOrDefault(info => info.Name == "GetValues");

MethodInfo enumGetValueMethodInfo  = arraryMetadata.GetMethods()
  .FirstOrDefault(methodInfo => (methodInfo.Name == "GetValue") && methodInfo.GetParameters().Any(param =>param.ParameterType == typeof(int)));
MethodInfo enumToObjectMethodInfo  = enumMetadata.GetMethods()
                                    .FirstOrDefault(info => info.Name == "ToObject");

// We know that there exist a number of polymorphic instances of the "SingleOrDefault" Extension method
// so we use the name of the parameter named "predicate" to locate our method. **FYI Can't use the MethodInfo data in a call to Expression.Call - It's a generic definition**.

MethodInfo enumerableSingleOrDefaultInfo = fieldInfoEnumerableRepresentation.GetMethods()
  .FirstOrDefault(methodInfo => (methodInfo.Name == "SingleOrDefault") &&
                                 methodInfo.GetParameters()
                                   .Any(param => param.Name == "predicate"));

Here is the final code that works in making a call to a Generic Method:

// An approach to setup a Generic method call that will be used in an Expression.Assign call

// I decompose this code so for debugging purposes

// I create the "inputOfTSourceType" as a Generic Type because in the Definition of "SingleOrDefault" method there is only one Generic Parameter;
// also, take special note that in the assemblage of Expression.Call methods any of the methods that take a MethodInfo instance you can't pass in
// a "Generic" method definition. If you take a look at the code that is called it will throw and exception if it detects the IsGenericMethodDefinition
// flag is true.
var inputOfTSourceType  = typeof(IEnumerable<>).MakeGenericType(typeof(FieldInfo));  // This is the type on the "source" TSource parameter
var predicateOfFuncType = typeof(Func<FieldInfo, bool>);   // This is the type on the "predicate" parameter
// Take note there that we only define one(1) type here ("inputParameterType"); this is the type we wish apply to the Generic Type TSource
// declaration: public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
var inputParameterType  = new[] {typeof(FieldInfo)};       // This is the type we must match to "source" parameter

// The "SingleOrDefault" method can take two parameters and in this case I need to pass in a lambda expression as the predicate.
// Se we need two parameters. 

ParameterExpression fieldInfoSource = Expression.Parameter(inputOfTSourceType, "fieldInfoSource");           // This is: this IEnumerable<TSource>
ParameterExpression predicateSource = Expression.Parameter(predicateOfFuncType, "funcPredicateOnFieldInfo"); // This is: Func<TSource, bool> predicate

 MethodCallExpression SingleOrDefaultMethodCall = 
     Expression.Call(fieldInfoEnumerableRepresentation, // This is the Object Instance for which the 
                     "SingleOrDefault", // The Name of the Generic Method
                     inputParameterType, // The Generic Type
                     fieldInfoSource,    // this is the "this" source parameter
                     predicateSource);   // this the "predicate" parameter

 Expression localEnumNameAssignment =
   Expression.Assign(enumVariables.Variables[0], EnumGetNameMethodCall);
 Expression localEnumObjectsAssignment =
   Expression.Assign(enumVariables.Variables[1], EnumGetValauesMethodCall);
 Expression localEnumObjectAssignment =
   Expression.Assign(enumVariables.Variables[2], ArrayGetValueMethodCall);
 Expression localEnumTypeAssignment = 
   Expression.Assign(enumVariables.Variables[3], Expression.Convert(EnumToObjectMethodCall, theEnumType));
 Expression localFieldInfoAssignment =
   Expression.Assign(enumVariables.Variables[4], Expression.Convert(SingleOrDefaultMethodCall, typeof(FieldInfo)));

 BlockExpression blockExpression =
   Expression.Block(enumVariables, 
   localEnumNameAssignment, 
   localEnumObjectsAssignment, 
   localEnumObjectAssignment, 
   localEnumTypeAssignment, 
   localFieldInfoAssignment, 
   enumTypeToReturn);

Here's the generated code:

$gcEnumName = .Call System.Enum.GetName(
   $theInputOfEnumType, $gcEnumName = (System.String)$theEnumFieldNameValue)

$gcEnumValues = .Call System.Enum.GetValues($theInputOfEnumType)

$gcEnumValue = .Call $anArrayOfEnumObjects.GetValue((System.Int32)  $theOrdinalEnumValue)

$gcEnumObject = (WorkflowMessagingCommands).Call System.Enum.ToObject(
   $theInputOfEnumType,
   (System.Object)$theEnumInstance)

// Here is the generated code to call "SignleOrDefault"
$gcFieldInfoOnEnum = .Call System.Linq.Enumerable.SingleOrDefault(
    $thisSourceType,
    $predciateType)


Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Is this KB legal? Yes, learn why
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Is this KB legal? Yes, learn why