public override Expression Visit(BinaryOperatorNode nodeIn)
{
Expression left = TranslateNode(nodeIn.Left);
Expression right = TranslateNode(nodeIn.Right);
if (left.Type != right.Type && !(OeExpressionHelper.IsNull(left) || OeExpressionHelper.IsNull(right)))
{
Type leftType = left.Type;
Type rightType = right.Type;
if (OeExpressionHelper.IsNullable(left))
{
leftType = Nullable.GetUnderlyingType(left.Type);
left = Expression.Convert(left, left.Type);
}
else if (OeExpressionHelper.IsNullable(right))
{
rightType = Nullable.GetUnderlyingType(right.Type);
right = Expression.Convert(right, right.Type);
}
if (right.Type != left.Type)
{
if (left is ConstantExpression)
{
ConstantExpression oldConstant = left as ConstantExpression;
ConstantExpression newConstant = OeExpressionHelper.ConstantChangeType(oldConstant, rightType);
if (oldConstant != newConstant)
{
ReplaceConstant(oldConstant, newConstant);
}
left = Expression.Convert(newConstant, right.Type);
}
else if (right is ConstantExpression)
{
ConstantExpression oldConstant = right as ConstantExpression;
ConstantExpression newConstant = OeExpressionHelper.ConstantChangeType(oldConstant, leftType);
if (oldConstant != newConstant)
{
ReplaceConstant(oldConstant, newConstant);
}
right = Expression.Convert(newConstant, left.Type);
}
else
{
right = Expression.Convert(right, left.Type);
}
}
}
ExpressionType binaryType = OeExpressionHelper.ToExpressionType(nodeIn.OperatorKind);
return(Expression.MakeBinary(binaryType, left, right));
}
public override Expression Visit(InNode nodeIn)
{
var propertyExpression = (MemberExpression)Visit((SingleValuePropertyAccessNode)nodeIn.Left);
var constantNodes = (CollectionConstantNode)nodeIn.Right;
BinaryExpression inExpression = null;
for (int i = 0; i < constantNodes.Collection.Count; i++)
{
var constantExpression = (ConstantExpression)Visit(constantNodes.Collection[i]);
ConstantExpression coercedConstanExpression = OeExpressionHelper.ConstantChangeType(constantExpression, propertyExpression.Type);
if (coercedConstanExpression != constantExpression)
{
ReplaceConstant(constantExpression, coercedConstanExpression);
}
BinaryExpression equalExpression = Expression.Equal(propertyExpression, coercedConstanExpression);
inExpression = inExpression == null ? equalExpression : Expression.OrElse(inExpression, equalExpression);
}
return(inExpression);
}
public override Expression Visit(BinaryOperatorNode nodeIn)
{
Expression left = TranslateNode(nodeIn.Left);
Expression right = TranslateNode(nodeIn.Right);
if (left.Type != right.Type)
{
Type leftType = left.Type;
Type rightType = right.Type;
if (OeExpressionHelper.IsNullable(left) && !OeExpressionHelper.IsNull(left))
{
if (OeExpressionHelper.IsNull(right))
{
right = OeConstantToVariableVisitor.NullConstantExpression;
}
else
{
leftType = Nullable.GetUnderlyingType(left.Type);
}
}
else if (OeExpressionHelper.IsNullable(right) && !OeExpressionHelper.IsNull(right))
{
if (OeExpressionHelper.IsNull(left))
{
left = OeConstantToVariableVisitor.NullConstantExpression;
}
else
{
rightType = Nullable.GetUnderlyingType(right.Type);
}
}
if (right.Type != left.Type)
{
if (left is ConstantExpression)
{
ConstantExpression oldConstant = left as ConstantExpression;
ConstantExpression newConstant = OeExpressionHelper.ConstantChangeType(oldConstant, rightType);
if (oldConstant != newConstant)
{
ReplaceConstant(oldConstant, newConstant);
}
left = Expression.Convert(newConstant, right.Type);
}
else if (right is ConstantExpression)
{
ConstantExpression oldConstant = right as ConstantExpression;
ConstantExpression newConstant = OeExpressionHelper.ConstantChangeType(oldConstant, leftType);
if (oldConstant != newConstant)
{
ReplaceConstant(oldConstant, newConstant);
}
right = Expression.Convert(newConstant, left.Type);
}
else
{
Type precedenceType = OeExpressionHelper.GetTypeConversion(left.Type, right.Type);
if (left.Type != precedenceType)
{
left = Expression.Convert(left, precedenceType);
}
if (right.Type != precedenceType)
{
right = Expression.Convert(right, precedenceType);
}
}
}
}
ExpressionType binaryType = OeExpressionHelper.ToExpressionType(nodeIn.OperatorKind);
if (!(binaryType == ExpressionType.Equal || binaryType == ExpressionType.NotEqual))
{
if (left.Type == typeof(String))
{
Func <String, String, int> compareToFunc = String.Compare;
MethodCallExpression compareToCall = Expression.Call(null, compareToFunc.GetMethodInfo(), left, right);
return(Expression.MakeBinary(binaryType, compareToCall, OeConstantToVariableVisitor.ZeroStringCompareConstantExpression));
}
Type underlyingType;
if (left.Type.IsEnum)
{
Type enumUnderlyingType = Enum.GetUnderlyingType(left.Type);
left = ConvertEnumExpression(left, enumUnderlyingType);
right = ConvertEnumExpression(right, enumUnderlyingType);
}
else if ((underlyingType = Nullable.GetUnderlyingType(left.Type)) != null && underlyingType.IsEnum)
{
Type enumUnderlyingType = Enum.GetUnderlyingType(underlyingType);
Type nullableUnderlyingType = typeof(Nullable <>).MakeGenericType(enumUnderlyingType);
left = ConvertEnumExpression(left, nullableUnderlyingType);
right = ConvertEnumExpression(right, nullableUnderlyingType);
}
}
return(Expression.MakeBinary(binaryType, left, right));
UnaryExpression ConvertEnumExpression(Expression e, Type nullableType)
{
if (e is UnaryExpression unaryExpression)
{
var value = (ConstantExpression)unaryExpression.Operand;
return(Expression.Convert(value, nullableType));
}
return(Expression.Convert(e, nullableType));
}
}
public override Expression Visit(BinaryOperatorNode nodeIn)
{
Expression left = TranslateNode(nodeIn.Left);
Expression right = TranslateNode(nodeIn.Right);
if (left.Type != right.Type)
{
Type leftType = left.Type;
Type rightType = right.Type;
if (OeExpressionHelper.IsNullable(left) && !OeExpressionHelper.IsNull(left))
{
if (OeExpressionHelper.IsNull(right))
{
ConstantExpression newConstant = Expression.Constant(null, leftType);
ReplaceConstant((ConstantExpression)right, newConstant);
right = newConstant;
}
else
{
leftType = Nullable.GetUnderlyingType(left.Type);
}
}
else if (OeExpressionHelper.IsNullable(right) && !OeExpressionHelper.IsNull(right))
{
if (OeExpressionHelper.IsNull(left))
{
ConstantExpression newConstant = Expression.Constant(null, rightType);
ReplaceConstant((ConstantExpression)left, newConstant);
left = newConstant;
}
else
{
rightType = Nullable.GetUnderlyingType(right.Type);
}
}
if (right.Type != left.Type)
{
if (left is ConstantExpression)
{
ConstantExpression oldConstant = left as ConstantExpression;
ConstantExpression newConstant = OeExpressionHelper.ConstantChangeType(oldConstant, rightType);
if (oldConstant != newConstant)
{
ReplaceConstant(oldConstant, newConstant);
}
left = Expression.Convert(newConstant, right.Type);
}
else if (right is ConstantExpression)
{
ConstantExpression oldConstant = right as ConstantExpression;
ConstantExpression newConstant = OeExpressionHelper.ConstantChangeType(oldConstant, leftType);
if (oldConstant != newConstant)
{
ReplaceConstant(oldConstant, newConstant);
}
right = Expression.Convert(newConstant, left.Type);
}
else
{
Type precedenceType = OeExpressionHelper.GetTypeConversion(left.Type, right.Type);
if (left.Type != precedenceType)
{
left = Expression.Convert(left, precedenceType);
}
if (right.Type != precedenceType)
{
right = Expression.Convert(right, precedenceType);
}
}
}
}
ExpressionType binaryType = OeExpressionHelper.ToExpressionType(nodeIn.OperatorKind);
if (left.Type == typeof(String) && !(binaryType == ExpressionType.Equal || binaryType == ExpressionType.NotEqual))
{
Func <String, String, int> compareToFunc = String.Compare;
MethodCallExpression compareToCall = Expression.Call(null, compareToFunc.GetMethodInfo(), left, right);
return(Expression.MakeBinary(binaryType, compareToCall, OeConstantToVariableVisitor.ZeroStringCompareConstantExpression));
}
return(Expression.MakeBinary(binaryType, left, right));
}
