| public static ReferenceEqual ( Expression left, Expression right ) : BinaryExpression | ||
| left | Expression | An |
| right | Expression | An |
| return | BinaryExpression | |
// Helper that is used when re-eval of LHS is safe.
private Expression ByValParameterTypeEqual(ParameterExpression value)
{
Expression getType = Expression.Call(value, typeof(object).GetMethod("GetType"));
// In remoting scenarios, obj.GetType() can return an interface.
// But JIT32's optimized "obj.GetType() == typeof(ISomething)" codegen,
// causing it to always return false.
// We workaround this optimization by generating different, less optimal IL
// if TypeOperand is an interface.
if (_typeOperand.GetTypeInfo().IsInterface)
{
var temp = Expression.Parameter(typeof(Type));
getType = Expression.Block(new[] { temp }, Expression.Assign(temp, getType), temp);
}
// We use reference equality when comparing to null for correctness
// (don't invoke a user defined operator), and reference equality
// on types for performance (so the JIT can optimize the IL).
return(Expression.AndAlso(
Expression.ReferenceNotEqual(value, Expression.Constant(null)),
Expression.ReferenceEqual(
getType,
Expression.Constant(_typeOperand.GetNonNullableType(), typeof(Type))
)
));
}
public void ReferenceEquals()
{
var expected =
LinqExpression.ReferenceEqual(
LinqExpression.Parameter(
typeof(object)),
LinqExpression.Parameter(
typeof(object)));
var actual = $@"
@prefix : <http://example.com/> .
:s
a :ReferenceEqual ;
:binaryLeft [
:parameterType [
:typeName ""System.Object"" ;
]
] ;
:binaryRight [
:parameterType [
:typeName ""System.Object"" ;
] ;
] ;
.
";
ShouldBe(actual, expected);
}
public void ReferenceEqual()
{
var expression =
LinqExpression.ReferenceEqual(
LinqExpression.Parameter(
typeof(object)),
LinqExpression.Parameter(
typeof(object)));
ShouldRoundrip(expression);
}
public BinaryExpression Update(Expression left, LambdaExpression conversion, Expression right)
{
if (((left == this.Left) && (right == this.Right)) && (conversion == this.Conversion))
{
return(this);
}
if (!this.IsReferenceComparison)
{
return(Expression.MakeBinary(this.NodeType, left, right, this.IsLiftedToNull, this.Method, conversion));
}
if (this.NodeType == ExpressionType.Equal)
{
return(Expression.ReferenceEqual(left, right));
}
return(Expression.ReferenceNotEqual(left, right));
}
