|
public Update ( |
||
| test | The |
|
| ifTrue | The |
|
| ifFalse | The |
|
| return | ||
/// <summary>
/// Visits the children of the <see cref="ConditionalExpression" />.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>
/// The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.
/// </returns>
protected internal virtual Expression VisitConditional(ConditionalExpression node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
return(node.Update(Visit(node.Test), Visit(node.IfTrue), Visit(node.IfFalse)));
}
protected override ExpressionTree VisitConditional(ConditionalExpression node)
{
CheckChildrenCount(3);
var t = ExtractChildExpression(0);
var p = ExtractChildExpression(1);
var n = ExtractChildExpression(2);
var expression = node.Update(t, p, n);
return(CreateExpressionTree(expression));
}
/// <summary>
/// Visits the children of the <see cref="ConditionalExpression"/>.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.</returns>
protected internal virtual Expression VisitConditional(ConditionalExpression node)
{
return(node.Update(Visit(node.Test), Visit(node.IfTrue), Visit(node.IfFalse)));
}
protected override Expression VisitConditional(ConditionalExpression node)
{
Debug.WriteLine(node);
var ifTrue = Visit(node.IfTrue);
var ifFalse = Visit(node.IfFalse);
var test = Visit(node.Test);
Expression expression;
if (ExtractNullableArgument(test, ifTrue, out expression))
{
return Expression.Coalesce(expression, ifFalse);
}
var ifTrueBinary = UnwrapConvertExpression(ifTrue) as BinaryExpression;
if (ifTrueBinary != null)
{
BinaryExpression result;
if (TryConvert1(test, ifTrueBinary, out result))
return result;
}
var binaryExpression = test as BinaryExpression;
var ifTrueConstant = ifTrue as ConstantExpression;
var ifFalseConstant = ifFalse as ConstantExpression;
if (binaryExpression != null)
{
BinaryExpression result;
if (ifTrueBinary != null && TryConvert2(binaryExpression, ifTrueBinary, out result))
{
return result;
}
if (TryConvert(ifTrueConstant, binaryExpression, ifFalse, out result, false))
{
return result;
}
if (TryConvert(ifFalseConstant, binaryExpression, ifTrue, out result, true))
{
return result;
}
if (binaryExpression.NodeType == ExpressionType.NotEqual)
{
if (binaryExpression.Left == node.IfTrue)
{
if (binaryExpression.Right is DefaultExpression)
{
return Expression.Coalesce(binaryExpression.Left, ifFalse);
}
var rightConstant = binaryExpression.Right as ConstantExpression;
if (rightConstant != null && rightConstant.Value == null)
{
return Expression.Coalesce(binaryExpression.Left, ifFalse);
}
}
}
}
if (test.NodeType == ExpressionType.Not)
{
if (ifTrueConstant != null)
{
if (ifTrueConstant.Value as bool? == false)
{
return Expression.AndAlso(((UnaryExpression) test).Operand, ifFalse);
}
}
}
return node.Update(test, ifTrue, ifFalse);
}
#pragma warning restore CA1810
#pragma warning restore IDE0079
/// <summary>
/// Visits the conditional expression and avoids inadvertening cloning of the node when unchanged due to a bug in the .NET Framework.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns>
/// <remarks>
/// Works around a bug in ConditionalExpression.Update that causes inadvertent cloning of `IfThen` nodes.
/// See https://github.com/dotnet/corefx/issues/3223 for more information.
/// </remarks>
protected override Expression VisitConditional(ConditionalExpression node)
{
//
// No need to do some workaround if the quirk has been fixed.
//
if (s_hasIfThenQuirk)
{
//
// The quirk exists, so only access IfFalse once to avoid triggering allocations
// of spurious Default(typeof(void)) nodes.
//
var oldIfFalse = node.IfFalse;
//
// See ConditionalExpression.Make for the logic that leads to special-casing nodes
// whose IfFalse child is a DefaultExpression of type void.
//
if (node.Type == typeof(void) && IsEmpty(oldIfFalse))
{
var oldTest = node.Test;
var oldIfTrue = node.IfTrue;
//
// Visit in the same order as the base class would do. We still visit IfFalse,
// which always returns a new instance of Default(typeof(void)) when the quirk
// is present. This is needed because a visitor subtype may want to do override
// VisitDefault and change the IfFalse node.
//
var newTest = Visit(oldTest);
var newIfTrue = Visit(oldIfTrue);
var newIfFalse = Visit(oldIfFalse);
//
// Check child reference equality to avoid cloning, as we normally would do,
// but check the case where the new IfFalse child node is Default(typeof(void))
// which we will classify as no change either.
//
// NB: In case the user rewrites the expression tree to ensure uniqueness of
// references of nodes (i.e. intentional cloning), it's fine to keep the
// node as-is, because ConditionalExpression's behavior of returning a new
// instance of Default(typeof(void)) for each access to IfFalse ensures
// the same uniqueness property. Stated otherwise, the unique Default node
// handed to us by such a user doesn't get stored in ConditionalExpression
// anyway, in favor of GetFalse() returning new Default(typeof(void)) nodes
// for each access to IfFalse.
//
if (newTest == oldTest &&
newIfTrue == oldIfTrue &&
(newIfFalse == oldIfFalse || IsEmpty(newIfFalse)))
{
return(node);
}
//
// If anything changed for real, call Update as usual.
//
return(node.Update(newTest, newIfTrue, newIfFalse));
}
}
return(base.VisitConditional(node));
}
protected override Expression VisitConditional(ConditionalExpression node)
{
var children = new[] {node.Test, node.IfTrue, node.IfFalse};
VisitChildren(children);
return node.Update(children[0], children[1], children[2]);
}
private ConditionalExpression replaceConditionalNodeChild(ConditionalExpression conditionalExpression, Expression oldChild, Expression newChild)
{
Expression test = conditionalExpression.Test.Equals(oldChild) ? newChild : conditionalExpression.Test;
Expression ifTrue = conditionalExpression.IfTrue.Equals(oldChild) ? newChild : conditionalExpression.IfTrue;
Expression ifFalse = conditionalExpression.IfFalse.Equals(oldChild) ? newChild : conditionalExpression.IfFalse;
return conditionalExpression.Update(test, ifTrue, ifFalse);
}