Пример #1
0
        private static string GetMaxValue(IFolderRange folderRange)
        {
            if (folderRange.IsMaxOpenEnded)
            {
                return("" + char.MaxValue + char.MaxValue + char.MaxValue);
            }

            return((string)folderRange.MaxValue);
        }
Пример #2
0
        private static string GetMinValue(IFolderRange folderRange)
        {
            if (folderRange.IsMinOpenEnded)
            {
                return("" + (char.MinValue + 1) + (char.MinValue + 1) + (char.MinValue + 1));
            }

            return((string)folderRange.MinValue);
        }
Пример #3
0
        private Expression CreateFolderRangeExpression(IFolderRange folderRange, Expression fieldExpression)
        {
            string minValue = GetMinValue(folderRange);
            string maxValue = GetMaxValue(folderRange);

            var fieldToUpper = Expression.Call(fieldExpression, this.StringToUpper_MethodInfo);

            Expression expression = Expression.AndAlso(
                Expression.NotEqual(
                    fieldExpression,
                    Expression.Constant(null, typeof(string))
                    ),
                Expression.AndAlso(
                    Expression.GreaterThanOrEqual(
                        Expression.Call(
                            this.StringCompare_MethodInfo,
                            fieldToUpper,
                            Expression.Constant(minValue.ToUpperInvariant())
                            ),
                        Expression.Constant(0)
                        ),

                    Expression.OrElse(
                        Expression.LessThanOrEqual(
                            Expression.Call(
                                this.StringCompare_MethodInfo,
                                fieldToUpper,
                                Expression.Constant(maxValue.ToUpperInvariant())
                                ),
                            Expression.Constant(0)
                            ),

                        Expression.Call(fieldToUpper, StringStartsWith_MethodInfo, Expression.Constant(maxValue.ToUpperInvariant()))
                        )

                    )
                );

            return(expression);
        }
Пример #4
0
        public override Expression CreateFilterExpression(int folderRangeIndex, Expression fieldExpression)
        {
            if (folderRangeIndex != -1)
            {
                IFolderRange folderRange = this.GetFolderRange(folderRangeIndex);

                return(CreateFolderRangeExpression(folderRange, fieldExpression));
            }

            Expression currentExpression = null;

            foreach (IFolderRange folderRange in this.Ranges.Where(f => f.Index != -1))
            {
                Expression expression = CreateFolderRangeExpression(folderRange, fieldExpression);

                expression = Expression.Not(expression);

                currentExpression = currentExpression.NestedAnd(expression);
            }

            return(currentExpression);
        }
Пример #5
0
 public void AddFolderRange(IFolderRange folderRange)
 {
     _folderRanges.Add(folderRange);
 }
 public void AddFolderRange(IFolderRange folderRange)
 {
     _folderRanges.Add(folderRange);
 }
Пример #7
0
        private Expression CreateFolderRangeExpression(IFolderRange folderRange, Expression fieldExpression)
        {
            string minValue = GetMinValue(folderRange);
            string maxValue = GetMaxValue(folderRange);

            var fieldToUpper = Expression.Call(fieldExpression, this.StringToUpper_MethodInfo);

            Expression expression = Expression.AndAlso(
                Expression.NotEqual(
                    fieldExpression,
                    Expression.Constant(null, typeof(string))
                ),
                Expression.AndAlso(
                    Expression.GreaterThanOrEqual(
                        Expression.Call(
                            this.StringCompare_MethodInfo,
                            fieldToUpper,
                            Expression.Constant(minValue.ToUpperInvariant())
                        ),
                        Expression.Constant(0)
                    ),

                    Expression.OrElse(
                        Expression.LessThanOrEqual(
                            Expression.Call(
                                this.StringCompare_MethodInfo,
                                fieldToUpper,
                                Expression.Constant(maxValue.ToUpperInvariant())
                            ),
                            Expression.Constant(0)
                        ),

                        Expression.Call(fieldToUpper, StringStartsWith_MethodInfo, Expression.Constant(maxValue.ToUpperInvariant()))
                    )
                    
                )
            );

            return expression;
        }
Пример #8
0
        private static string GetMaxValue(IFolderRange folderRange)
        {
            if (folderRange.IsMaxOpenEnded)
            {
                return "" + char.MaxValue + char.MaxValue + char.MaxValue;
            }

            return (string) folderRange.MaxValue;
        }
Пример #9
0
        private static string GetMinValue(IFolderRange folderRange)
        {
            if (folderRange.IsMinOpenEnded)
            {
                return "" + (char.MinValue + 1) + (char.MinValue + 1) + (char.MinValue + 1);
            }

            return (string) folderRange.MinValue;
        }
Пример #10
0
        public override Expression CreateFilterExpression(int folderRangeIndex, Expression fieldExpression)
        {
            if (folderRangeIndex != -1)
            {
                IFolderRange folderRange = this.GetFolderRange(folderRangeIndex);

                int minValue = (int)folderRange.MinValue;
                int maxValue = (int)folderRange.MaxValue;

                Expression minExpression = Expression.GreaterThanOrEqual(
                    fieldExpression,
                    Expression.Constant(minValue)
                    );

                Expression maxExpression = Expression.LessThanOrEqual(
                    fieldExpression,
                    Expression.Constant(maxValue)
                    );

                Expression expression;
                if (folderRange.IsMinOpenEnded)
                {
                    expression = maxExpression;
                }
                else if (folderRange.IsMaxOpenEnded)
                {
                    expression = minExpression;
                }
                else
                {
                    expression = Expression.And(minExpression, maxExpression);
                }

                return(expression);
            }
            else
            {
                Expression currentExpression = null;
                foreach (IFolderRange folderRange in this.Ranges.Where(f => f.Index != -1))
                {
                    int minValue = (int)folderRange.MinValue;
                    int maxValue = (int)folderRange.MaxValue;

                    Expression minExpression = Expression.GreaterThanOrEqual(
                        fieldExpression,
                        Expression.Constant(minValue)
                        );

                    Expression maxExpression = Expression.LessThanOrEqual(
                        fieldExpression,
                        Expression.Constant(maxValue)
                        );

                    if (folderRange.IsMinOpenEnded)
                    {
                        currentExpression = currentExpression.NestedAnd(Expression.Not(maxExpression));
                    }
                    else if (folderRange.IsMaxOpenEnded)
                    {
                        currentExpression = currentExpression.NestedAnd(Expression.Not(minExpression));
                    }
                    else
                    {
                        currentExpression = currentExpression.NestedAnd(
                            Expression.Not(
                                Expression.And(
                                    minExpression,
                                    maxExpression
                                    )
                                )
                            );
                    }
                }

                return(currentExpression);
            }
        }