Update() публичный Метод

Creates a new expression that is like this one, but using the supplied children. If all of the children are the same, it will return this expression.
public Update ( IEnumerable arguments ) : NewExpression
arguments IEnumerable The property of the result.
Результат NewExpression
Документация по классу NewExpression
Пример #1
0
        //make projections of enums work
        protected override Expression VisitNew(NewExpression node)
        {
            IEnumerable<Expression> arguments = node.Arguments
                .Select((arg, i) =>
                            {
                                Expression newarg = Visit(arg);
                                if (arg.Type.IsEnum && newarg.Type == typeof (Int32))
                                    return Expression.Convert(newarg, arg.Type);
                                    //force an in mem convert from int to enum
                                else
                                    return newarg;
                            });

            return node.Update(arguments);
        }
Пример #2
0
        protected override Expression VisitNew(NewExpression expression)
        {
            if (expression.Type.IsDataAccessObjectType())
            {
                // Replace all new DataAccessObject() calls with new ConcreteDataAccessObject(DataAccessModel)

                return Expression.New
                (
                    this.dataAccessModel.GetConcreteTypeFromDefinitionType(expression.Type).GetConstructor(new [] { typeof(DataAccessModel), typeof(bool) }),
                    new Expression[] { Expression.Property(this.objectProjector, "DataAccessModel"), Expression.Constant(false) }
                );
            }

            var visitedArgs = this.VisitExpressionList(expression.Arguments);

            if (visitedArgs != expression.Arguments)
            {
                var i = 0;
                Expression[] newArgs = null;

                foreach (var newArg in visitedArgs)
                {
                    if (newArg.Type != expression.Arguments[i].Type)
                    {
                        if (newArgs == null)
                        {
                            newArgs = new Expression[visitedArgs.Count];

                            for (var j = 0; j < i; j++)
                            {
                                newArgs[j] = visitedArgs[j];
                            }
                        }

                        newArgs[i] = Expression.Convert(visitedArgs[i], expression.Arguments[i].Type);
                    }
                    else
                    {
                        if (newArgs != null)
                        {
                            newArgs[i] = visitedArgs[i];
                        }
                    }

                    i++;
                }

                return expression.Update(newArgs ?? (IEnumerable<Expression>)visitedArgs);
            }

            return expression;
        }
Пример #3
0
 protected internal virtual Expression VisitNew(NewExpression node)
 {
     return(node.Update(Visit(node.Arguments)));
 }