public ExpressionConverter()
{
_entityProperties = MappedEntity <TModel, TEntity> .EntityProperties;
_propertyMap = new PropertyConverterMap(MappedEntity <TModel, TEntity> .PropertyMap.Cast <PropertyConverter>());
_defaultVisitor = new DefaultExpressionVisitor();
_parameterVisitor = new ParameterExpressionVisitor(_propertyMap);
}
public static Expression Extract <T>(IQueryable qry, ParameterExpression parameterExpression, string parameterName)
{
MethodCallExpression methodCallExpression = qry.Expression as MethodCallExpression;
Expression <Func <LambdaExpression> > executionLambda = Expression.Lambda <Func <LambdaExpression> >(methodCallExpression.Arguments[1]);
Expression extractedExpression = (executionLambda.Compile().Invoke() as Expression <Func <T, bool> >).Body;
var filterExpressionVisitor = new ParameterExpressionVisitor(parameterExpression, parameterName);
return(filterExpressionVisitor.Visit(extractedExpression));
}
/// <summary>
/// 合并操作
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sourceExpression">原表达式</param>
/// <param name="pendingExpression">待合并的表达式</param>
/// <param name="mergeFunc">合并后的表达式</param>
/// <returns></returns>
private static Expression <T> Merge <T>(this Expression <T> sourceExpression, Expression <T> pendingExpression, Func <Expression, Expression, Expression> mergeFunc)
{
Dictionary <ParameterExpression, ParameterExpression> dictionary = sourceExpression.Parameters.Select((ParameterExpression left, int i) => new
{
left,
right = pendingExpression.Parameters[i]
}).ToDictionary(p => p.right, p => p.left);
Expression arg = ParameterExpressionVisitor.VisitParameters(dictionary, pendingExpression.Body);
return(Expression.Lambda <T>(mergeFunc(sourceExpression.Body, arg), sourceExpression.Parameters));
}
/// <summary>
/// Extracts the "Where" clause Expression from an IQueryable
/// </summary>
/// <param name="qry">The qry.</param>
/// <param name="parameterExpression">The original parameter expression.</param>
/// <param name="parameterName">Name of the parameter (forexample: 'p') from the qry to replace with the parameterExpression.</param>
/// <returns></returns>
public static Expression Extract(IQueryable qry, ParameterExpression parameterExpression, string parameterName)
{
var methodCallExpression = qry.Expression as MethodCallExpression;
if (methodCallExpression == null)
{
return(null);
}
var executionLambda = Expression.Lambda <Func <LambdaExpression> >(methodCallExpression.Arguments[1]);
var extractedExpression = (executionLambda.Compile().Invoke()).Body;
var filterExpressionVisitor = new ParameterExpressionVisitor(parameterExpression, parameterName);
return(filterExpressionVisitor.Visit(extractedExpression));
}
public LambdaExpression[] GetMapExpression(Type sourceType, Type destinationType, object parameters, MemberInfo[] membersToExpand)
{
var expressionRequest = new ExpressionRequest(
sourceType ?? throw new ArgumentNullException(nameof(sourceType)),
destinationType ?? throw new ArgumentNullException(nameof(destinationType)),
membersToExpand ?? throw new ArgumentNullException(nameof(membersToExpand)),
null);
var cachedExpressions = _expressionCache.GetOrAdd(expressionRequest);
return(Array.ConvertAll(cachedExpressions, Prepare));
LambdaExpression Prepare(Expression cachedExpression)
{
var result = parameters == null ? cachedExpression : ParameterExpressionVisitor.SetParameters(parameters, cachedExpression);
return((LambdaExpression)(_configurationProvider.EnableNullPropagationForQueryMapping ? NullsafeQueryRewriter.NullCheck(result) : result));
}
}
private Expression Prepare(Expression cachedExpression, object parameters)
{
Expression result;
if (parameters != null)
{
var visitor = ParameterExpressionVisitor.Create(parameters);
result = visitor.Visit(cachedExpression);
}
else
{
result = cachedExpression;
}
// perform null-propagation if this feature is enabled.
if (_configurationProvider.EnableNullPropagationForQueryMapping)
{
var nullVisitor = new NullsafeQueryRewriter();
return(nullVisitor.Visit(result));
}
return(result);
}
public void Or(Expression <Func <TModel, bool> > predicate)
{
if (predicate == null)
{
return;
}
var exp = new ParameterExpressionVisitor(predicate.Parameters[0], _parameter).Visit(predicate.Body);
if (_expression == null)
{
_expression = exp;
}
else
{
_expression = Expression.Or(
_expression,
exp
);
}
}
/// <summary>
/// Replaces a parameter in the expression.
/// </summary>
/// <param name="expression">The expression.</param>
/// <param name="parameterName">Name of the parameter to be replaced.</param>
/// <param name="parameterExpression">The parameter expression to use in the replacement.</param>
/// <returns>A new Expression if the original expression was modified; otherwise the original expression.</returns>
public static Expression ReplaceParameter(this Expression expression, string parameterName, ParameterExpression parameterExpression)
{
var filterExpressionVisitor = new ParameterExpressionVisitor(parameterExpression, parameterName);
return(filterExpressionVisitor.Visit(expression));
}
