/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="param">The root expression</param>
/// <param name="memberField">The expression that leads to the property</param>
/// <param name="operation">The operator defined as a string</param>
/// <param name="value">The value to compare the field with</param>
/// <returns></returns>
private Expression <Func <T, bool> > CreateExpression <T>(
ParameterExpression param,
MemberExpression memberField,
string operation,
object value)
{
// Get the converter and parser
TypeConverter converter = TypeDescriptor.GetConverter(memberField.Type);
IParser parser = Descriptor.GetParser(converter);
// Check if the value can be converted and/or parsed
object parsedValue = memberField.ParseValue(value);
bool canConvert = parser?.IsValid(parsedValue) ?? converter.IsValid(parsedValue);
if (!canConvert)
{
return(null);
}
// Convert value to constant value
object result = parser?.ConvertFrom(value) ?? converter.ConvertFrom(value);
ConstantExpression constant = Expression.Constant(result);
// Interpret the operator and convert into an expression
Operators operatorType = operation.GetValueFromDescription <Operators>();
Expression comparingExpression = operatorType switch
{
Operators.IsSame => Equals(memberField, constant),
Operators.Equals => Equals(memberField, constant),
Operators.Eq => Equals(memberField, constant),
Operators.Neq => NotEquals(memberField, constant),
Operators.Like => Like(memberField, constant),
Operators.Contains => Like(memberField, constant),
Operators.DoesNotContain => DoesNotContain(memberField, constant),
Operators.StartsWith => StartsWith(memberField, constant),
Operators.EndsWith => EndsWith(memberField, constant),
Operators.DoesNotStartWith => DoesNotStartWith(memberField, constant),
Operators.DoesNotEndWith => DoesNotEndWith(memberField, constant),
Operators.Gte => GreaterThanOrEqual(memberField, constant),
Operators.Gt => GreaterThan(memberField, constant),
Operators.Lte => LessThanOrEqual(memberField, constant),
Operators.Lt => LessThan(memberField, constant),
Operators.IsNullOrEmpty => IsNullOrEmpty(memberField),
Operators.IsNotNullOrEmpty => IsNotNullOrEmpty(memberField),
_ => null
};
// Convert expression
return(comparingExpression == null ? null : Expression.Lambda <Func <T, bool> >(comparingExpression, param));
}
