private static Expression GetExpression(ParameterExpression param, FilterDef filter)
{
MemberExpression member = Expression.Property(param, filter.Field);
var converter = TypeDescriptor.GetConverter(member.Type);
if (!converter.IsValid(filter.Value))
{
return(null);
}
var propertyValue = converter.ConvertFromInvariantString(filter.Value);
ConstantExpression constant = Expression.Constant(propertyValue, member.Type);
switch (filter.Operand)
{
case Operand.Equal:
#if NETFRAMEWORK
if (member.Type == typeof(DateTime?) || member.Type == typeof(DateTime))
{
var me = Expression.Convert(member, member.Type);
var ex = Expression.Call(null, typeof(DbFunctions).GetMethod("TruncateTime", new Type[] { member.Type }), me);
return(Expression.Equal(ex, constant));
}
#endif
return(Expression.Equal(member, constant));
case Operand.NotEqual:
return(Expression.NotEqual(member, constant));
case Operand.GreaterThan:
return(Expression.GreaterThan(member, constant));
case Operand.GreaterThanOrEqual:
return(Expression.GreaterThanOrEqual(member, constant));
case Operand.LessThan:
return(Expression.LessThan(member, constant));
case Operand.LessThanOrEqual:
return(Expression.LessThanOrEqual(member, constant));
case Operand.Contains:
return(Expression.Call(member, containsMethod, constant));
case Operand.StartsWith:
return(Expression.Call(member, startsWithMethod, constant));
case Operand.EndsWith:
return(Expression.Call(member, endsWithMethod, constant));
default:
return(null);
}
}
public static Expression <Func <T, bool> > GetExpression <T>(FilterDef filter)
{
if (filter == null)
{
return(null);
}
ParameterExpression param = Expression.Parameter(typeof(T), "t");
var exp = GetExpression(param, filter);
if (exp == null)
{
return(null);
}
return(Expression.Lambda <Func <T, bool> >(exp, param));
}
