DbExpressionRules.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Common / CommandTrees / Internal / DbExpressionRules.cs / 1305376 / DbExpressionRules.cs
                        
                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System.Data.Common.CommandTrees; 
using System.Collections.Generic;
using System.Data.Metadata.Edm;
using System.Diagnostics;
using System.Data.Common.Utils; 
using System.Linq;
using System.Globalization; 
using System.Data.Common.CommandTrees.ExpressionBuilder; 

namespace System.Data.Common.CommandTrees.Internal 
{
    /// 
    /// Enacapsulates the logic that defines an expression 'rule' which is capable of transforming a candidate 
    /// into a result DbExpression, and indicating what action should be taken on that result expression by the rule application logic. 
    /// 
    internal abstract class DbExpressionRule 
    { 
        /// 
        /// Indicates what action the rule processor should take if the rule successfully processes an expression. 
        /// 
        internal enum ProcessedAction
        {
            ///  
            /// Continue to apply rules, from the rule immediately following this rule, to the result expression
            ///  
            Continue = 0, 

            ///  
            /// Going back to the first rule, apply all rules to the result expression
            /// 
            Reset,
 
            /// 
            /// Stop all rule processing and return the result expression as the final result expression 
            ///  
            Stop
        } 

        /// 
        /// Indicates whether  should be called on the specified argument expression.
        ///  
        /// The  that the rule should inspect and determine if processing is possible
        /// true if the rule can attempt processing of the expression via the  method; otherwise false 
        internal abstract bool ShouldProcess(DbExpression expression); 

        ///  
        /// Attempts to process the input  to produce a  .
        /// 
        /// The input expression that the rule should process
        /// The result expression produced by the rule if processing was successful 
        /// true if the rule was able to successfully process the input expression and produce a result expression; otherwise false
        internal abstract bool TryProcess(DbExpression expression, out DbExpression result); 
 
        /// 
        /// Indicates what action - as a  value - the rule processor should take if  returns true. 
        /// 
        internal abstract ProcessedAction OnExpressionProcessed { get; }
    }
 
    /// 
    /// Abstract base class for a DbExpression visitor that can apply a collection of s during the visitor pass, returning the final result expression. 
    /// This class encapsulates the rule application logic that applies regardless of how the ruleset - modelled as the abstract  method - is provided. 
    /// 
    internal abstract class DbExpressionRuleProcessingVisitor : DefaultExpressionVisitor 
    {
        protected DbExpressionRuleProcessingVisitor() { }

        protected abstract IEnumerable GetRules(); 

        private static Tuple ProcessRules(DbExpression expression, List rules) 
        { 
            // Considering each rule in the rule set in turn, if the rule indicates that it can process the
            // input expression, call TryProcess to attempt processing. If successful, take the action specified 
            // by the rule's OnExpressionProcessed action, which may involve returning the action and the result
            // expression so that processing can be reset or halted.

            for (int idx = 0; idx < rules.Count; idx++) 
            {
                DbExpressionRule currentRule = rules[idx]; 
                if (currentRule.ShouldProcess(expression)) 
                {
                    DbExpression result; 
                    if (currentRule.TryProcess(expression, out result))
                    {
                        if (currentRule.OnExpressionProcessed != DbExpressionRule.ProcessedAction.Continue)
                        { 
                            return Tuple.Create(result, currentRule.OnExpressionProcessed);
                        } 
                        else 
                        {
                            expression = result; 
                        }
                    }
                }
            } 
            return Tuple.Create(expression, DbExpressionRule.ProcessedAction.Continue);
        } 
 
        private bool _stopped;
 
        private DbExpression ApplyRules(DbExpression expression)
        {
            // Driver loop to apply rules while the status of processing is 'Reset',
            // or correctly set the _stopped flag if status is 'Stopped'. 

            List currentRules = this.GetRules().ToList(); 
            var ruleResult = ProcessRules(expression, currentRules); 
            while (ruleResult.Item2 == DbExpressionRule.ProcessedAction.Reset)
            { 
                currentRules = this.GetRules().ToList();
                ruleResult = ProcessRules(ruleResult.Item1, currentRules);
            }
            if (ruleResult.Item2 == DbExpressionRule.ProcessedAction.Stop) 
            {
                _stopped = true; 
            } 
            return ruleResult.Item1;
        } 

        protected override DbExpression VisitExpression(DbExpression expression)
        {
            // Pre-process this visitor's rules 
            DbExpression result = ApplyRules(expression);
            if (_stopped) 
            { 
                // If rule processing was stopped, the result expression must be returned immediately
                return result; 
            }

            // Visit the expression to recursively apply rules to subexpressions
            result = base.VisitExpression(result); 
            if (_stopped)
            { 
                // If rule processing was stopped, the result expression must be returned immediately 
                return result;
            } 

            // Post-process the rules over the resulting expression and return the result.
            // This is done so that rules that did not match the original structure of the
            // expression have an opportunity to examine the structure of the result expression. 
            result = ApplyRules(result);
            return result; 
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
DbExpressionRules.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
