Пример #1
0
        private static Expression CheckNullOnEnumerableParent(ExpressionParserPieceGroup group, ExpressionParserPieceGroup parent, Expression parentExpression, bool shouldSkipLast)
        {
            string path = null;

            if (shouldSkipLast)
            {
                path = string.Join(".", group.Pieces.Take(group.Pieces.Count - 1).Select(t => t.Name));
            }
            else
            {
                path = string.Join(".", group.Pieces.Select(t => t.Name));
            }

            if (!string.IsNullOrEmpty(path))
            {
                var whereExpression = QueryableHelpers.CreateConditionExpression(group.Parameter.Type, path,
                                                                                 ConditionOperators.NotEqual, null, QueryConvertStrategy.ConvertConstantToComparedPropertyOrField,
                                                                                 parameter: group.Parameter, nullChecking: true);

                //public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
                parentExpression = Expression.Call(typeof(Enumerable), "Where",
                                                   new Type[] { parent.GroupEnumerableType() },
                                                   parentExpression, whereExpression);
            }

            return(parentExpression);
        }
Пример #2
0
        private Expression CheckNullOnFirstGroup(ExpressionParserPieceGroup group, Expression currentExpression)
        {
            var path            = string.Join(".", group.Pieces.Select(t => t.Name));
            var whereExpression = QueryableHelpers.CreateConditionExpression(group.Parameter.Type, path,
                                                                             ConditionOperators.NotEqual, null, QueryConvertStrategy.ConvertConstantToComparedPropertyOrField,
                                                                             parameter: group.Parameter, nullChecking: true);

            var whereBodyExpression = (whereExpression as LambdaExpression).Body;

            whereBodyExpression = Expression.Not(whereBodyExpression);



            var        nullType         = currentExpression.Type;
            Expression ifTrueExpression = null;

            if (QueryableHelpers.IsGenericEnumerable(nullType))
            {
                var listType = typeof(List <>).MakeGenericType(nullType.GenericTypeArguments.First());
                ifTrueExpression = Expression.New(listType);
            }
            else
            {
                ifTrueExpression = Expression.Default(nullType);
            }

            return(Expression.Condition(whereBodyExpression, ifTrueExpression, currentExpression, currentExpression.Type));
        }
Пример #3
0
        protected Expression CompileGroup(ExpressionParserPieceGroup group, bool nullChecking)
        {
            var expr = group.Parameter as Expression;

            group.Pieces.ForEach(piece =>
            {
                expr = Expression.PropertyOrField(expr, piece.Name);
            });
            return(expr);
        }