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);
            }
Exemple #6
0
 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));
 }
Exemple #7
0
        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);
        }
Exemple #8
0
 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);
     }
 }
Exemple #9
0
        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;
 }
Exemple #12
0
        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;
 }
Exemple #14
0
        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&lt;JsonConverter&gt;)"/> 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());
        }
Exemple #24
0
 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);
 }
Exemple #28
0
 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;
 }
Exemple #30
0
 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();
 }
Exemple #33
0
 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);
 }