ExpressionReplacer.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / ndp / fx / src / DataEntity / System / Data / Common / CommandTrees / Internal / ExpressionReplacer.cs / 2 / ExpressionReplacer.cs
                        

                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner  [....], [....]
//--------------------------------------------------------------------- 
 
using System;
using System.Collections.Generic; 
using System.Diagnostics;
using System.Data.Metadata.Edm;
using System.Data.Common.CommandTrees;
 
namespace System.Data.Common.CommandTrees.Internal
{ 
    internal class ExpressionReplacement 
    {
        private DbExpression _toReplace; 
        private DbExpression _replacement;
        private bool _visit;

        internal ExpressionReplacement() { } 

        public DbExpression Current { get { return _toReplace; } internal set { _toReplace = value; } } 
        public DbExpression Replacement 
        {
            get { return _replacement; } 
            set
            {
                // #487325
                if (value == null) 
                {
                    throw EntityUtil.ArgumentNull("Replacement"); 
                } 
                _replacement = value;
            } 
        }
        public bool VisitReplacement { get { return _visit; } set { _visit = value; } }
    }
 
    internal delegate void ReplacerCallback(ExpressionReplacement replacement);
 
    /// 
 
    /// Replaces Expressions according to a given callback
    /// 
 
    internal class ExpressionReplacer : DbExpressionVisitor
    {
        private ReplacerCallback _replacer;
        private ExpressionReplacement _replacement = new ExpressionReplacement(); 

        internal ExpressionReplacer(ReplacerCallback replacer) 
        { 
            _replacer = replacer;
        } 

        internal DbExpression Replace(DbExpression toReplace)
        {
            return toReplace.Accept(this); 
        }
 
        internal void ReplaceBinding(DbExpressionBinding binding) 
        {
            DbExpression newExpr = this.Replace(binding.Expression); 
            if (!object.ReferenceEquals(newExpr, binding.Expression))
            {
                binding.Expression = newExpr;
            } 
        }
 
        #region Private Implementation 

        /// 
 
        /// Handles the logic of invoking the replacement callback, inspecting the result, and recursing into the new expression if necessary.
        /// This method is guaranteed to return either the original expression or the replaced expression as the value of the out parameter
        /// (i.e. will never return null) with the Boolean return value indicating whether or not replacement actually took place.
        /// 
 
        /// The DbExpression to potentially replace
        /// Either the original DbExpression or the DbExpression that the replacement callback replaced the original DbExpression with 
        /// True if the original DbExpression was replaced and the result is the new DbExpression; false otherwise (in which case result is the original DbExpression) 
        private bool DoReplacement(DbExpression original, out DbExpression result)
        { 
            result = original;

            _replacement.Current = original;
            _replacement.Replacement = original; 
            _replacement.VisitReplacement = true;
 
            _replacer(_replacement); 

            if (!object.ReferenceEquals(_replacement.Current, _replacement.Replacement)) 
            {
                if (_replacement.VisitReplacement)
                {
                    result = this.Replace(_replacement.Replacement); 
                }
                else 
                { 
                    result = _replacement.Replacement;
                } 

                return true;
            }
 
            return false;
        } 
 
        private DbExpression ReplaceTerminal(DbExpression e)
        { 
            DbExpression retExpr = null;
            DoReplacement(e, out retExpr);
            return retExpr;
        } 

        private DbExpression ReplaceUnary(DbUnaryExpression e) 
        { 
            DbExpression retExpr = null;
            if (DoReplacement(e, out retExpr)) 
            {
                return retExpr;
            }
 
            DbExpression argExpr = this.Replace(e.Argument);
            if (!object.ReferenceEquals(argExpr, e.Argument)) 
            { 
                e.Argument = argExpr;
            } 

            return e;
        }
 
        private DbExpression ReplaceBinary(DbBinaryExpression e)
        { 
            DbExpression retExpr = null; 
            if (DoReplacement(e, out retExpr))
            { 
                return retExpr;
            }

            DbExpression argExpr = this.Replace(e.Left); 
            if (!object.ReferenceEquals(argExpr, e.Left))
            { 
                e.Left = argExpr; 
            }
 
            argExpr = this.Replace(e.Right);
            if (!object.ReferenceEquals(argExpr, e.Right))
            {
                e.Right = argExpr; 
            }
 
            return e; 
        }
 
        private void ReplaceList(IList list)
        {
            for (int idx = 0; idx < list.Count; idx++)
            { 
                DbExpression newExpr = this.Replace(list[idx]);
                if (!object.ReferenceEquals(newExpr, list[idx])) 
                { 
#if MUTABLE_CQT
                    list[idx] = newExpr; 
#else
                    ExpressionList exprList = list as ExpressionList;
                    if (exprList != null)
                    { 
                        exprList.SetAt(idx, newExpr);
                    } 
                    else 
                    {
                        list[idx] = newExpr; 
                    }
#endif
                }
            } 

        } 
 
        private void ReplaceBinding(DbGroupExpressionBinding binding)
        { 
            DbExpression newExpr = this.Replace(binding.Expression);
            if (!object.ReferenceEquals(newExpr, binding.Expression))
            {
                binding.Expression = newExpr; 
            }
        } 
 
        #endregion
 
        #region DbExpressionVisitor Members

        public override DbExpression Visit(DbExpression e)
        { 
            throw EntityUtil.NotSupported(System.Data.Entity.Strings.Cqt_General_UnsupportedExpression(e.GetType().FullName));
        } 
 
        public override DbExpression Visit(DbConstantExpression e)
        { 
            return ReplaceTerminal(e);
        }

        public override DbExpression Visit(DbNullExpression e) 
        {
            return ReplaceTerminal(e); 
        } 

        public override DbExpression Visit(DbVariableReferenceExpression e) 
        {
            return ReplaceTerminal(e);
        }
 
        public override DbExpression Visit(DbParameterReferenceExpression e)
        { 
            return ReplaceTerminal(e); 
        }
 
        public override DbExpression Visit(DbFunctionExpression e)
        {
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            } 

            ReplaceList(e.Arguments); 

            if (e.IsLambda)
            {
                Debug.Assert(e.LambdaBody != null, "DbFunctionExpression.IsLambda returned true when LambdaBody == null"); 
                DbExpression newBody = this.Replace(e.LambdaBody);
                if (!object.ReferenceEquals(newBody, e.LambdaBody)) 
                { 
                    e.LambdaBody = newBody;
                } 
            }

            return e;
        } 

#if METHOD_EXPRESSION 
        public override Expression Visit(MethodExpression e) 
        {
            Expression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            {
                return newExpr;
            } 

            ReplaceList(e.Arguments); 
 
            if (e.Instance != null)
            { 
                Expression newInst = this.Replace(e.Instance);
                if (!object.ReferenceEquals(newInst, e.Instance))
                {
                    e.Instance = newInst; 
                }
            } 
 
            return e;
        } 
#endif

        public override DbExpression Visit(DbPropertyExpression e)
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            { 
                return newExpr;
            } 

            if (e.Instance != null)
            {
                DbExpression newInst = this.Replace(e.Instance); 
                if (!object.ReferenceEquals(newInst, e.Instance))
                { 
                    e.Instance = newInst; 
                }
            } 

            return e;
        }
 
        public override DbExpression Visit(DbComparisonExpression e)
        { 
            return ReplaceBinary(e); 
        }
 
        public override DbExpression Visit(DbLikeExpression e)
        {
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            } 

            DbExpression argExpr = this.Replace(e.Argument); 
            if (!object.ReferenceEquals(argExpr, e.Argument))
            {
                e.Argument = argExpr;
            } 

            argExpr = this.Replace(e.Pattern); 
            if (!object.ReferenceEquals(argExpr, e.Pattern)) 
            {
                e.Pattern = argExpr; 
            }

            argExpr = this.Replace(e.Escape);
            if (!object.ReferenceEquals(argExpr, e.Escape)) 
            {
                e.Escape = argExpr; 
            } 

            return e; 
        }

        public override DbExpression Visit(DbLimitExpression e)
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            { 
                return newExpr;
            } 

            DbExpression argExpr = this.Replace(e.Argument);
            if (!object.ReferenceEquals(argExpr, e.Argument))
            { 
                e.Argument = argExpr;
            } 
 
            argExpr = this.Replace(e.Limit);
            if (!object.ReferenceEquals(argExpr, e.Limit)) 
            {
                e.Limit = argExpr;
            }
 
            return e;
        } 
 
        public override DbExpression Visit(DbIsNullExpression e)
        { 
            return ReplaceUnary(e);
        }

        public override DbExpression Visit(DbArithmeticExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            }

            ReplaceList(e.Arguments);
 
            return e;
        } 
 
        public override DbExpression Visit(DbAndExpression e)
        { 
            return ReplaceBinary(e);
        }

        public override DbExpression Visit(DbOrExpression e) 
        {
            return ReplaceBinary(e); 
        } 

        public override DbExpression Visit(DbNotExpression e) 
        {
            return ReplaceUnary(e);
        }
 
        public override DbExpression Visit(DbDistinctExpression e)
        { 
            return ReplaceUnary(e); 
        }
 
        public override DbExpression Visit(DbElementExpression e)
        {
            return ReplaceUnary(e);
        } 

        public override DbExpression Visit(DbIsEmptyExpression e) 
        { 
            return ReplaceUnary(e);
        } 

        public override DbExpression Visit(DbUnionAllExpression e)
        {
            return ReplaceBinary(e); 
        }
 
        public override DbExpression Visit(DbIntersectExpression e) 
        {
            return ReplaceBinary(e); 
        }

        public override DbExpression Visit(DbExceptExpression e)
        { 
            return ReplaceBinary(e);
        } 
 
        public override DbExpression Visit(DbTreatExpression e)
        { 
            return ReplaceUnary(e);
        }

        public override DbExpression Visit(DbIsOfExpression e) 
        {
            return ReplaceUnary(e); 
        } 

        public override DbExpression Visit(DbCastExpression e) 
        {
            return ReplaceUnary(e);
        }
 
        public override DbExpression Visit(DbCaseExpression e)
        { 
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            { 
                return newExpr;
            }

            ReplaceList(e.When); 
            ReplaceList(e.Then);
            newExpr = this.Replace(e.Else); 
            if (!object.ReferenceEquals(newExpr, e.Else)) 
            {
                e.Else = newExpr; 
            }

            return e;
        } 

        public override DbExpression Visit(DbOfTypeExpression e) 
        { 
            return ReplaceUnary(e);
        } 

        public override DbExpression Visit(DbNewInstanceExpression e)
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            { 
                return newExpr; 
            }
 
            ReplaceList(e.Arguments);
            if (e.HasRelatedEntityReferences)
            {
                foreach(DbRelatedEntityRef relatedRef in e.RelatedEntityReferences) 
                {
                    DbExpression newTargetRef = this.Replace(relatedRef.TargetEntityReference); 
                    if (!object.ReferenceEquals(newTargetRef, relatedRef.TargetEntityReference)) 
                    {
                        relatedRef.TargetEntityReference = newTargetRef; 
                    }
                }
            }
 
            return e;
        } 
 
        public override DbExpression Visit(DbRefExpression e)
        { 
            return ReplaceUnary(e);
        }

        public override DbExpression Visit(DbRelationshipNavigationExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            }

            DbExpression argExpr = this.Replace(e.NavigationSource);
            if (!object.ReferenceEquals(argExpr, e.NavigationSource)) 
            {
                e.NavigationSource = argExpr; 
            } 

            return e; 
        }

        public override DbExpression Visit(DbDerefExpression e)
        { 
            return ReplaceUnary(e);
        } 
 
        public override DbExpression Visit(DbRefKeyExpression e)
        { 
            return ReplaceUnary(e);
        }

        public override DbExpression Visit(DbEntityRefExpression e) 
        {
            return ReplaceUnary(e); 
        } 

        public override DbExpression Visit(DbScanExpression e) 
        {
            return ReplaceTerminal(e);
        }
 
        public override DbExpression Visit(DbFilterExpression e)
        { 
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            { 
                return newExpr;
            }

            ReplaceBinding(e.Input); 

            DbExpression predExpr = this.Replace(e.Predicate); 
            if (!object.ReferenceEquals(predExpr, e.Predicate)) 
            {
                e.Predicate = predExpr; 
            }

            return e;
        } 

        public override DbExpression Visit(DbProjectExpression e) 
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr;
            }
 
            ReplaceBinding(e.Input);
 
            DbExpression projExpr = this.Replace(e.Projection); 
            if (!object.ReferenceEquals(projExpr, e.Projection))
            { 
                e.Projection = projExpr;
            }

            return e; 
        }
 
        public override DbExpression Visit(DbCrossJoinExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            {
                return newExpr;
            } 

            foreach (DbExpressionBinding input in e.Inputs) 
            { 
                ReplaceBinding(input);
            } 

            return e;
        }
 
        public override DbExpression Visit(DbJoinExpression e)
        { 
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            { 
                return newExpr;
            }

            ReplaceBinding(e.Left); 
            ReplaceBinding(e.Right);
 
            DbExpression condExpr = this.Replace(e.JoinCondition); 
            if (!object.ReferenceEquals(condExpr, e.JoinCondition))
            { 
                e.JoinCondition = condExpr;
            }

            return e; 
        }
 
        public override DbExpression Visit(DbApplyExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            {
                return newExpr;
            } 

            ReplaceBinding(e.Input); 
            ReplaceBinding(e.Apply); 

            return e; 
        }

        public override DbExpression Visit(DbGroupByExpression e)
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            { 
                return newExpr;
            } 

            ReplaceBinding(e.Input);
            ReplaceList(e.Keys);
            foreach (DbAggregate agg in e.Aggregates) 
            {
                ReplaceList(agg.Arguments); 
            } 

            return e; 
        }

        private void ReplaceSortKeys(IList keys)
        { 
            foreach (DbSortClause sortClause in keys)
            { 
                DbExpression keyExpr = this.Replace(sortClause.Expression); 
                if (!object.ReferenceEquals(keyExpr, sortClause.Expression))
                { 
                    sortClause.Expression = keyExpr;
                }
            }
        } 

        public override DbExpression Visit(DbSkipExpression e) 
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr;
            }
 
            ReplaceBinding(e.Input);
            ReplaceSortKeys(e.SortOrder); 
 
            DbExpression countExpr = this.Replace(e.Count);
            if (!object.ReferenceEquals(countExpr, e.Count)) 
            {
                e.Count = countExpr;
            }
 
            return e;
        } 
 
        public override DbExpression Visit(DbSortExpression e)
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr))
            {
                return newExpr; 
            }
 
            ReplaceBinding(e.Input); 
            ReplaceSortKeys(e.SortOrder);
 
            return e;
        }

        public override DbExpression Visit(DbQuantifierExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            }

            ReplaceBinding(e.Input);
 
            DbExpression predExpr = this.Replace(e.Predicate);
            if (!object.ReferenceEquals(predExpr, e.Predicate)) 
            { 
                e.Predicate = predExpr;
            } 

            return e;
        }
 
        #endregion
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner  [....], [....]
//--------------------------------------------------------------------- 
 
using System;
using System.Collections.Generic; 
using System.Diagnostics;
using System.Data.Metadata.Edm;
using System.Data.Common.CommandTrees;
 
namespace System.Data.Common.CommandTrees.Internal
{ 
    internal class ExpressionReplacement 
    {
        private DbExpression _toReplace; 
        private DbExpression _replacement;
        private bool _visit;

        internal ExpressionReplacement() { } 

        public DbExpression Current { get { return _toReplace; } internal set { _toReplace = value; } } 
        public DbExpression Replacement 
        {
            get { return _replacement; } 
            set
            {
                // #487325
                if (value == null) 
                {
                    throw EntityUtil.ArgumentNull("Replacement"); 
                } 
                _replacement = value;
            } 
        }
        public bool VisitReplacement { get { return _visit; } set { _visit = value; } }
    }
 
    internal delegate void ReplacerCallback(ExpressionReplacement replacement);
 
    /// 
 
    /// Replaces Expressions according to a given callback
    /// 
 
    internal class ExpressionReplacer : DbExpressionVisitor
    {
        private ReplacerCallback _replacer;
        private ExpressionReplacement _replacement = new ExpressionReplacement(); 

        internal ExpressionReplacer(ReplacerCallback replacer) 
        { 
            _replacer = replacer;
        } 

        internal DbExpression Replace(DbExpression toReplace)
        {
            return toReplace.Accept(this); 
        }
 
        internal void ReplaceBinding(DbExpressionBinding binding) 
        {
            DbExpression newExpr = this.Replace(binding.Expression); 
            if (!object.ReferenceEquals(newExpr, binding.Expression))
            {
                binding.Expression = newExpr;
            } 
        }
 
        #region Private Implementation 

        /// 
 
        /// Handles the logic of invoking the replacement callback, inspecting the result, and recursing into the new expression if necessary.
        /// This method is guaranteed to return either the original expression or the replaced expression as the value of the out parameter
        /// (i.e. will never return null) with the Boolean return value indicating whether or not replacement actually took place.
        /// 
 
        /// The DbExpression to potentially replace
        /// Either the original DbExpression or the DbExpression that the replacement callback replaced the original DbExpression with 
        /// True if the original DbExpression was replaced and the result is the new DbExpression; false otherwise (in which case result is the original DbExpression) 
        private bool DoReplacement(DbExpression original, out DbExpression result)
        { 
            result = original;

            _replacement.Current = original;
            _replacement.Replacement = original; 
            _replacement.VisitReplacement = true;
 
            _replacer(_replacement); 

            if (!object.ReferenceEquals(_replacement.Current, _replacement.Replacement)) 
            {
                if (_replacement.VisitReplacement)
                {
                    result = this.Replace(_replacement.Replacement); 
                }
                else 
                { 
                    result = _replacement.Replacement;
                } 

                return true;
            }
 
            return false;
        } 
 
        private DbExpression ReplaceTerminal(DbExpression e)
        { 
            DbExpression retExpr = null;
            DoReplacement(e, out retExpr);
            return retExpr;
        } 

        private DbExpression ReplaceUnary(DbUnaryExpression e) 
        { 
            DbExpression retExpr = null;
            if (DoReplacement(e, out retExpr)) 
            {
                return retExpr;
            }
 
            DbExpression argExpr = this.Replace(e.Argument);
            if (!object.ReferenceEquals(argExpr, e.Argument)) 
            { 
                e.Argument = argExpr;
            } 

            return e;
        }
 
        private DbExpression ReplaceBinary(DbBinaryExpression e)
        { 
            DbExpression retExpr = null; 
            if (DoReplacement(e, out retExpr))
            { 
                return retExpr;
            }

            DbExpression argExpr = this.Replace(e.Left); 
            if (!object.ReferenceEquals(argExpr, e.Left))
            { 
                e.Left = argExpr; 
            }
 
            argExpr = this.Replace(e.Right);
            if (!object.ReferenceEquals(argExpr, e.Right))
            {
                e.Right = argExpr; 
            }
 
            return e; 
        }
 
        private void ReplaceList(IList list)
        {
            for (int idx = 0; idx < list.Count; idx++)
            { 
                DbExpression newExpr = this.Replace(list[idx]);
                if (!object.ReferenceEquals(newExpr, list[idx])) 
                { 
#if MUTABLE_CQT
                    list[idx] = newExpr; 
#else
                    ExpressionList exprList = list as ExpressionList;
                    if (exprList != null)
                    { 
                        exprList.SetAt(idx, newExpr);
                    } 
                    else 
                    {
                        list[idx] = newExpr; 
                    }
#endif
                }
            } 

        } 
 
        private void ReplaceBinding(DbGroupExpressionBinding binding)
        { 
            DbExpression newExpr = this.Replace(binding.Expression);
            if (!object.ReferenceEquals(newExpr, binding.Expression))
            {
                binding.Expression = newExpr; 
            }
        } 
 
        #endregion
 
        #region DbExpressionVisitor Members

        public override DbExpression Visit(DbExpression e)
        { 
            throw EntityUtil.NotSupported(System.Data.Entity.Strings.Cqt_General_UnsupportedExpression(e.GetType().FullName));
        } 
 
        public override DbExpression Visit(DbConstantExpression e)
        { 
            return ReplaceTerminal(e);
        }

        public override DbExpression Visit(DbNullExpression e) 
        {
            return ReplaceTerminal(e); 
        } 

        public override DbExpression Visit(DbVariableReferenceExpression e) 
        {
            return ReplaceTerminal(e);
        }
 
        public override DbExpression Visit(DbParameterReferenceExpression e)
        { 
            return ReplaceTerminal(e); 
        }
 
        public override DbExpression Visit(DbFunctionExpression e)
        {
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            } 

            ReplaceList(e.Arguments); 

            if (e.IsLambda)
            {
                Debug.Assert(e.LambdaBody != null, "DbFunctionExpression.IsLambda returned true when LambdaBody == null"); 
                DbExpression newBody = this.Replace(e.LambdaBody);
                if (!object.ReferenceEquals(newBody, e.LambdaBody)) 
                { 
                    e.LambdaBody = newBody;
                } 
            }

            return e;
        } 

#if METHOD_EXPRESSION 
        public override Expression Visit(MethodExpression e) 
        {
            Expression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            {
                return newExpr;
            } 

            ReplaceList(e.Arguments); 
 
            if (e.Instance != null)
            { 
                Expression newInst = this.Replace(e.Instance);
                if (!object.ReferenceEquals(newInst, e.Instance))
                {
                    e.Instance = newInst; 
                }
            } 
 
            return e;
        } 
#endif

        public override DbExpression Visit(DbPropertyExpression e)
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            { 
                return newExpr;
            } 

            if (e.Instance != null)
            {
                DbExpression newInst = this.Replace(e.Instance); 
                if (!object.ReferenceEquals(newInst, e.Instance))
                { 
                    e.Instance = newInst; 
                }
            } 

            return e;
        }
 
        public override DbExpression Visit(DbComparisonExpression e)
        { 
            return ReplaceBinary(e); 
        }
 
        public override DbExpression Visit(DbLikeExpression e)
        {
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            } 

            DbExpression argExpr = this.Replace(e.Argument); 
            if (!object.ReferenceEquals(argExpr, e.Argument))
            {
                e.Argument = argExpr;
            } 

            argExpr = this.Replace(e.Pattern); 
            if (!object.ReferenceEquals(argExpr, e.Pattern)) 
            {
                e.Pattern = argExpr; 
            }

            argExpr = this.Replace(e.Escape);
            if (!object.ReferenceEquals(argExpr, e.Escape)) 
            {
                e.Escape = argExpr; 
            } 

            return e; 
        }

        public override DbExpression Visit(DbLimitExpression e)
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            { 
                return newExpr;
            } 

            DbExpression argExpr = this.Replace(e.Argument);
            if (!object.ReferenceEquals(argExpr, e.Argument))
            { 
                e.Argument = argExpr;
            } 
 
            argExpr = this.Replace(e.Limit);
            if (!object.ReferenceEquals(argExpr, e.Limit)) 
            {
                e.Limit = argExpr;
            }
 
            return e;
        } 
 
        public override DbExpression Visit(DbIsNullExpression e)
        { 
            return ReplaceUnary(e);
        }

        public override DbExpression Visit(DbArithmeticExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            }

            ReplaceList(e.Arguments);
 
            return e;
        } 
 
        public override DbExpression Visit(DbAndExpression e)
        { 
            return ReplaceBinary(e);
        }

        public override DbExpression Visit(DbOrExpression e) 
        {
            return ReplaceBinary(e); 
        } 

        public override DbExpression Visit(DbNotExpression e) 
        {
            return ReplaceUnary(e);
        }
 
        public override DbExpression Visit(DbDistinctExpression e)
        { 
            return ReplaceUnary(e); 
        }
 
        public override DbExpression Visit(DbElementExpression e)
        {
            return ReplaceUnary(e);
        } 

        public override DbExpression Visit(DbIsEmptyExpression e) 
        { 
            return ReplaceUnary(e);
        } 

        public override DbExpression Visit(DbUnionAllExpression e)
        {
            return ReplaceBinary(e); 
        }
 
        public override DbExpression Visit(DbIntersectExpression e) 
        {
            return ReplaceBinary(e); 
        }

        public override DbExpression Visit(DbExceptExpression e)
        { 
            return ReplaceBinary(e);
        } 
 
        public override DbExpression Visit(DbTreatExpression e)
        { 
            return ReplaceUnary(e);
        }

        public override DbExpression Visit(DbIsOfExpression e) 
        {
            return ReplaceUnary(e); 
        } 

        public override DbExpression Visit(DbCastExpression e) 
        {
            return ReplaceUnary(e);
        }
 
        public override DbExpression Visit(DbCaseExpression e)
        { 
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            { 
                return newExpr;
            }

            ReplaceList(e.When); 
            ReplaceList(e.Then);
            newExpr = this.Replace(e.Else); 
            if (!object.ReferenceEquals(newExpr, e.Else)) 
            {
                e.Else = newExpr; 
            }

            return e;
        } 

        public override DbExpression Visit(DbOfTypeExpression e) 
        { 
            return ReplaceUnary(e);
        } 

        public override DbExpression Visit(DbNewInstanceExpression e)
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            { 
                return newExpr; 
            }
 
            ReplaceList(e.Arguments);
            if (e.HasRelatedEntityReferences)
            {
                foreach(DbRelatedEntityRef relatedRef in e.RelatedEntityReferences) 
                {
                    DbExpression newTargetRef = this.Replace(relatedRef.TargetEntityReference); 
                    if (!object.ReferenceEquals(newTargetRef, relatedRef.TargetEntityReference)) 
                    {
                        relatedRef.TargetEntityReference = newTargetRef; 
                    }
                }
            }
 
            return e;
        } 
 
        public override DbExpression Visit(DbRefExpression e)
        { 
            return ReplaceUnary(e);
        }

        public override DbExpression Visit(DbRelationshipNavigationExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            }

            DbExpression argExpr = this.Replace(e.NavigationSource);
            if (!object.ReferenceEquals(argExpr, e.NavigationSource)) 
            {
                e.NavigationSource = argExpr; 
            } 

            return e; 
        }

        public override DbExpression Visit(DbDerefExpression e)
        { 
            return ReplaceUnary(e);
        } 
 
        public override DbExpression Visit(DbRefKeyExpression e)
        { 
            return ReplaceUnary(e);
        }

        public override DbExpression Visit(DbEntityRefExpression e) 
        {
            return ReplaceUnary(e); 
        } 

        public override DbExpression Visit(DbScanExpression e) 
        {
            return ReplaceTerminal(e);
        }
 
        public override DbExpression Visit(DbFilterExpression e)
        { 
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            { 
                return newExpr;
            }

            ReplaceBinding(e.Input); 

            DbExpression predExpr = this.Replace(e.Predicate); 
            if (!object.ReferenceEquals(predExpr, e.Predicate)) 
            {
                e.Predicate = predExpr; 
            }

            return e;
        } 

        public override DbExpression Visit(DbProjectExpression e) 
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr;
            }
 
            ReplaceBinding(e.Input);
 
            DbExpression projExpr = this.Replace(e.Projection); 
            if (!object.ReferenceEquals(projExpr, e.Projection))
            { 
                e.Projection = projExpr;
            }

            return e; 
        }
 
        public override DbExpression Visit(DbCrossJoinExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            {
                return newExpr;
            } 

            foreach (DbExpressionBinding input in e.Inputs) 
            { 
                ReplaceBinding(input);
            } 

            return e;
        }
 
        public override DbExpression Visit(DbJoinExpression e)
        { 
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            { 
                return newExpr;
            }

            ReplaceBinding(e.Left); 
            ReplaceBinding(e.Right);
 
            DbExpression condExpr = this.Replace(e.JoinCondition); 
            if (!object.ReferenceEquals(condExpr, e.JoinCondition))
            { 
                e.JoinCondition = condExpr;
            }

            return e; 
        }
 
        public override DbExpression Visit(DbApplyExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr))
            {
                return newExpr;
            } 

            ReplaceBinding(e.Input); 
            ReplaceBinding(e.Apply); 

            return e; 
        }

        public override DbExpression Visit(DbGroupByExpression e)
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            { 
                return newExpr;
            } 

            ReplaceBinding(e.Input);
            ReplaceList(e.Keys);
            foreach (DbAggregate agg in e.Aggregates) 
            {
                ReplaceList(agg.Arguments); 
            } 

            return e; 
        }

        private void ReplaceSortKeys(IList keys)
        { 
            foreach (DbSortClause sortClause in keys)
            { 
                DbExpression keyExpr = this.Replace(sortClause.Expression); 
                if (!object.ReferenceEquals(keyExpr, sortClause.Expression))
                { 
                    sortClause.Expression = keyExpr;
                }
            }
        } 

        public override DbExpression Visit(DbSkipExpression e) 
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr;
            }
 
            ReplaceBinding(e.Input);
            ReplaceSortKeys(e.SortOrder); 
 
            DbExpression countExpr = this.Replace(e.Count);
            if (!object.ReferenceEquals(countExpr, e.Count)) 
            {
                e.Count = countExpr;
            }
 
            return e;
        } 
 
        public override DbExpression Visit(DbSortExpression e)
        { 
            DbExpression newExpr = null;
            if (DoReplacement(e, out newExpr))
            {
                return newExpr; 
            }
 
            ReplaceBinding(e.Input); 
            ReplaceSortKeys(e.SortOrder);
 
            return e;
        }

        public override DbExpression Visit(DbQuantifierExpression e) 
        {
            DbExpression newExpr = null; 
            if (DoReplacement(e, out newExpr)) 
            {
                return newExpr; 
            }

            ReplaceBinding(e.Input);
 
            DbExpression predExpr = this.Replace(e.Predicate);
            if (!object.ReferenceEquals(predExpr, e.Predicate)) 
            { 
                e.Predicate = predExpr;
            } 

            return e;
        }
 
        #endregion
    } 
} 

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

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• Dispatcher.cs
• Panel.cs
• PartialCachingControl.cs
• DateTimeValueSerializer.cs
• RSAPKCS1SignatureFormatter.cs
• SqlRecordBuffer.cs
• ContextMenu.cs
• ReflectionTypeLoadException.cs
• BitmapMetadataBlob.cs
• HGlobalSafeHandle.cs
• AttributeQuery.cs
• MeshGeometry3D.cs
• VirtualPath.cs
• AsymmetricSignatureFormatter.cs
• CaseInsensitiveOrdinalStringComparer.cs
• StorageAssociationSetMapping.cs
• InvalidProgramException.cs
• ParserStack.cs
• StorageScalarPropertyMapping.cs
• SQLInt64.cs
• DataControlCommands.cs
• PartManifestEntry.cs
• TransformerInfoCollection.cs
• complextypematerializer.cs
• RowBinding.cs
• MatrixCamera.cs
• SpeechEvent.cs
• WebPartConnectionsCancelVerb.cs
• PixelShader.cs
• ConfigXmlDocument.cs
• RadioButton.cs
• COM2AboutBoxPropertyDescriptor.cs
• ChineseLunisolarCalendar.cs
• HtmlInputButton.cs
• AppDomainUnloadedException.cs
• MultipleViewPatternIdentifiers.cs
• Vector3DCollectionConverter.cs
• exports.cs
• WindowsEditBoxRange.cs
• Point3D.cs
• XmlElementList.cs
• ColumnClickEvent.cs
• MergeFilterQuery.cs
• Fx.cs
• EventDescriptor.cs
• UTF7Encoding.cs
• DecodeHelper.cs
• PersistenceProviderElement.cs
• Models.cs
• ColorTranslator.cs
• BulletedListEventArgs.cs
• Sequence.cs
• sqlnorm.cs
• WorkflowStateRollbackService.cs
• XmlCharacterData.cs
• SelectionRange.cs
• BaseInfoTable.cs
• WebPartManagerInternals.cs
• RegexCompiler.cs
• Int64KeyFrameCollection.cs
• ExtractorMetadata.cs
• WSSecureConversationDec2005.cs
• SpinLock.cs
• OdbcConnectionHandle.cs
• IPipelineRuntime.cs
• ClientData.cs
• TransformGroup.cs
• CommandValueSerializer.cs
• DictionarySectionHandler.cs
• MailHeaderInfo.cs
• ContextMenu.cs
• BlockUIContainer.cs
• MetadataItemEmitter.cs
• BuildManager.cs
• ReadOnlyDictionary.cs
• MasterPageCodeDomTreeGenerator.cs
• TemplateControlCodeDomTreeGenerator.cs
• DataTableTypeConverter.cs
• FileLogRecordEnumerator.cs
• ScriptModule.cs
• RegexReplacement.cs
• ErrorEventArgs.cs
• ApplicationGesture.cs
• OleDbRowUpdatedEvent.cs
• TableLayoutCellPaintEventArgs.cs
• XPathExpr.cs
• FactoryId.cs
• DependencyPropertyKey.cs
• X509CertificateTrustedIssuerElement.cs
• TraceContextRecord.cs
• SqlDataSourceFilteringEventArgs.cs
• EncryptedXml.cs
• DBProviderConfigurationHandler.cs
• StylusPlugin.cs
• DiscardableAttribute.cs
• ResourceAssociationTypeEnd.cs
• MulticastDelegate.cs
• figurelengthconverter.cs
• DateTimeOffsetAdapter.cs
• ExtendedPropertyCollection.cs