コード例 #1
0
        protected override CamlExpression VisitWhereLogicalExpression(CamlWhereLogicalExpression expression)
        {
            CamlLogicalOperator previousOperator = currentOperater;

            using (new WhereExpressionScope(this, expression.Operator)) {
                if (expression.Operator == CamlLogicalOperator.Not)
                {
                    queryBuilder.Append(" -");
                    Visit(expression.Left);
                }
                else
                {
                    if (previousOperator != expression.Operator)
                    {
                        queryBuilder.Append("(");
                    }
                    Visit(expression.Left);
                    if (expression.Operator == CamlLogicalOperator.Or)
                    {
                        queryBuilder.Append(" OR ");
                    }
                    else
                    {
                        queryBuilder.Append(" ");
                    }
                    Visit(expression.Right);
                    if (previousOperator != expression.Operator)
                    {
                        queryBuilder.Append(")");
                    }
                }
            }
            return(expression);
        }
コード例 #2
0
        /// <summary>
        /// Called when visiting a logical comparison expression inside a &lt;Where/&gt; element.
        /// </summary>
        /// <param name="expression">An instance of the <see cref="CamlWhereLogicalExpression"/> class representing the logical comparison expression.</param>
        /// <returns>When overriden, returns an expression to replace the expression given in arguments.</returns>
        protected virtual CamlExpression VisitWhereLogicalExpression(CamlWhereLogicalExpression expression)
        {
            CommonHelper.ConfirmNotNull(expression, "expression");
            CamlExpression l = VisitChecked(expression.Left, CamlExpressionType.Where);
            CamlExpression r = VisitChecked(expression.Right, CamlExpressionType.Where);

            if (l != expression.Left || r != expression.Right)
            {
                switch (expression.Operator)
                {
                case CamlLogicalOperator.And:
                    return(Caml.And(l, r));

                case CamlLogicalOperator.Or:
                    return(Caml.Or(l, r));

                case CamlLogicalOperator.Not:
                    return(Caml.Not(l));
                }
                throw new InvalidOperationException();
            }
            return(expression);
        }