C# Expressions.LambdaExpression类代码示例

 protected LambdaExpression UpdateLambda(LambdaExpression lambda, Type delegateType, Expression body, IEnumerable<ParameterExpression> parameters)
 {
     if (body != lambda.Body || parameters != lambda.Parameters || delegateType != lambda.Type) {
         return Expression.Lambda(delegateType, body, parameters);
     }
     return lambda;
 }

        /// <summary>
        /// Gets the name of the member used in the <paramref name="expression"/>.
        /// </summary>
        /// <param name="expression">
        /// The <see cref="T:LambdaExpression"/> that calls the class member
        /// whose name should be returned.
        /// </param>
        /// <returns>
        /// The name of the member used in the <paramref name="expression"/>.
        /// </returns>   
        public virtual string GetMemberName(LambdaExpression expression) {
            if (null == expression) throw new ArgumentNullException("expression");

            var body = expression.Body;
            if (body != null) {

                var try1 = body as UnaryExpression;
                if (try1 != null) {

                    var try11 = try1.Operand as MemberExpression;
                    if (try11 != null) {
                        return GetMemberName(try11);
                    }

                    var try12 = try1.Operand as MethodCallExpression;
                    if (try12 != null) {
                        return GetMemberName(try12);
                    }
                }

                var try2 = body as MemberExpression;
                if (try2 != null) {
                    return GetMemberName(try2);
                }

                var try3 = body as MethodCallExpression;
                if (try3 != null) {
                    return GetMemberName(try3);
                }
            }

            throw new InvalidTargetMemberException(expression);
        }

        // Terminology used in this file:
        //
        // - a "statement" is something like "x.Foo? AS Bar"
        // - "text" is a collection of statements, like "x.Foo? AS Bar, y.Baz as Qak"
        public static ReturnExpression BuildText(LambdaExpression expression, bool camelCaseProperties)
        {
            var body = expression.Body;

            if (body.NodeType == ExpressionType.Convert &&
                body is UnaryExpression)
            {
                body = ((UnaryExpression)expression.Body).Operand;
            }

            string text;
            switch (body.NodeType)
            {
                case ExpressionType.MemberInit:
                    var memberInitExpression = (MemberInitExpression) body;
                    text = BuildText(memberInitExpression, camelCaseProperties);
                    return new ReturnExpression {Text = text, ResultMode = CypherResultMode.Projection};
                case ExpressionType.New:
                    var newExpression = (NewExpression) body;
                    text = BuildText(newExpression,camelCaseProperties);
                    return new ReturnExpression {Text = text, ResultMode = CypherResultMode.Projection};
                case ExpressionType.Call:
                    var methodCallExpression = (MethodCallExpression) body;
                    text = BuildText(methodCallExpression);
                    return new ReturnExpression {Text = text, ResultMode = CypherResultMode.Set};
                case ExpressionType.MemberAccess:
                    var memberExpression = (MemberExpression) body;
                    text = BuildText(memberExpression, camelCaseProperties);
                    return new ReturnExpression { Text = text, ResultMode = CypherResultMode.Set };
                default:
                    throw new ArgumentException(WithExpressionShouldBeOneOfExceptionMessage, "expression");
            }
        }

        public override Expression GetDeleteExpression(MappingEntity entity, Expression instance, LambdaExpression deleteCheck)
        {
            var tables = this.mapping.GetTables(entity);
            if (tables.Count < 2)
            {
                return base.GetDeleteExpression(entity, instance, deleteCheck);
            }

            var commands = new List<Expression>();
            foreach (var table in this.GetDependencyOrderedTables(entity).Reverse())
            {
                TableExpression tex = new TableExpression(new TableAlias(), entity, this.mapping.GetTableName(table));
                var where = this.GetIdentityCheck(tex, entity, instance);
                commands.Add(new DeleteCommand(tex, where));
            }

            Expression block = new BlockCommand(commands);

            if (deleteCheck != null)
            {
                var test = this.GetEntityStateTest(entity, instance, deleteCheck);
                return new IFCommand(test, block, null);
            }

            return block;
        }

        public override bool IsValid(LambdaExpression expr)
        {
            // expression should be binary expresion
            if (!(expr.Body is BinaryExpression))
            {
                return false;
            }
            var body = expr.Body as BinaryExpression;

            //            // left operand should be binary expression
            //            if (!(body.Left is BinaryExpression))
            //            {
            //                return false;
            //            }
            //
            //            // right operand should be binary expression
            //            if (!(body.Right is BinaryExpression))
            //            {
            //                return false;
            //            }

            var lambdaParam = expr.Parameters[0];
            // check left operand
            if (!this.isExpressionValid(body.Left, lambdaParam))
            {
                return false;
            }

            // check right operand
            if (!this.isExpressionValid(body.Right, lambdaParam))
            {
                return false;
            }
            return true;
        }

        public override Expression GetUpdateExpression(IMappedEntity entity, Expression instance, LambdaExpression updateCheck, LambdaExpression selector)
        {
            var IdentifiableAlias = new IdentifiableAlias();
            var table = new IdentifiableExpression(IdentifiableAlias, entity, ((OTypeMapping)this.Mapping).GetTableName(entity));

            var where = this.GetIdentityCheck(table, entity, instance);
            if (updateCheck != null)
            {
                Expression typeProjector = this.GetEntityExpression(table, entity);
                Expression pred = DbExpressionReplacer.Replace(updateCheck.Body, updateCheck.Parameters[0], typeProjector);
                where = where.And(pred);
            }

            var assignments = this.GetFieldAssignments(table, instance, entity, (e, m) => ((OTypeMapping)this.Mapping).IsUpdatable(e, m));

            Expression update = new UpdateCommandExpression(table, where, assignments);

            if (selector != null)
            {
                return CreateUpdateCommand(entity, instance, selector, where, assignments);
            }
            else
            {
                return update;
            }
        }

        public static PropertyInfo FindProperty(LambdaExpression lambdaExpression)
        {
            Expression expressionToCheck = lambdaExpression;

            bool done = false;

            while (!done)
            {
                switch (expressionToCheck.NodeType)
                {
                    case ExpressionType.Convert:
                        expressionToCheck = ((UnaryExpression) expressionToCheck).Operand;
                        break;
                    case ExpressionType.Lambda:
                        expressionToCheck = lambdaExpression.Body;
                        break;
                    case ExpressionType.MemberAccess:
                        var propertyInfo = ((MemberExpression) expressionToCheck).Member as PropertyInfo;
                        return propertyInfo;
                    default:
                        done = true;
                        break;
                }
            }

            return null;
        }

		public static Expression ReplaceParameters(LambdaExpression @in, IEnumerable<Expression> with)
		{
			Expression e = @in.Body;

			var withList = with.ToList();

			if (withList.Count() == @in.Parameters.Count)
			{
				e = @in.Parameters.Zip(withList, (parameter, replace) => new {parameter, replace})
					.Aggregate(e, (current, expression) => Rewrite(current, expression.parameter, expression.replace));
			}
			else
			{
				foreach (var parameter in @in.Parameters)
				{
					ParameterExpression parameter1 = parameter;
					foreach (var withParameter in withList.Where(withParameter => parameter1.Type == withParameter.Type))
					{
						e = Rewrite(e, parameter, withParameter);
						break;
					}
				}
			}

			return e;
		}

 private static string OutputFunctionBody(LambdaExpression function)
 {
     string body = function.Body.ToString();
     body = MemberPattern.Replace(body, string.Empty);
     body = BoxingPattern.Replace(body, "$1");
     return EscapeForTemplate(body);
 }

        private static Func<ExpressionIterationNode, bool> ParsePattern(LambdaExpression pattern)
        {
            //foreach (var node in pattern.Iterate())
            //{

            //}
        }

 private static string ExtractMemberName(LambdaExpression expr)
 {
     var body = expr.Body;
     var parts = new List<string>();
     for(;;)
     {
         switch(body.NodeType)
         {
             case ExpressionType.Convert:
             case ExpressionType.ConvertChecked:
                 body = ((UnaryExpression)body).Operand;
                 break;
             case ExpressionType.MemberAccess:
                 var member = ((MemberExpression)body).Member;
                 if(!member.DeclaringType.IsDefined(typeof(CompilerGeneratedAttribute), true))
                     // Don't add access to compiler-generated classes to our path because an expression such as () => command.Member.SubMember will contain an access to the "command" member of an anonymous type.
                 {
                     parts.Add(member.Name);
                 }
                 body = ((MemberExpression)body).Expression;
                 break;
             case ExpressionType.Constant:
             case ExpressionType.Parameter:
                 goto breakOuter;
             default:
                 throw new ArgumentException("Expression must be a member expression, eg () => command.InvalidMember", "expr");
         }
     }
     breakOuter:
     return ((IEnumerable<string>)parts).Reverse().Join(".");
 }

        public static IEnumerable<Expression> Match(this LambdaExpression expression, LambdaExpression pattern)
        {
            //var patternSequence = pattern.Body.Iterate().ToList();
            //if (patternSequence.Count == 0)
            //{
            //    throw new ArgumentException("Invalid pattern", "pattern");
            //}

            //var rootNode = patternSequence[0];

            //var partialMatches = new List<PartialMatch>();

            //foreach (var node in expression.Iterate())
            //{
            //    partialMatches.Add(new PartialMatch { Root = node });

            //    for (var i = partialMatches.Count - 1; i >= 0; --i)
            //    {
            //        var partialMatch = partialMatches[i];
            //        if (Matches(node, patternSequence[partialMatch.Position]))
            //        {
            //            partialMatch.Position++;
            //            if (partialMatch.Position < patternSequence.Count)
            //            {
            //                continue;
            //            }
            //            yield return (Expression)partialMatch.Root.Element;
            //        }
            //        partialMatches.RemoveAt(i);
            //    }
            //}
        }

 public void Inspect(LambdaExpression keysExpression, bool direction)
 {
     foreach (var columnMap in MapTransformer.Transform(keysExpression, queryBlock.QueryMap))
     {
         keyMap.Add(new ColumnMapAndDesc(columnMap, direction));
     }
 }

        internal static void Analyze(LambdaExpression e, PathBox pb)
        {
            bool knownEntityType = CommonUtil.IsClientType(e.Body.Type);
            pb.PushParamExpression(e.Parameters.Last());

            if (!knownEntityType)
            {
                NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
            }
            else
            {
                switch (e.Body.NodeType)
                {
                    case ExpressionType.MemberInit:
                        EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb);
                        break;
                    case ExpressionType.New:
                        throw new NotSupportedException(SR.ALinqCannotConstructKnownEntityTypes);
                    case ExpressionType.Constant:
                        throw new NotSupportedException(SR.ALinqCannotCreateConstantEntity);
                    default:
                        NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
                        break;
                }
            }

            pb.PopParamExpression();
        }

		public static LambdaExpression Combine(this LambdaExpression outer, LambdaExpression inner)
		{
			var invoke = Expression.Invoke(inner, outer.Body);
			var body = new ExpressionRewriter().AutoInline(invoke);

			return Expression.Lambda(body, outer.Parameters.ToArray());
		}