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); } }