private static bool LiftModelToViewItem(ref LambdaExpression lambda)
{
if (lambda.Parameters[0].Type == typeof(T))
{
ParameterExpression paramItem = Expression.Parameter(typeof(AggregationResultItem <T>), "item"), paramOrigin = lambda.Parameters[0];
MemberExpression model = Expression.Property(paramItem, "Model");
var body = ReplacementVisitor.Replace(lambda.Body, (current) =>
{
if (current is MemberExpression member)
{
if (member.Member.DeclaringType == typeof(T))
{
return(Expression.MakeMemberAccess(model, member.Member));
}
}
return(null);
});
lambda = Expression.Lambda(body, paramItem);
return(true);
}
else
{
return(false);
}
}
public static Expression Replace(Expression expression, Func <Expression, Expression> evaluator)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
ReplacementVisitor visitor = new ReplacementVisitor(evaluator);
return(visitor.Visit(expression));
}
public static Expression Replace(Expression expression, Expression find, Expression replaceWith)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
ReplacementVisitor util = new ReplacementVisitor(find, replaceWith);
return(util.Visit(expression));
}
internal static Expression ExtractExpression(LambdaExpression lambda, ParameterExpression param)
{
if (lambda.Parameters.Count > 0)
{
return(ReplacementVisitor.Replace(lambda.Body, lambda.Parameters[0], param));
}
else
{
return(lambda.Body);
}
}
internal static bool ResolvePropertyExpressionOrCriteria(object value, ModelPropertyInfo argumentProperty, WhereBuilderContext context)
{
var method = context.Arguments.GetType().GetMethod("Resolve" + argumentProperty.Name,
BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { argumentProperty.Type }, null);
if (method != null)
{
Type retType = typeof(Expression <>).MakeGenericType(typeof(Func <,>).MakeGenericType(context.ElementType, typeof(bool)));
if (method.ReturnType == retType)
{
LambdaExpression lambda = (LambdaExpression)method.Invoke(context.Arguments, new object[] { value });
if (lambda != null)
{
//ExpressionReplacementUtil util = new ExpressionReplacementUtil(lambda.Parameters[0], context.Parameter);
//context.Append(util.Visit(lambda.Body));
context.Append(ReplacementVisitor.Replace(lambda.Body, lambda.Parameters[0], context.Parameter));
}
return(true);
}
else if ((typeof(Criteria)).IsAssignableFrom(method.ReturnType))
{
Criteria criteria = (Criteria)method.Invoke(context.Arguments, new object[] { value });
if (criteria != null)
{
ResolvePropertyDefault(criteria, argumentProperty, context);
}
return(true);
}
}
return(false);
}
