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

• MDIControlStrip.cs
• CancellationTokenSource.cs
• QilScopedVisitor.cs
• LogWriteRestartAreaAsyncResult.cs
• FileVersionInfo.cs
• AutomationEvent.cs
• Fx.cs
• MissingMemberException.cs
• ArrayList.cs
• DocumentGrid.cs
• PageCatalogPartDesigner.cs
• NavigatingCancelEventArgs.cs
• HttpRequest.cs
• OleDbCommand.cs
• RuntimeWrappedException.cs
• SecurityPolicySection.cs
• ResolveNameEventArgs.cs
• CodePageEncoding.cs
• CompositeDesignerAccessibleObject.cs
• PersonalizationAdministration.cs
• HtmlTableCell.cs
• PreApplicationStartMethodAttribute.cs
• XmlSchemaValidator.cs
• serverconfig.cs
• GridViewDeletedEventArgs.cs
• ControlPaint.cs
• Int64KeyFrameCollection.cs
• CodeArrayCreateExpression.cs
• DbConvert.cs
• PageDeviceFont.cs
• Matrix3D.cs
• SecurityVerifiedMessage.cs
• CornerRadiusConverter.cs
• CodeDirectionExpression.cs
• RtfToXamlReader.cs
• ChannelCredentials.cs
• Visual.cs
• MouseButton.cs
• Int64.cs
• AspCompat.cs
• ErasingStroke.cs
• TextDecorationUnitValidation.cs
• ToolboxControl.cs
• Accessors.cs
• IntSecurity.cs
• WebPartZone.cs
• MetafileHeaderEmf.cs
• _Events.cs
• OleDbCommand.cs
• odbcmetadatafactory.cs
• ListControl.cs
• DeviceOverridableAttribute.cs
• SolidBrush.cs
• IndentTextWriter.cs
• LocatorGroup.cs
• HMACMD5.cs
• WindowsHyperlink.cs
• DesignerForm.cs
• Convert.cs
• DataGridCellsPresenter.cs
• oledbconnectionstring.cs
• SchemaElementLookUpTableEnumerator.cs
• SiteMapNodeItemEventArgs.cs
• ClientTargetSection.cs
• SeekStoryboard.cs
• NonSerializedAttribute.cs
• DeploymentExceptionMapper.cs
• AmbiguousMatchException.cs
• _CookieModule.cs
• TypeElement.cs
• DelegatingConfigHost.cs
• DataTableTypeConverter.cs
• ComplexPropertyEntry.cs
• _FixedSizeReader.cs
• DbConnectionFactory.cs
• IndicShape.cs
• _BasicClient.cs
• PageParserFilter.cs
• DocobjHost.cs
• GridViewUpdatedEventArgs.cs
• DispatcherExceptionEventArgs.cs
• HtmlImage.cs
• ThicknessAnimationUsingKeyFrames.cs
• COM2PropertyBuilderUITypeEditor.cs
• DeferredElementTreeState.cs
• CodeIterationStatement.cs
• TableSectionStyle.cs
• SystemIcmpV4Statistics.cs
• DBCommandBuilder.cs
• ProjectionPlanCompiler.cs
• DataRowView.cs
• SerializerProvider.cs
• NativeMethods.cs
• PageStatePersister.cs
• Model3D.cs
• ContainerUtilities.cs
• CacheEntry.cs
• SharedUtils.cs
• ConfigurationStrings.cs
• XamlDesignerSerializationManager.cs