public WhereCollectionExpression(ICollectionExpression <T> source, Expression <Func <T, bool> > predicate, Func <T, bool> predicateCompiled, Action <T, bool> predicateReversed)
: base(source, predicate, predicateCompiled)
{
if (predicateCompiled == null)
{
var predicateReverseExpression = SetExpressionRewriter.CreateSetter(predicate);
if (predicateReverseExpression != null)
{
predicateReversed = predicateReverseExpression.Compile();
}
}
PredicateSetter = predicateReversed;
}
public override INotifyExpression <T> ApplyParameters(IDictionary <string, object> parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var applyParameters = new RepositoryChangeApplyParametersVisitor(parameters);
var newBody = applyParameters.Visit(Body);
var changeInfos = ChangeInfos;
if (applyParameters.Recorders != null)
{
if (changeInfos == null)
{
changeInfos = applyParameters.Recorders;
}
else
{
changeInfos = new List <IChangeInfo>(changeInfos);
changeInfos.AddRange(applyParameters.Recorders);
}
}
if (parameters.Count == Parameters.Count)
{
var lambda = Expression.Lambda <Func <T> >(newBody);
var setter = SetExpressionRewriter.CreateSetter(lambda);
if (setter == null)
{
throw new InvalidOperationException(string.Format("The lambda expression {0} could not be reversed.", newBody));
}
if (changeInfos == null)
{
return(new RepositoryAffectedReversableNotifyValue <T>(Repository, lambda.Compile(), setter.Compile()));
}
else
{
return(new RepositoryAffectedDependentReversableNotofyValue <T>(Repository, lambda.Compile(), setter.Compile(), changeInfos));
}
}
else
{
return(new RepositoryAffectedReversableNotifyFunc <T>(Repository, newBody, Parameters.Where(p => !parameters.ContainsKey(p.Name)), changeInfos));
}
}
public INotifyReversableExpression <T> CreateReversableExpression <T>(Expression expression, IEnumerable <ParameterExpression> parameters, IDictionary <string, object> parameterMappings)
{
if (parameterMappings != null)
{
var applyParameters = new ApplyParametersVisitor(parameterMappings);
expression = applyParameters.Visit(expression);
}
if (parameters == null || (parameterMappings == null ? !parameters.Any() : parameters.Count() == parameterMappings.Count))
{
var lambda = Expression.Lambda <Func <T> >(expression);
var setter = SetExpressionRewriter.CreateSetter(lambda);
if (setter == null)
{
throw new InvalidOperationException(string.Format("The lambda expression {0} could not be reversed.", expression));
}
return(new RepositoryAffectedReversableNotifyValue <T>(Repository, lambda.Compile(), setter.Compile()));
}
else
{
return(new RepositoryAffectedReversableNotifyFunc <T>(Repository, expression, parameters));
}
}
public static Binding <T, TMember> Create <TMember>(Expression <Func <T, TMember> > func, Expression <Func <T, TMember> > member)
{
var setter = SetExpressionRewriter.CreateSetter(member) ?? throw new InvalidOperationException($"The expression {member.ToString()} could not be inverted.");
return(Create(func, setter.Compile()));
}
