private static Expression <T> Compose <T>(
this Expression <T> first,
Expression <T> second,
Func <Expression, Expression, Expression> merge)
{
var visitor = new ParameterVisitor(first.Parameters);
var expression = merge(visitor.Visit(first.Body) !, visitor.Visit(second.Body) !);
return(Expression.Lambda <T>(expression, first.Parameters));
}
protected override System.Linq.Expressions.Expression <System.Func <TEntity, bool> > CreateExpression()
{
var parameter = Expression_.Parameter(typeof(TEntity), "entity");
var replacer = new ParameterVisitor(node => parameter);
var leftBody = replacer.Visit(LeftSideSpecification.Expression.Body);
var rightBody = replacer.Visit(RightSideSpecification.Expression.Body);
var newBody = CreateBody(leftBody, rightBody);
return(Expression_.Lambda <Func <TEntity, bool> >(newBody, parameter));
}
private static Expression MakeLambda(Expression parameter, Expression predicate)
{
var resultParameterVisitor = new ParameterVisitor();
resultParameterVisitor.Visit(parameter);
var resultParameter = resultParameterVisitor.Parameter;
return Expression.Lambda(predicate, (ParameterExpression)resultParameter);
}
public void CombineWithOtherCustomMappings(CustomMapping root, IEnumerable <CustomMapping> mappings)
{
lock (root)
{
foreach (var otherMapping in mappings)
{
foreach (var m in otherMapping.Members)
{
if (!root.Members.Contains(m))
{
var oldParams = otherMapping.ArgumentParameters.Select(p => p.Parameter).ToList();
var newParams = root.ArgumentParameters.Select(p => p.Parameter).ToList();
oldParams.Add(otherMapping.SourceParameter);
newParams.Add(root.SourceParameter);
var visitor = new ParameterVisitor(oldParams, newParams);
var member = new MemberExpressionTuple
{
Expression = visitor.Visit(m.Expression),
Member = m.Member
};
root.Members.Add(member);
}
}
}
}
}
/// <summary>
/// 编织扩展
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
internal Expression <Func <TEntity, T> > Expand <T>(Expression <Func <TEntity, T> > source)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
var adjuster = new ParameterVisitor(node => source.Parameters.Single());
var adjustedExpandables =
from expandable in _expandables
select new
{
From = expandable.From(),
To = (adjuster.Visit(expandable.To()))
};
var propertyReplacer = new MemberVisitor(node =>
{
var query =
from expandable in adjustedExpandables
where (expandable.From == node.Member)
select expandable.To;
return(query.SingleOrDefault() ?? node);
});
return((Expression <Func <TEntity, T> >)propertyReplacer.Visit(source));
}
public Expression Process(Expression expression)
{
var paramVisitor = new ParameterVisitor(this.ParametersToReplace);
expression = paramVisitor.Visit(expression);
return expression;
}
public Expression Process(Expression expression)
{
var paramVisitor = new ParameterVisitor(this.ParametersToReplace);
expression = paramVisitor.Visit(expression);
return(expression);
}
public static bool HasParameterExpression(this Expression self)
{
var constantVisitor = new ParameterVisitor();
constantVisitor.Visit(self);
return(constantVisitor.HasParameterExpression);
}
public static ParameterExpression GetParamaterFromExpression(Expression parameter)
{
var resultParameterVisitor = new ParameterVisitor();
resultParameterVisitor.Visit(parameter);
var resultParameter = resultParameterVisitor.Parameter as ParameterExpression;
return(resultParameter);
}
public static Expression <Func <TResult, bool> > WithParameter <TResult, TSource>(this Expression <Func <TSource, bool> > source, Expression <Func <TResult, TSource> > selector)
{
// Replace parameter with body of selector
var replaceParameter = new ParameterVisitor(source.Parameters, selector.Body);
// This will be the new body of the expression
var newExpressionBody = replaceParameter.Visit(source.Body);
return(Expression.Lambda <Func <TResult, bool> >(newExpressionBody, selector.Parameters));
}
public override Expression Translate(ExpandedNavigationSelectItem item)
{
var segment = (NavigationPropertySegment)item.PathToNavigationProperty.LastSegment;
Expression expression = Translate(segment);
Type navigationItemType = expression.Type;
Type itemType = OeExpressionHelper.GetCollectionItemType(navigationItemType);
if (itemType != null)
{
var expressionBuilder = new OeExpressionBuilder(_model, itemType);
expression = expressionBuilder.ApplyFilter(expression, item.FilterOption);
expression = expressionBuilder.ApplyOrderBy(expression, item.OrderByOption);
var path = new ODataPath(_path.Union(item.PathToNavigationProperty));
expression = expressionBuilder.ApplySkip(expression, item.SkipOption, path);
expression = expressionBuilder.ApplyTake(expression, item.TopOption, path);
foreach (KeyValuePair <ConstantExpression, ConstantNode> constant in expressionBuilder.Constants)
{
_visitor.AddConstant(constant.Key, constant.Value);
}
}
Expression countExpression = null;
if (item.CountOption.GetValueOrDefault())
{
MethodInfo countMethodInfo = OeMethodInfoHelper.GetCountMethodInfo(itemType);
countExpression = Expression.Call(countMethodInfo, expression);
}
if (item.SelectAndExpand.SelectedItems.Any())
{
var path = new ODataPath(_path.Union(item.PathToNavigationProperty));
var selectTranslator = new OeSelectTranslator(_visitor, path);
Expression nestedExpression = selectTranslator.CreateExpression(expression, item.SelectAndExpand, OeMetadataLevel.Minimal);
Type nestedType = OeExpressionHelper.GetCollectionItemType(nestedExpression.Type);
if (nestedType == null)
{
var visitor = new ParameterVisitor(selectTranslator._parameter, expression);
nestedExpression = visitor.Visit(nestedExpression);
nestedType = nestedExpression.Type;
}
_selectItemInfo.EntryFactory = selectTranslator.CreateNestedEntryFactory(nestedType, _selectItemInfo.EntitySet, _selectItemInfo.ResourceInfo);
expression = nestedExpression;
}
if (countExpression != null)
{
return(CreateNavigationLinkInfo(navigationItemType, expression, countExpression));
}
return(expression);
}
private static Expression <Func <T, bool> > MakeLambda <T>(Expression parameter, Expression predicate)
{
var resultParameterVisitor = new ParameterVisitor();
resultParameterVisitor.Visit(parameter);
var resultParameter = resultParameterVisitor.Parameter;
return(Expression.Lambda <Func <T, bool> >(predicate, (ParameterExpression)resultParameter));
}
public static LambdaExpression BuildPredicateForSubQuery(Type parentType, Type propertyType, Expression parameter)
{
var resultParameterVisitor = new ParameterVisitor();
resultParameterVisitor.Visit(parameter);
var parentParameter = (ParameterExpression)resultParameterVisitor.Parameter;
var functionType = typeof(Func <,>).MakeGenericType(parentType, propertyType);
return(Expression.Lambda(functionType, parameter, parentParameter));
}
internal static LambdaExpression Bind(Type sourceType, PropertyOrFieldInfo member, LambdaExpression conversion, LambdaExpression customMapping = null)
{
var parameterToReplace = conversion.Parameters.Single();
var newParameter = Expression.Parameter(sourceType, "p");
var accessMember = Expression.MakeMemberAccess(newParameter, member);
var visitor = new ParameterVisitor(parameterToReplace, accessMember);
var newBody= visitor.Visit(conversion.Body);
return Expression.Lambda(newBody, newParameter);
}
internal static LambdaExpression Bind(Type sourceType, PropertyOrFieldInfo member, LambdaExpression conversion, LambdaExpression customMapping = null)
{
var parameterToReplace = conversion.Parameters.Single();
var newParameter = Expression.Parameter(sourceType, "p");
var accessMember = Expression.MakeMemberAccess(newParameter, member);
var visitor = new ParameterVisitor(parameterToReplace, accessMember);
var newBody = visitor.Visit(conversion.Body);
return(Expression.Lambda(newBody, newParameter));
}
public void ShouldReplaceParameter()
{
Expression<Func<User, bool>> expr1 = user => user.Name == "name";
Expression<Func<User, bool>> expr2 = user => user.IsMale;
var parm1 = expr1.Parameters[0];
var parm2 = expr2.Parameters[0];
var visitor = new ParameterVisitor(parm2, parm1);
var body = visitor.Visit(expr2);
var lambda = Expression.Lambda(body, parm1);
Assert.Equal(parm1, lambda.Parameters[0]);
}
public void ShouldNotReplaceIfParameterIsDifferent()
{
Expression<Func<User, bool>> expr1 = user => user.Name == "name";
Expression<Func<User, bool>> expr2 = user => user.IsMale;
Expression<Func<User, bool>> expr3 = user => user.FavoriteNumber == 3;
var parm1 = expr1.Parameters[0];
var parm2 = expr2.Parameters[0];
var parm3 = expr3.Parameters[0];
var visitor = new ParameterVisitor(parm1, parm2);
var body = visitor.Visit(expr3);
var lambda = Expression.Lambda(body, parm3);
Assert.Equal(parm3, lambda.Parameters[0]);
}
public Expression Process(Expression expression)
{
RootExpression = expression;
var memberVisitor = new MemberVisitor(MemberMapper, MemberMapper.Options.Safety.PerformNullChecksOnCustomMappings, Variables);
// Pass 1: Transform member access so they do null-checks first, if needed
expression = memberVisitor.Visit(expression);
RootExpression = expression;
var paramVisitor = new ParameterVisitor(this.ParametersToReplace);
// Pass 2: Transform parameter placeholders with their final ones
expression = paramVisitor.Visit(expression);
RootExpression = expression;
var visibilityVisitor = new VisibilityVisitor(this);
// Pass 3: Check visibility of what is accessed, to establish if we can compile to a new dynamic assembly.
visibilityVisitor.Visit(expression);
RootExpression = expression;
this.NonPublicMembersAccessed = visibilityVisitor.NonPublicMembersAccessed;
if (this.NonPublicMembersAccessed)
{
var lambdaVisitor = new LambdaVisitor(this);
expression = lambdaVisitor.Visit(expression);
RootExpression = expression;
}
return(expression);
}
/// <summary>
/// Filters IQueryable and returns all objects that matches given parameters
/// </summary>
/// <typeparam name="TSource">IQueryable type</typeparam>
/// <typeparam name="TProperty">Property type</typeparam>
/// <typeparam name="TValue">Values collection type</typeparam>
/// <param name="source">Filtered IQueryable</param>
/// <param name="propertyExpression">Property expression</param>
/// <param name="values">Collection where propertys value is</param>
/// <returns>Filtered IQueryable</returns>
public static IQueryable <TSource> WherePropertyIn <TSource, TProperty, TValue>(this IQueryable <TSource> source, Expression <Func <TSource, TProperty> > propertyExpression, ICollection <TValue> values)
{
if (values == null || !values.Any())
{
return(source);
}
var castedValues = values.Cast <TProperty>().ToList();
var parameter = Expression.Parameter(typeof(TSource));
var parameterVisitor = new ParameterVisitor(parameter);
var visitedPropertyExpression = (Expression <Func <TSource, TProperty> >)parameterVisitor.Visit(propertyExpression);
var memberExpressionWithReplacedParameter = (MemberExpression)visitedPropertyExpression.Body;
var expression = Expression.Lambda <Func <TSource, bool> >(
Expression.Call(Expression.Constant(castedValues),
typeof(ICollection <TProperty>).GetMethod("Contains"),
memberExpressionWithReplacedParameter), parameter);
return(source.Where(expression));
}
public override SelectItemInfo Translate(ExpandedNavigationSelectItem item)
{
var segment = (NavigationPropertySegment)item.PathToNavigationProperty.LastSegment;
if (_navigationNextLink && segment.NavigationProperty.Type is IEdmCollectionTypeReference)
{
return(null);
}
SelectItemInfo selectItemInfo = CreateNavigationSelectItemInfo(_model, segment, false, item.CountOption);
PropertyInfo navigationClrProperty = _parameter.Type.GetProperty(selectItemInfo.EdmProperty.Name);
Expression expression = Expression.MakeMemberAccess(_parameter, navigationClrProperty);
Type itemType = OeExpressionHelper.GetCollectionItemType(expression.Type);
if (itemType != null)
{
var expressionBuilder = new OeExpressionBuilder(_model, itemType);
expression = expressionBuilder.ApplyFilter(expression, item.FilterOption);
expression = expressionBuilder.ApplyOrderBy(expression, item.OrderByOption);
var path = new ODataPath(_path.Union(item.PathToNavigationProperty));
expression = expressionBuilder.ApplySkip(expression, item.SkipOption, path);
expression = expressionBuilder.ApplyTake(expression, item.TopOption, path);
foreach (KeyValuePair <ConstantExpression, ConstantNode> constant in expressionBuilder.Constants)
{
_visitor.AddConstant(constant.Key, constant.Value);
}
}
if (item.SelectAndExpand.SelectedItems.Any())
{
var path = new ODataPath(_path.Union(item.PathToNavigationProperty));
var selectTranslator = new OeSelectTranslator(_visitor, path);
ParameterExpression parameter = Expression.Parameter(itemType ?? expression.Type);
selectTranslator.BuildSelect(item.SelectAndExpand, expression, parameter, _metadataLevel, _navigationNextLink);
Expression nestedExpression;
Type nestedType;
if (itemType == null)
{
nestedExpression = selectTranslator.CreateTupleExpression();
var visitor = new ParameterVisitor(parameter, expression, segment.NavigationProperty.Type.IsNullable);
nestedExpression = visitor.Visit(nestedExpression);
nestedType = nestedExpression.Type;
}
else
{
nestedExpression = selectTranslator.CreateSelectExpression(expression, parameter);
nestedType = OeExpressionHelper.GetCollectionItemType(nestedExpression.Type);
}
selectItemInfo.EntryFactory = selectTranslator.CreateNestedEntryFactory(nestedType, selectItemInfo.EntitySet, selectItemInfo.Resource);
expression = nestedExpression;
}
selectItemInfo.Expression = expression;
return(selectItemInfo);
}
private void BuildSimpleTypeMappingExpressions(ParameterExpression source, ParameterExpression destination, ProposedMemberMapping member, List<Expression> expressions, List<ParameterExpression> newParams, CustomMapping customMapping = null)
{
Expression sourceExpression = Expression.PropertyOrField(source, member.SourceMember.Name);
var destMember = Expression.PropertyOrField(destination, member.DestinationMember.Name);
BinaryExpression assignSourceToDest;
Expression customExpression;
if (customMapping != null && (customExpression = customMapping.GetExpressionForMember(member.DestinationMember)) != null)
{
var visitor = new ParameterVisitor(customMapping.Parameter, source);
customExpression = visitor.Visit(customExpression);
assignSourceToDest = Expression.Assign(destMember, customExpression);
}
else
{
assignSourceToDest = Expression.Assign(destMember, sourceExpression);
}
expressions.Add(assignSourceToDest);
}
