public static void UpdateDifferentBindingsReturnsDifferent()
{
MemberAssignment bind0 = Expression.Bind(typeof(Y).GetProperty(nameof(Y.Z)), Expression.Parameter(typeof(int), "z"));
MemberAssignment bind1 = Expression.Bind(typeof(Y).GetProperty(nameof(Y.A)), Expression.Parameter(typeof(int), "a"));
NewExpression newExp = Expression.New(typeof(Y));
MemberInitExpression init = Expression.MemberInit(newExp, bind0, bind1);
Assert.NotSame(init, init.Update(newExp, new[] { bind0, bind1, bind0 }));
Assert.NotSame(init, init.Update(newExp, new[] { bind1, bind0 }));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var newExpression = this.VisitAndConvert <NewExpression>(node.NewExpression, "VisitMemberInit"); var memberExpression = Visit <MemberBinding>(node.Bindings, new Func <MemberBinding, MemberBinding>(this.VisitMemberBinding));
sb.Remove(sb.Length - 1, 1);
return(node.Update(newExpression, memberExpression));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
return(node.Update(
VisitAndConvert(node.NewExpression, nameof(VisitMemberInit)),
Visit(new ReadOnlyCollection <MemberBinding>(node.Bindings.OrderBy(b => b.Member.Name).ToList()), VisitMemberBinding)
));
}
/// <summary>
/// Visits the children of the <see cref="MemberInitExpression"/>.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.</returns>
protected override Expression VisitMemberInit(MemberInitExpression node)
{
return(node.Update(
VisitAndConvert(node.NewExpression, nameof(VisitMemberInit)),
Visit(node.Bindings, VisitMemberBinding)
));
}
/// <summary>
/// 访问 <see cref="MemberInitExpression"/>。
/// </summary>
/// <param name="memberInitExp">要访问的表达式。</param>
/// <returns></returns>
protected virtual Expression VisitMemberInit(MemberInitExpression memberInitExp)
{
var n = (NewExpression)VisitNew(memberInitExp.NewExpression);
var bindings = VisitBindingList(memberInitExp.Bindings);
return(memberInitExp.Update(n, bindings));
}
protected override Expression VisitMemberInit(MemberInitExpression memberInitExpression)
{
var newExpression = VisitAndConvert(memberInitExpression.NewExpression, nameof(VisitMemberInit));
if (newExpression == null)
{
return(null);
}
var newBindings = new MemberBinding[memberInitExpression.Bindings.Count];
for (var i = 0; i < newBindings.Length; i++)
{
if (memberInitExpression.Bindings[i].BindingType != MemberBindingType.Assignment)
{
return(null);
}
newBindings[i] = VisitMemberBinding(memberInitExpression.Bindings[i]);
if (newBindings[i] == null)
{
return(null);
}
}
return(memberInitExpression.Update(newExpression, newBindings));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
List <MemberBinding> newbinding = new List <MemberBinding>();
for (int i = 0; i < node.Bindings.Count; i++)
{
bool islist = false;
var ma = node.Bindings[i] as MemberAssignment;
if (ma != null && ma.Expression.Type.GetTypeInfo().IsGenericType == true)
{
if (ma.Expression.Type.GetGenericTypeDefinition() != typeof(Nullable <>))
{
islist = true;
}
}
if (islist == false)
{
newbinding.Add(node.Bindings[i]);
}
}
if (newbinding.Count < node.Bindings.Count)
{
return(node.Update(node.NewExpression, newbinding));
}
else
{
return(base.VisitMemberInit(node));
}
}
/// <summary>
/// Visits the children of the <see cref="MemberInitExpression" />.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.</returns>
protected internal virtual Expression VisitMemberInit(MemberInitExpression node)
{
return(node.Update(
VisitAndConvert(node.NewExpression, "VisitMemberInit"),
Visit(node.Bindings, VisitMemberBinding)
));
}
/// <summary>
/// Visits the children of the <see cref="T:System.Linq.Expressions.MemberInitExpression" />.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>
/// The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.
/// </returns>
protected override Expression VisitMemberInit(MemberInitExpression node)
{
if (typeof(Rock.Data.IModel).IsAssignableFrom(node.Type))
{
var currentBindings = node.Bindings.ToList();
if (!currentBindings.Any(a => a.Member.Name == "ModifiedDateTime"))
{
MemberInfo modifiedDateTypeMemberInfo = typeof(Rock.Data.IModel).GetMember("ModifiedDateTime").FirstOrDefault();
if (modifiedDateTypeMemberInfo != null)
{
currentBindings.Add(Expression.Bind(modifiedDateTypeMemberInfo, Expression.Constant(_currentDateTime)));
}
MemberInfo modifiedByPersonAliasIdMemberInfo = typeof(Rock.Data.IModel).GetMember("ModifiedByPersonAliasId").FirstOrDefault();
if (modifiedByPersonAliasIdMemberInfo != null && _currentPersonAlias != null)
{
currentBindings.Add(Expression.Bind(modifiedByPersonAliasIdMemberInfo, Expression.Constant(_currentPersonAlias.Id)));
}
node = node.Update(node.NewExpression, currentBindings);
}
}
return(base.VisitMemberInit(node));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var c = VisitAndConvert(node.NewExpression, nameof(VisitMemberInit));
var a = Visit(node.Bindings, VisitMemberBinding);
var inits = (IList <MemberBinding>)a;
var n = node.Bindings.Count;
var all = Pop(n, out var ess);
var cs = _tilingState.Pop();
all &= cs;
if (all && _parent.CanEvaluate(node.Type))
{
_tilingState.Push(true);
}
else
{
_tilingState.Push(false);
inits = Reduce(inits, ess);
}
return(node.Update(c, inits));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var n = (NewExpression)VisitNew(node.NewExpression);
var bindings = VisitBindingList(node.Bindings);
return(node.Update(n, bindings));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var visitAndConvert = VisitAndConvert(node.NewExpression, "VisitMemberInit");
var readOnlyCollection = Visit(node.Bindings, VisitMemberBinding);
return(node.Update(visitAndConvert, readOnlyCollection));
}
/// <summary>
/// Visits a member initialization expression without any safety checks. See remarks on <see cref="VisitMemberInit"/>
/// for more information.
/// </summary>
/// <param name="node">The member initialization expression to visit.</param>
/// <returns>The result of visiting the member initialization expression.</returns>
protected virtual Expression VisitMemberInitUnsafe(MemberInitExpression node)
{
var @new = VisitMemberInitNew(node.NewExpression);
var bindings = Visit(node.Bindings, VisitMemberBinding);
return(node.Update(@new, bindings));
}
protected override Expression VisitMemberInitExpression(MemberInitExpression expression)
{
_queryBuilder.MemberInitExpression = expression;
_queryBuilder.Constructor = expression.NewExpression.Constructor;
foreach (var a in expression.NewExpression.Arguments)
{
var mappedExpression = VisitExpression(a);
if (mappedExpression is SelectVariableNameExpression)
{
_queryBuilder.ConstructorArgs.Add((mappedExpression as SelectVariableNameExpression).Name);
_queryBuilder.AddSelectVariable((mappedExpression as SelectVariableNameExpression).Name);
}
else
{
throw new NotSupportedException(
String.Format(
"Unable to map constructor expression to a SPARQL results variable. Only simple property expressions are currently supported. Invalid expression is: {0}",
a));
}
}
var updatedBindings = new List <MemberBinding>();
foreach (var b in expression.Bindings)
{
updatedBindings.Add(VisitMemberBinding(b));
}
#if WINDOWS_PHONE || PORTABLE
var updatedExpression = Expression.MemberInit(expression.NewExpression, updatedBindings);
#else
var updatedExpression = expression.Update(expression.NewExpression, updatedBindings);
#endif
_queryBuilder.MemberInitExpression = updatedExpression;
return(updatedExpression);
}
protected override Expression VisitMemberInit(MemberInitExpression memberInitExpression)
{
Check.NotNull(memberInitExpression, nameof(memberInitExpression));
var newExpression = Visit(memberInitExpression.NewExpression);
if (newExpression == QueryCompilationContext.NotTranslatedExpression)
{
return(QueryCompilationContext.NotTranslatedExpression);
}
var newBindings = new MemberBinding[memberInitExpression.Bindings.Count];
for (var i = 0; i < newBindings.Length; i++)
{
if (memberInitExpression.Bindings[i].BindingType != MemberBindingType.Assignment)
{
return(QueryCompilationContext.NotTranslatedExpression);
}
newBindings[i] = VisitMemberBinding(memberInitExpression.Bindings[i]);
if (((MemberAssignment)newBindings[i]).Expression is UnaryExpression unaryExpression &&
unaryExpression.NodeType == ExpressionType.Convert &&
unaryExpression.Operand == QueryCompilationContext.NotTranslatedExpression)
{
return(QueryCompilationContext.NotTranslatedExpression);
}
}
return(memberInitExpression.Update((NewExpression)newExpression, newBindings));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var newExpression = VisitAndConvert(node.NewExpression, nameof(VisitMemberInit));
var bindings = node.Bindings.Select(VisitMemberBinding).ToArray();
var entityType = model.FindEntityType(node.Type);
if (entityType != null)
{
var collectionMembers
= from n in entityType.GetNavigations()
where n.IsCollection()
from m in new[] { n.GetReadableMemberInfo(), n.GetWritableMemberInfo() }
select m;
for (var i = 0; i < bindings.Length; i++)
{
if (collectionMembers.Contains(bindings[i].Member))
{
var sequenceType = bindings[i].Member.GetMemberType().GetSequenceType();
bindings[i]
= Expression.Bind(
bindings[i].Member,
Expression.Coalesce(
((MemberAssignment)bindings[i]).Expression.AsCollectionType(),
Expression.New(typeof(List <>).MakeGenericType(sequenceType))));
}
}
}
return(node.Update(newExpression, bindings));
}
private Expression ConvertEntityExpression(MemberInitExpression mbmInitExp)
{
if (_isNoTracking == true)
{
return(mbmInitExp.Update(mbmInitExp.NewExpression, mbmInitExp.Bindings.Select(s => VisitBinding(s))));
}
var properties = new List <Expression>();
var values = new List <Expression>();
var bindings = new List <MemberBinding>();
mbmInitExp.Bindings.ForEach(s =>
{
if (s is MemberAssignment assign)
{
var expression = Visit(assign.Expression);
var proprety = PropertyUnity.GetProperty(mbmInitExp.Type, assign.Member.Name);
if (proprety == null)
{
bindings.Add(Expression.Bind(assign.Member, expression));
}
else
{
properties.Add(Expression.Constant(proprety));
if (PropertyValue.IsSupportedType(proprety.Type))
{
if (expression.Type.GetNonNullableType().IsEnum)
{
expression = Expression.Convert(expression, typeof(Enum));
}
var pValue = Expression.Convert(expression, typeof(PropertyValue));
values.Add(pValue);
}
else
{
var pValue = Expression.Call(null, MethodCache.NewPropertyValue, expression, Expression.Constant(null, typeof(Type)));
values.Add(pValue);
}
}
}
});
var newExp = Visit(mbmInitExp.NewExpression);
if (bindings.Count > 0)
{
newExp = Expression.MemberInit((NewExpression)newExp, bindings.ToArray());
}
var constCall = Expression.Call(null, MethodCache.ConstructEntity,
newExp,
Expression.NewArrayInit(typeof(IProperty), properties.ToArray()),
Expression.NewArrayInit(typeof(PropertyValue), values.ToArray()),
Expression.Constant(_transContext.InstanceName, typeof(string)),
Expression.Constant(_transContext.PersistentEnvironment, typeof(EntityPersistentEnvironment)));
return(Expression.Convert(constCall, mbmInitExp.Type));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var newArgs = VisitNewArguments(node.NewExpression);
var bindings = Visit(node.Bindings, VisitMemberBinding);
return(node.Update(node.NewExpression.Update(newArgs), bindings));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
NewExpression newExpression = this.VisitAndConvert <NewExpression>(node.NewExpression, "VisitMemberInit");
ReadOnlyCollection <MemberBinding> readOnlyCollection = ExpressionVisitor.Visit <MemberBinding>(node.Bindings, new Func <MemberBinding, MemberBinding>(
binding => ((SubtreeEvaluator)this).VisitMemberBinding(binding)));
return((Expression)node.Update(newExpression, (IEnumerable <MemberBinding>)readOnlyCollection));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var newExpression = VisitAndConvert(node.NewExpression, nameof(VisitMemberInit));
if (Finished)
{
return(node.Update(newExpression, node.Bindings));
}
var bindings = node.Bindings.ToList();
var currentMember = path.Pop();
var currentMemberInfo = currentMember.GetReadableMemberInfo();
var foundMember = false;
for (var i = 0; i < bindings.Count; i++)
{
var binding = bindings[i];
if (binding.Member == currentMemberInfo)
{
foundMember = true;
if (path.Count == 0)
{
bindings[i] = Expression.Bind(currentMemberInfo, includedExpression);
Finished = true;
}
else
{
bindings[i] = VisitMemberBinding(binding);
}
break;
}
}
if (!foundMember && currentMemberInfo.DeclaringType.IsAssignableFrom(node.Type))
{
bindings.Add(Expression.Bind(currentMember.GetWritableMemberInfo(), includedExpression));
Finished = true;
}
path.Push(currentMember);
return(node.Update(newExpression, bindings));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
// This override ensures that materializers with parameterless constructors
// are not botched by partial evaluation.
var newExpression = node.NewExpression.Update(Visit(node.NewExpression.Arguments));
var bindings = node.Bindings.Select(VisitMemberBinding);
return(node.Update(newExpression, bindings));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
// If we here, than eval the whole block failed, don't touch constructor!
_allowEval = false;
var newExpr = VisitAndConvert(node.NewExpression, "VisitMemberInit");
_allowEval = true;
// ReSharper disable once AssignNullToNotNullAttribute
return(node.Update(newExpr, Visit(node.Bindings, VisitMemberBinding)));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var member = typeof(User).GetProperty("DOB");
var newBindings = new[]
{
Expression.Bind(member, Expression.Property(parameter, "DOB")),
};
var updatedNode = node.Update(
node.NewExpression,
node.Bindings.Concat(newBindings));
return(base.VisitMemberInit(updatedNode));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var member = typeof(TMap).GetProperty(_propNamr);
var newBindings = new[]
{
Expression.Bind(member, Expression.Property(_existingParam, _propNamr)),
};
var updatedNode = node.Update(
node.NewExpression,
node.Bindings.Concat(newBindings));
return(base.VisitMemberInit(updatedNode));
}
static MemberInitExpression MutateMemberInit(MemberInitExpression node, IList <Expression> operands)
{
var newNewExpression = operands[0] as NewExpression;
var bindingOperands = operands.Skip(1).ToList();
var newBindings = new List <MemberBinding>();
foreach (var binding in node.Bindings)
{
var newBinding = MutateBinding(binding, bindingOperands);
newBindings.Add(newBinding);
}
return(node.Update(newNewExpression, newBindings));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var visitedNewExpression = VisitNew(node.NewExpression);
var visitedBindings = node.Bindings.Select(VisitMemberBinding).ToArray();
if (visitedNewExpression is ConstantExpression constantNewExpression &&
ValidateBindings(visitedBindings))
{
ApplyBindings(constantNewExpression.Value, visitedBindings);
return(constantNewExpression);
}
return(node.Update((NewExpression)visitedNewExpression, visitedBindings));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
if (node.Type.IsSubclassOf(typeof(EntryObjects.EntryObject)))
{
var newBindings = new List <MemberBinding>();
// Now need to go through and replace any instances of IEnumerable<EntryObject> with something else.
foreach (var binding in node.Bindings)
{
if (IsEnumerableOfEntryObjects(binding))
{
Type type = GetEnumerableType(binding);
var newBinding = Expression.Bind(
binding.Member,
Expression.New(
typeof(EntryObjects.EntryCollection2 <>).MakeGenericType(type).GetConstructor(new Type[] { typeof(IQueryProvider) }),
Expression.Constant(_context.QueryProvider)
)
);
newBindings.Add(newBinding);
}
else
{
newBindings.Add(binding);
}
}
//entryObject.Context = Context;
newBindings.Add(BindExpression("Context", Expression.Constant(this._context)));
//entryObject.ChangeState = ChangeState.None;
// -- strictly speaking, no need for this, since it will default to None anyway.
newBindings.Add(BindExpression("ChangeState", Expression.Constant(EntryObjects.ChangeState.None)));
//entryObject.ADPath = result.Path;
PropertyInfo pathProperty = typeof(System.DirectoryServices.SearchResult).GetProperty("Path");
newBindings.Add(BindExpression("ADPath", Expression.MakeMemberAccess(_parameterExpression, pathProperty)));
//entryObject.Entry = result.GetDirectoryEntry();
MethodInfo getDirectoryEntryMethod = typeof(System.DirectoryServices.SearchResult).GetMethod("GetDirectoryEntry");
newBindings.Add(BindExpression("Entry", Expression.Call(_parameterExpression, getDirectoryEntryMethod)));
//entryObject.SetParent( entryObject.Entry.Parent ); // -- no need for this any more
//Context.ChangeTracker.TrackChanges( entryObject ); // -- no need for this any more
node = node.Update(node.NewExpression, newBindings);
}
return(base.VisitMemberInit(node));
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
var newExpression = Visit(node.NewExpression) as NewExpression;
var changed = newExpression != node.NewExpression;
var bindings = new MemberBinding[node.Bindings.Count];
for (int i = 0; i < node.Bindings.Count; i++)
{
bindings[i] = VisitMemberBinding(node.Bindings[i]);
changed |= bindings[i] != node.Bindings[i];
}
if (changed)
{
return(node.Update(newExpression, bindings));
}
return(node);
}
protected override Expression VisitMemberInit(MemberInitExpression memberInitExpression)
{
var newExpression = (NewExpression)Visit(memberInitExpression.NewExpression);
var newBindings = new MemberAssignment[memberInitExpression.Bindings.Count];
for (var i = 0; i < newBindings.Length; i++)
{
// TODO: Members can be null????
var memberAssignment = (MemberAssignment)memberInitExpression.Bindings[i];
var projectionMember = _projectionMembers.Peek().AddMember(memberAssignment.Member);
_projectionMembers.Push(projectionMember);
newBindings[i] = memberAssignment.Update(Visit(memberAssignment.Expression));
_projectionMembers.Pop();
}
return(memberInitExpression.Update(newExpression, newBindings));
}
protected override Expression VisitMemberInit(MemberInitExpression memberInitExpression)
{
var visitedNew = Visit(memberInitExpression.NewExpression);
var(visitedBindings, entityReferenceInfo) = VisitMemberBindings(memberInitExpression.Bindings);
var visitedMemberInit = memberInitExpression.Update((NewExpression)Unwrap(visitedNew), visitedBindings);
return(entityReferenceInfo == null
? (Expression)visitedMemberInit
: new EntityReferenceExpression(visitedMemberInit, entityReferenceInfo));
// Visits member bindings, unwrapping expressions and surfacing entity reference information via the dictionary
(IEnumerable <MemberBinding>, Dictionary <string, EntityOrDtoType>) VisitMemberBindings(ReadOnlyCollection <MemberBinding> bindings)
{
var newBindings = new MemberBinding[bindings.Count];
Dictionary <string, EntityOrDtoType> bindingEntityReferenceInfo = null;
for (var i = 0; i < bindings.Count; i++)
{
switch (bindings[i])
{
case MemberAssignment assignment:
var visitedAssignment = VisitMemberAssignment(assignment);
if (visitedAssignment.Expression is EntityReferenceExpression ere)
{
if (bindingEntityReferenceInfo == null)
{
bindingEntityReferenceInfo = new Dictionary <string, EntityOrDtoType>();
}
bindingEntityReferenceInfo[assignment.Member.Name] = EntityOrDtoType.FromEntityReferenceExpression(ere);
}
newBindings[i] = assignment.Update(Unwrap(visitedAssignment.Expression));
continue;
default:
newBindings[i] = VisitMemberBinding(bindings[i]);
continue;
}
}
return(newBindings, bindingEntityReferenceInfo);
}
}
