コード例 #1
0
        // public static methods
        public static AstFilter Translate(TranslationContext context, MethodCallExpression expression)
        {
            if (StringExpressionToRegexFilterTranslator.CanTranslate(expression))
            {
                return(StringExpressionToRegexFilterTranslator.Translate(context, expression));
            }

            throw new ExpressionNotSupportedException(expression);
        }
コード例 #2
0
        public static AstFilter Translate(TranslationContext context, MethodCallExpression expression)
        {
            if (StringExpressionToRegexFilterTranslator.CanTranslate(expression))
            {
                return(StringExpressionToRegexFilterTranslator.Translate(context, expression));
            }

            var method    = expression.Method;
            var arguments = expression.Arguments;

            if (method.IsStatic &&
                method.Name == "Contains" &&
                method.ReturnType == typeof(bool) &&
                arguments.Count == 2)
            {
                var sourceExpression = arguments[0];
                var sourceType       = sourceExpression.Type;
                var itemExpression   = arguments[1];
                var itemType         = itemExpression.Type;
                if (TypeImplementsIEnumerable(sourceType, itemType))
                {
                    return(Translate(context, expression, sourceExpression, itemExpression));
                }
            }

            if (!method.IsStatic &&
                method.Name == "Contains" &&
                method.ReturnType == typeof(bool) &&
                arguments.Count == 1)
            {
                var sourceExpression = expression.Object;
                var sourceType       = sourceExpression.Type;
                var itemExpression   = arguments[0];
                var itemType         = itemExpression.Type;
                if (TypeImplementsIEnumerable(sourceType, itemType))
                {
                    return(Translate(context, expression, sourceExpression, itemExpression));
                }
            }

            throw new ExpressionNotSupportedException(expression);
        }
        private static AstFilter Translate(TranslationContext context, Expression expression, Expression expression1, Expression expression2)
        {
            Expression fieldExpression, valueExpression;

            if (expression1.NodeType == ExpressionType.Constant && expression2.NodeType != ExpressionType.Constant)
            {
                (fieldExpression, valueExpression) = (expression2, expression1);
            }
            else
            {
                (fieldExpression, valueExpression) = (expression1, expression2);
            }

            if (StringExpressionToRegexFilterTranslator.TryTranslateComparisonExpression(context, expression, fieldExpression, AstComparisonFilterOperator.Eq, valueExpression, out var filter))
            {
                return(filter);
            }

            var field           = ExpressionToFilterFieldTranslator.Translate(context, fieldExpression);
            var value           = valueExpression.GetConstantValue <object>(containingExpression: expression);
            var serializedValue = SerializationHelper.SerializeValue(field.Serializer, value);

            return(AstFilter.Eq(field, serializedValue));
        }