private static BinaryExpression GetExpression(RuleGroupType type, Expression param, Filter filter1, Filter filter2)
{
Expression bin1 = GetExpression(param, filter1);
Expression bin2 = GetExpression(param, filter2);
return(type == RuleGroupType.All ? Expression.AndAlso(bin1, bin2) : Expression.OrElse(bin1, bin2));
}
/// <summary>
/// Create an Expression from a list of filters that, applied to a collection of type T,
/// will return a new collection filtered by the conditions in the expression.
/// </summary>
/// <typeparam name="T">The type of the result returned by the expression</typeparam>
/// <param name="type">The group type (All or Any)</param>
/// <param name="filters">A list of filters that each define one part of the expression</param>
/// <returns>An Expression that filters a list of type T based on the filters</returns>
public static Expression <Func <T, bool> > GetExpression <T>(RuleGroupType type, IList <Filter> filters)
{
if (filters.Count == 0)
{
return(null);
}
ParameterExpression param = Expression.Parameter(typeof(T), "t");
Expression exp = null;
if (filters.Count == 1)
{
exp = GetExpression(param, filters[0]);
}
else if (filters.Count == 2)
{
exp = GetExpression(type, param, filters[0], filters[1]);
}
else
{
while (filters.Count > 0)
{
var f1 = filters[0];
var f2 = filters[1];
exp = (exp == null)
? GetExpression(type, param, filters[0], filters[1])
: type == RuleGroupType.All
? Expression.AndAlso(exp, GetExpression(type, param, filters[0], filters[1]))
: Expression.OrElse(exp, GetExpression(type, param, filters[0], filters[1]));
filters.Remove(f1);
filters.Remove(f2);
if (filters.Count == 1)
{
exp = Expression.AndAlso(exp, GetExpression(param, filters[0]));
filters.RemoveAt(0);
}
}
}
return(exp == null ? null : Expression.Lambda <Func <T, bool> >(exp, param));
}
public override void NegateRule()
{
SelectedType = SelectedType == RuleGroupType.And ? RuleGroupType.Or : RuleGroupType.And;
_model.SelectedType = SelectedType;
}
