在动态类型上使用 IEqualityComparer 调用 Linq GroupBy

Question

I want to create a dynamic GroupBy implementation that ignores case. I am using Expression.Call , which allows me to pass Expressions as arguments.

There are several answers on how to create a custom comparer, but this question is about how to pass a comparer dynamically.

Here is the complete method:

public static IQueryable GroupBy(this IQueryable source, string keySelector, string elementSelector, params object[] values)
{
    if (source == null) throw new ArgumentNullException("source");
    if (keySelector == null) throw new ArgumentNullException("keySelector");
    if (elementSelector == null) throw new ArgumentNullException("elementSelector");
    LambdaExpression keyLambda = DynamicExpression.ParseLambda(source.ElementType, null, keySelector, false, values);
    LambdaExpression elementLambda = DynamicExpression.ParseLambda(source.ElementType, null, elementSelector, false, values);

    return source.Provider.CreateQuery(
        Expression.Call(
            typeof(Queryable), 
            "GroupBy", 
            new Type[] { source.ElementType, keyLambda.Body.Type, elementLambda.Body.Type },
            source.Expression, 
            Expression.Quote(keyLambda), 
            Expression.Quote(elementLambda)
        )
    );
}

The call to Queryable.GroupBy is created by:

Expression.Call(typeof(Queryable), "GroupBy", 
  new Type[] { source.ElementType, keyLambda.Body.Type, elementLambda.Body.Type },
  source.Expression, Expression.Quote(keyLambda), Expression.Quote(elementLambda))

Queryable.GroupBy allows to pass a custom IEqualityComparer . How can I do this? Expression.Call only allows me to pass arguments of type Expression .

Is there any other way I can group with case ignored, by eg dynamically overriding GetHashCode() of the keys?

Answer 1

You should call it the same way, as you would normally by adding comparer in GroupBy call:

return source.Provider.CreateQuery(
    Expression.Call(
        typeof(Queryable),
        "GroupBy", 
        new Type[] { source.ElementType, keyLambda.Body.Type, elementLambda.Body.Type },
        source.Expression,
        Expression.Quote(keyLambda),
        Expression.Quote(elementLambda),
        Expression.Constant(StringComparer.InvariantCultureIgnoreCase)
    )
);

Answer 2

StringComparer can not be used here because the type is dynamic and not string. I had to elaborate on Krzysztofs answer to find a solution that worked.

First create an instance of a custom dynamic comparer DynamicCaseInsensitiveComparer<T> (which implements IEqualityComparer) of the same type as keyLambda.Body.Type . Since the type is provided by a variable, you have to use MakeGenericType . Then add it in the GroupBy call:

var comparerType = typeof(DynamicCaseInsensitiveComparer<>).MakeGenericType(keyLambda.Body.Type);
var keyComparer = Activator.CreateInstance(comparerType);

return source.Provider.CreateQuery(
    Expression.Call(
        typeof(Queryable),
        "GroupBy", 
        new Type[] { source.ElementType, keyLambda.Body.Type, elementLambda.Body.Type },
        source.Expression,
        Expression.Quote(keyLambda),
        Expression.Quote(elementLambda),
        Expression.Constant(keyComparer)
    )
);

How to create a custom comparer has been answered in other questions, see for example IEqualityComparer for Annoymous Type