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
- TokenBasedSet.cs
- EventRouteFactory.cs
- SqlFormatter.cs
- StateMachineWorkflowDesigner.cs
- TableStyle.cs
- Span.cs
- KnownTypesHelper.cs
- RuleSettings.cs
- NumericUpDownAcceleration.cs
- Parallel.cs
- ProtocolsConfigurationHandler.cs
- SqlNodeAnnotations.cs
- Asn1IntegerConverter.cs
- HybridDictionary.cs
- OperatorExpressions.cs
- Vector3DAnimationBase.cs
- DetailsViewDesigner.cs
- XmlTextWriter.cs
- DesignerAttributeInfo.cs
- MatrixConverter.cs
- CacheVirtualItemsEvent.cs
- GeneralTransform3DTo2D.cs
- DataColumnChangeEvent.cs
- ProbeMatches11.cs
- ToolStripControlHost.cs
- CharEnumerator.cs
- FormViewPageEventArgs.cs
- DispatcherFrame.cs
- FacetValueContainer.cs
- State.cs
- LinkLabelLinkClickedEvent.cs
- MemberNameValidator.cs
- Expr.cs
- DBAsyncResult.cs
- SR.cs
- ExpressionTextBoxAutomationPeer.cs
- LayoutEvent.cs
- CounterCreationDataCollection.cs
- XamlReaderHelper.cs
- QueryContinueDragEvent.cs
- SQLUtility.cs
- SamlAuthorizationDecisionStatement.cs
- StylusPointProperties.cs
- UrlEncodedParameterWriter.cs
- LinqDataSource.cs
- IndependentAnimationStorage.cs
- Math.cs
- CustomErrorCollection.cs
- FormViewRow.cs
- CursorConverter.cs
- QueryCursorEventArgs.cs
- LinqDataSourceDeleteEventArgs.cs
- DataTableNewRowEvent.cs
- SupportingTokenChannel.cs
- CharEnumerator.cs
- ModelItemDictionaryImpl.cs
- RequestDescription.cs
- PeerToPeerException.cs
- EmulateRecognizeCompletedEventArgs.cs
- Viewport3DVisual.cs
- WebControlsSection.cs
- Int32AnimationBase.cs
- TemplateControlCodeDomTreeGenerator.cs
- DataGridViewCellFormattingEventArgs.cs
- CollectionViewGroup.cs
- CodeActivityMetadata.cs
- CreateSequenceResponse.cs
- DataGridViewTopRowAccessibleObject.cs
- FixedStringLookup.cs
- arabicshape.cs
- SessionStateUtil.cs
- WebColorConverter.cs
- StoragePropertyMapping.cs
- ListControlDataBindingHandler.cs
- ToolStripComboBox.cs
- _ProxyChain.cs
- DataViewManager.cs
- LocalValueEnumerator.cs
- WebServiceTypeData.cs
- ThreadAbortException.cs
- ParagraphResult.cs
- TypeSystem.cs
- HttpRequest.cs
- InstanceOwnerQueryResult.cs
- TextSegment.cs
- PictureBox.cs
- DoubleLink.cs
- VirtualPathUtility.cs
- SizeIndependentAnimationStorage.cs
- templategroup.cs
- SessionStateUtil.cs
- cookiecollection.cs
- RegexFCD.cs
- __Filters.cs
- ProcessHost.cs
- FocusTracker.cs
- FixedPage.cs
- DbCommandTree.cs
- JumpTask.cs
- Win32Native.cs