/// <summary>
/// Applies your conditions against an IQueryable with collection conditions (ie. contains)
/// </summary>
/// <typeparam name="TItem">The type of the data in the data source this will be applied against</typeparam>
/// <typeparam name="TCondition">The type of the condition</typeparam>
/// <param name="query">The IQueryable query</param>
/// <param name="conditions">The map of conditions</param>
/// <param name="expressionType">The expression type,</param>
/// <returns></returns>
public static IQueryable <TItem> ApplyConditions <TItem, TCondition>(IQueryable <TItem> query, MultiMap <List <TCondition> > conditions, CollectionExpressionType expressionType)
{
if (conditions is null || conditions.Count == 0)
{
return(query);
}
IQueryable <TItem> output = query;
foreach (KeyValuePair <string, List <List <TCondition> > > condition in conditions)
{
foreach (List <TCondition> item in condition.Value)
{
output = output.Where(GetPredicate <TItem, TCondition>(expressionType, condition.Key, item));
}
}
return(output);
}
public static Expression <Func <TItem, bool> > GetPredicate <TItem, TCondition>(CollectionExpressionType expressionType, string propertyName, List <TCondition> values)
{
ParameterExpression parameter = Expression.Parameter(typeof(TItem), "item");
Expression property = Expression.Property(parameter, propertyName);
Expression constant = Expression.Constant(values);
MethodInfo method;
switch (expressionType)
{
case CollectionExpressionType.Contains:
method = typeof(List <TCondition>).GetMethod("Contains", new Type[] { typeof(TCondition) });
break;
default:
throw new NotImplementedException();
}
Expression finalMethod = Expression.Call(constant, method, property);
return(Expression.Lambda <Func <TItem, bool> >(finalMethod, parameter));
}
