private static Expression CreateLambdaExpression(ParameterExpression parameter, string property, object value, LambdaCompare compare)
{
//var propertyExpression = Expression.Convert(Expression.Property(parameter, property), value.GetType());
var propertyExpression = Expression.Property(parameter, property);
var valueExpression = Expression.Constant(value);
switch (compare)
{
case LambdaCompare.LessThan:
return(Expression.LessThan(propertyExpression, valueExpression));
case LambdaCompare.LessThanOrEqual:
return(Expression.LessThanOrEqual(propertyExpression, valueExpression));
case LambdaCompare.GreaterThan:
return(Expression.GreaterThan(propertyExpression, valueExpression));
case LambdaCompare.GreaterThanOrEqual:
return(Expression.GreaterThanOrEqual(propertyExpression, valueExpression));
case LambdaCompare.Equal:
return(Expression.Equal(propertyExpression, valueExpression));
case LambdaCompare.NotEqual:
return(Expression.NotEqual(propertyExpression, valueExpression));
case LambdaCompare.Contains:
return(Expression.Call(propertyExpression, MethodCreator.CreateStringContainMethod(), valueExpression));
case LambdaCompare.Unknown:
default:
throw new ArgumentOutOfRangeException(nameof(compare), compare, null);
}
}
private MethodCallExpression CreateIncludeMethodCallExpression(Expression pExpression, bool hasncludeFilter)
{
MethodInfo include;
Expression includePropertyExpr;
var list = Properties.Values.Where(p => !p.ShouldInclude && p.ComputedExpression != null).Select(p => p.ComputedExpression).ToList();
if (hasncludeFilter && list.Any())
{
var w = MethodCreator.CreateGenericEnumerableWhereMethod(Type);
var whereExpr = list.Aggregate(Expression.AndAlso);
var l = Expression.Lambda(whereExpr, false, ParameterExpression);
var c = Expression.Property(Parent.ParameterExpression, NodeName);
includePropertyExpr = Expression.Call(null, w, new Expression[] { c, l });
include = Depth > 1 ? MethodCreator.CreateGenericThenIncludeMethod(Parent, this, typeof(IEnumerable <>)) : MethodCreator.CreateGenericIncludeMethod(Parent, this, typeof(IEnumerable <>));
}
else
{
includePropertyExpr = Expression.Property(Parent.ParameterExpression, NodeName);
include = Depth > 1 ? MethodCreator.CreateGenericThenIncludeMethod(Parent, this, typeof(ICollection <>)) : MethodCreator.CreateGenericIncludeMethod(Parent, this, typeof(ICollection <>));
}
var lambda = Expression.Lambda(includePropertyExpr, false, Parent.ParameterExpression);
var exp = Expression.Call(null, include, new[] { pExpression, Expression.Quote(lambda) });
return(exp);
}
private Expression CreateAnyExpression()
{
if (WherePredictExpression == null)
{
return(null);
}
var wInfo = MethodCreator.CreateGenericAnyMethod(Type);
var lambda = Expression.Lambda(WherePredictExpression, false, ParameterExpression);
var c = Expression.Property(Parent.ParameterExpression, NodeName);
var exp = Expression.Call(null, wInfo, new Expression[] { c, Expression.Quote(lambda) });
return(exp);
}
private static IQueryable <T> CreateQueryWhere <T>(IQueryable <T> queryable, ExpressionNode node)
{
var predict = node.CreateWherePredictExpression();
if (predict == null)
{
return(queryable);
}
var wInfo = MethodCreator.CreateGenericQueryableWhereMethod(node.Type);
var lambda = Expression.Lambda(node.WherePredictExpression, false, node.ParameterExpression);
var exp = Expression.Call(null, wInfo, new[] { queryable.Expression, Expression.Quote(lambda) });
return(queryable.Provider.CreateQuery <T>(exp));
}