protected MemberInitExpression UpdateMemberInit(MemberInitExpression init, NewExpression nex, IEnumerable<MemberBinding> bindings) { if (nex != init.NewExpression || bindings != init.Bindings) { return Expression.MemberInit(nex, bindings); } return init; }
protected override Expression VisitMemberInit(MemberInitExpression init) { if (this.mapping.IsEntity(init.Type)) { var save = this.includeScope; this.includeScope = new ScopedDictionary<MemberInfo,bool>(this.includeScope); Dictionary<MemberInfo, MemberBinding> existing = init.Bindings.ToDictionary(b => b.Member); List<MemberBinding> newBindings = null; foreach (var mi in this.mapping.GetMappedMembers(init.Type)) { if (!existing.ContainsKey(mi) && this.mapping.IsRelationship(mi) && this.policy.IsIncluded(mi)) { if (this.includeScope.ContainsKey(mi)) { throw new NotSupportedException(string.Format("Cannot include '{0}.{1}' recursively.", mi.DeclaringType.Name, mi.Name)); } Expression me = this.mapping.GetMemberExpression(init, mi); if (newBindings == null) { newBindings = new List<MemberBinding>(init.Bindings); } newBindings.Add(Expression.Bind(mi, me)); } } if (newBindings != null) { init = Expression.MemberInit(init.NewExpression, newBindings); } this.includeScope = save; } return base.VisitMemberInit(init); }
protected override Expression VisitMemberInit(MemberInitExpression node) { var bindings = node.Bindings.ToList(); foreach (var binding in this.fromBindings) { if (bindings.All(o => o.Member.Name != binding.Member.Name) && binding.Member is PropertyInfo) { var propertyInfo = binding.Member as PropertyInfo; switch (propertyInfo.PropertyType.ToString()) { case "System.String": bindings.Add(Expression.Bind(binding.Member, Expression.Constant(""))); break; case "System.Int32": case "System.Int64": case "System.Int16": bindings.Add(Expression.Bind(binding.Member, Expression.Constant(0))); break; case "System.DateTime": bindings.Add(Expression.Bind(binding.Member, Expression.Constant(DateTime.MinValue))); break; } } } return Expression.MemberInit(node.NewExpression, bindings); }
protected override Expression VisitMemberInit(MemberInitExpression node) { _classes.Push(node.Type); Expression visitMemberInit = base.VisitMemberInit(node); _classes.Pop(); return visitMemberInit; }
protected override Expression VisitMemberInit(MemberInitExpression node) { if (node.NewExpression.NodeType == ExpressionType.New) return node; return base.VisitMemberInit(node); }
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)); }
private static MemberInitExpression CreateMemberInitExpression(ParameterExpression left, Type entityType, Type dtoType, Tuple <Type, string>[] linkEntityNames) { System.Linq.Expressions.NewExpression newAnimal = System.Linq.Expressions.Expression.New(dtoType); List <MemberBinding> bindings = new List <MemberBinding>(); var members = dtoType.GetProperties();//获取Dto的各个属性 members.ToList().ForEach(p => { try { if (linkEntityNames != null && linkEntityNames.Length > 0) { var container = linkEntityNames.ToList().FirstOrDefault(x => p.Name.Contains(x.Item2)); if (container != null) { var rightStr = p.Name.Replace(container.Item2, ""); Expression right = Expression.Property(left, entityType.GetProperty(container.Item2)); MemberExpression mem = Expression.Property(right, rightStr); //这里传的mem是 用 a.name给它赋值 System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind(p, mem); bindings.Add(speciesMemberBinding); } else { MemberExpression mem = Expression.Property(left, p.Name); //这里传的mem是 用 a.name给它赋值 System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind(p, mem); bindings.Add(speciesMemberBinding); } } else { try { MemberExpression mem = Expression.Property(left, p.Name); //这里传的mem是 用 a.name给它赋值 System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind(p, mem); bindings.Add(speciesMemberBinding); } catch (Exception ex) { } } } catch { } }); System.Linq.Expressions.MemberInitExpression memberInitExpression = System.Linq.Expressions.Expression.MemberInit(newAnimal, bindings.ToArray()); return(memberInitExpression); }
private static void Analyze(MemberInitExpression mie, PathBox pb, DataServiceContext context) { if (ClientTypeUtil.TypeOrElementTypeIsEntity(mie.Type)) { EntityProjectionAnalyzer.Analyze(mie, pb, context); } else { NonEntityProjectionAnalyzer.Analyze(mie, pb, context); } }
public static void CreateMemberInitExpression() { System.Linq.Expressions.NewExpression newAnimal = System.Linq.Expressions.Expression.New(typeof(Animal)); System.Reflection.MemberInfo speciesMember = typeof(Animal).GetMember("Species")[0]; System.Reflection.MemberInfo ageMember = typeof(Animal).GetMember("Age")[0]; // Create a MemberBinding object for each member // that you want to initialize. System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind( speciesMember, System.Linq.Expressions.Expression.Constant("horse")); System.Linq.Expressions.MemberBinding ageMemberBinding = System.Linq.Expressions.Expression.Bind( ageMember, System.Linq.Expressions.Expression.Constant(12)); // Create a MemberInitExpression that represents initializing // two members of the 'Animal' class. System.Linq.Expressions.MemberInitExpression memberInitExpression = System.Linq.Expressions.Expression.MemberInit( newAnimal, speciesMemberBinding, ageMemberBinding); //// Create a MemberInitExpression that represents initializing //// two members of the 'Animal' class. //System.Linq.Expressions.MemberInitExpression memberInitExpression = // System.Linq.Expressions.Expression.MemberInit( // newAnimal, // speciesMemberBinding); Console.WriteLine(memberInitExpression.ToString()); var expression = Expression.Lambda <Func <Dog, Animal> >(memberInitExpression); var compile = expression.Compile(); var dog = new Dog() { Species = "DOG" }; var test = compile(dog); Console.WriteLine(test.ToJson()); // This code produces the following output: // // new Animal() {Species = "horse", Age = 12} }
protected override Expression VisitMemberInit(MemberInitExpression node) { Expression newExpr = this.Visit(node.NewExpression); if (newExpr.NodeType == ExpressionType.Constant) { // We translated the NewExpression to a ConstantExpression, so by-pass // VisitMemberInit's validation and return the expression as-is. return newExpr; } return base.VisitMemberInit(node); }
protected override Expression VisitMemberInit(MemberInitExpression node) { foreach (MemberAssignment binding in node.Bindings) { var visitor = new MemberExpressionVisitor(Context); visitor.Visit(binding.Expression); visitor.SelectedColumn.Alias = binding.Member.Name; Columns.Add(visitor.SelectedColumn); Context.Columns.Add(binding.Member.Name, visitor.SelectedColumn); } return node; }
protected override Expression VisitMemberInit(System.Linq.Expressions.MemberInitExpression expression) { this.VisitNew(expression.NewExpression); foreach (var memberBinding in expression.Bindings) { Console.WriteLine("Dup"); generator.Emit(OpCodes.Dup); this.VisitBinding(memberBinding); } return(expression); }
protected override Expression VisitMemberInit(MemberInitExpression node) { var results = new Dictionary<string, object>(); foreach (MemberAssignment binding in node.Bindings) { var visitor = new MemberExpressionVisitor(Context); visitor.Visit(binding.Expression); if (visitor.Token.Type != TokenType.Object) { throw new NotSupportedException("不支持"); } results.Add(binding.Member.Name, visitor.Token.Object); } Token = Token.Create(results); return node; }
protected override Expression VisitMemberInit(MemberInitExpression expression) { var projections = new List<SqlProjectionExpression>(); foreach (var memberBinding in expression.Bindings) { var property = memberBinding as MemberAssignment; if (property == null) continue; Visit(property.Expression); projections.Add(new SqlProjectionExpression((SqlColumnExpression)ast.Pop(), property.Member.Name)); } ast.Push(new SqlSelectExpression(projections)); return expression; }
/// <remarks> /// This build method caters to object initializers, like: /// /// new MyType { Foo = "Bar", Baz = "Qak" } /// /// It does not however cater to anonymous types, as they don't compile /// down to traditional object initializers. /// /// <see cref="BuildText(NewExpression)"/> caters to anonymous types. /// </remarks> string BuildText(MemberInitExpression expression) { if (expression.NewExpression.Constructor.GetParameters().Any()) throw new ArgumentException( "The result type must be constructed using a parameterless constructor. For example: n => new MyResultType { Foo = n.Bar }", "expression"); var bindingTexts = expression.Bindings.Select(binding => { if (binding.BindingType != MemberBindingType.Assignment) throw new ArgumentException("All bindings must be assignments. For example: n => new MyResultType { Foo = n.Bar }", "expression"); var memberAssignment = (MemberAssignment)binding; return BuildStatement(memberAssignment.Expression, binding.Member); }); return string.Join(", ", bindingTexts.ToArray()); }
protected override Expression VisitMemberInit(MemberInitExpression init) { DoVisitNew(init.NewExpression); foreach (var x in init.Bindings) { var oldMembership = membershipPath; membershipPath = Expression.MakeMemberAccess(oldMembership, x.Member); this.VisitBinding(x); membershipPath = oldMembership; } assignments.Add(new AssignmentInformation() { Declaration = init, MembershipPath = membershipPath, }); return init; }
protected object Visit(MemberInitExpression expression) { var obj = this.Visit(expression.NewExpression); if (obj == InterpretFailed) { return obj; } foreach (var binding in expression.Bindings) { var value = this.Visit(obj, binding); if (value == InterpretFailed) { return value; } } return obj; }
private void VisitMemberInit(MemberInitExpression node) { foreach (var memberBinding in node.Bindings) { var memberAssignment = memberBinding as MemberAssignment; if (memberAssignment != null) { _mappings.Add(new ProjectionMemberMapping { Expression = memberAssignment.Expression, Member = memberAssignment.Member }); } else { var message = string.Format("Only member assignments are supported in a new expression in $project and $group, but found {0}.", node.ToString()); throw new NotSupportedException(message); } } VisitNew(node.NewExpression); }
protected override Expression VisitMemberInit(MemberInitExpression expression) { var newExpression = (NewExpression) Visit(expression.NewExpression); if (newExpression.Type == expression.NewExpression.Type) { return base.VisitMemberInit(expression); } var bindings = expression.Bindings.Select(b => { var memberAssignment = b as MemberAssignment; if (memberAssignment == null) { return b; } var member = newExpression.Type.GetMember(memberAssignment.Member.Name).Single(); if (member.DeclaringType == memberAssignment.Member.DeclaringType) { return b; } return (MemberBinding) Expression.Bind(member, memberAssignment.Expression); }); return Expression.MemberInit(newExpression, bindings); }
/// <summary> /// Visits a MemberInitExpression. /// </summary> /// <param name="node">The MemberInitExpression.</param> /// <returns>The MemberInitExpression.</returns> protected override Expression VisitMemberInit(MemberInitExpression node) { throw new NotImplementedException(); }
/// <summary> /// Visit a member initialization expression. /// </summary> /// <param name="memberInitExp"></param> /// <returns></returns> protected virtual Expression VisitMemberInit(MemberInitExpression memberInitExp) { NewExpression n = VisitNew(memberInitExp.NewExpression); IEnumerable<MemberBinding> bindings = VisitBindingList(memberInitExp.Bindings); return n != memberInitExp.NewExpression || bindings != memberInitExp.Bindings ? Expression.MemberInit(n, bindings) : memberInitExp; }
private static string VisitMemberInit(MemberInitExpression node) { throw new NotImplementedException(); }
/// <remarks> /// This build method caters to object initializers, like: /// /// new MyType { Foo = "Bar", Baz = "Qak" } /// /// It does not however cater to anonymous types, as they don't compile /// down to traditional object initializers. /// /// <see cref="BuildText(NewExpression, CypherCapabilities, IEnumerable<JsonConverter>)"/> caters to anonymous types. /// </remarks> static string BuildText( MemberInitExpression expression, CypherCapabilities capabilities, IEnumerable<JsonConverter> jsonConvertersThatTheDeserializerWillUse) { if (expression.NewExpression.Constructor.GetParameters().Any()) throw new ArgumentException( "The result type must be constructed using a parameterless constructor. For example: n => new MyResultType { Foo = n.Bar }", "expression"); var bindingTexts = expression.Bindings.Select(binding => { if (binding.BindingType != MemberBindingType.Assignment) throw new ArgumentException("All bindings must be assignments. For example: n => new MyResultType { Foo = n.Bar }", "expression"); var memberAssignment = (MemberAssignment)binding; return BuildStatement(memberAssignment.Expression, binding.Member, capabilities, jsonConvertersThatTheDeserializerWillUse); }); return string.Join(", ", bindingTexts.ToArray()); }
protected override Expression VisitMemberInit(MemberInitExpression init) { this.Visit(init.NewExpression); this.Write(" {"); this.WriteLine(Indentation.Inner); this.VisitBindingList(init.Bindings); this.WriteLine(Indentation.Outer); this.Write("}"); return init; }
protected virtual Expression VisitMemberInit(MemberInitExpression init) { NewExpression n = this.VisitNew(init.NewExpression); IEnumerable<MemberBinding> bindings = this.VisitBindingList(init.Bindings); return this.UpdateMemberInit(init, n, bindings); }
/// <summary> /// MemberInitExpression visit method /// </summary> /// <param name="init">The MemberInitExpression to visit</param> /// <returns>The visited MemberInitExpression</returns> internal override Expression VisitMemberInit(MemberInitExpression init) { this.cantTranslateExpression = true; return init; }
protected virtual bool CompareMemberInit(MemberInitExpression a, MemberInitExpression b) { return this.Compare(a.NewExpression, b.NewExpression) && this.CompareBindingList(a.Bindings, b.Bindings); }
private MemberInitExpression Convert(LinqExp.MemberInitExpression linqMemberInit) { return(Expression.MemberInit( Convert(linqMemberInit.NewExpression), linqMemberInit.Bindings.Project(Convert))); }
/// <summary> /// Visits a MemberInitExpression. /// </summary> /// <param name="init">The MemberInitExpression.</param> /// <returns>The MemberInitExpression (possibly modified).</returns> protected virtual Expression VisitMemberInit(MemberInitExpression init) { NewExpression n = this.VisitNew(init.NewExpression); IEnumerable<MemberBinding> bindings = this.VisitBindingList(init.Bindings); if (n != init.NewExpression || bindings != init.Bindings) { return Expression.MemberInit(n, bindings); } return init; }
private IBsonSerializer BuildMemberInit(MemberInitExpression node) { var mapping = ProjectionMapper.Map(node); return BuildProjectedSerializer(mapping); }
protected virtual System.Linq.Expressions.Expression VisitMemberInit(MemberInitExpression init) { NewExpression n = VisitNew(init.NewExpression); IEnumerable<MemberBinding> bindings = VisitBindingList(init.Bindings); // ReSharper disable once PossibleUnintendedReferenceComparison if(n != init.NewExpression || bindings != init.Bindings) { return System.Linq.Expressions.Expression.MemberInit(n, bindings); } return init; }
protected virtual object CompileMemberInit(MemberInitExpression exp) { return Expression.Lambda(exp).Compile().DynamicInvoke(); }
internal static MemberInit MemberInit(MemberInitExpression expression) { return new MemberInit() { NewExpression = New(expression.NewExpression), Bindings = expression.Bindings.Select(MemberBinding.Serialize).ToArray(), }.Apply(n => n.Type = TypeRef.Serialize(expression.Type)); }
internal void EnterMemberInit(MemberInitExpression init) { bool isEntityType = ClientType.CheckElementTypeIsEntity(init.Type); this.entityInScope.Push(isEntityType); }