private static Expression MakeComparison(Expression left, TypeFilterEnum comparison, string value)
{
switch (comparison)
{
case TypeFilterEnum.EQUAL:
return(MakeBinary(ExpressionType.Equal, left, value));
case TypeFilterEnum.NOT_EQUAL:
return(MakeBinary(ExpressionType.NotEqual, left, value));
case TypeFilterEnum.GREATER_THAN:
return(MakeBinary(ExpressionType.GreaterThan, left, value));
case TypeFilterEnum.GREATER_THAN_OR_EQUAL:
return(MakeBinary(ExpressionType.GreaterThanOrEqual, left, value));
case TypeFilterEnum.LESS_THAN:
return(MakeBinary(ExpressionType.LessThan, left, value));
case TypeFilterEnum.LESS_THAN_OR_EQUAL:
return(MakeBinary(ExpressionType.LessThanOrEqual, left, value));
case TypeFilterEnum.CONTAINS:
case TypeFilterEnum.STARTS_WITH:
case TypeFilterEnum.ENDS_WITH:
return(Expression.Call(MakeString(left), GetStringComparison(comparison), Type.EmptyTypes, Expression.Constant(value, typeof(string))));
default:
throw new NotSupportedException($"Invalid comparison operator '{comparison}'.");
}
}
public static string Format(this TypeFilterEnum typeFilter)
{
switch (typeFilter)
{
case TypeFilterEnum.Movie:
return("movie");
case TypeFilterEnum.Episode:
return("episode");
case TypeFilterEnum.All:
return("all");
default:
throw new ArgumentException(nameof(typeFilter));
}
}
public WhereDinamicItem(string propertyName, TypeFilterEnum typeFilter, string value)
{
PropertyName = propertyName;
TypeFilter = typeFilter;
Value = value;
}
public static Expression <Func <T, bool> > BuildPredicate <T>(string propertyName, TypeFilterEnum comparison, string value)
{
var parameter = Expression.Parameter(typeof(T), "x");
var left = propertyName.Split('.').Aggregate((Expression)parameter, Expression.Property);
var body = MakeComparison(left, comparison, value);
return(Expression.Lambda <Func <T, bool> >(body, parameter));
}
private static string GetStringComparison(TypeFilterEnum typeFilterEnum) => typeFilterEnum switch
{
