|
public static Modulo ( |
||
| left | An |
|
| right | An |
|
| 리턴 | ||
public void TestWhereArithmetic()
{
var parameter = LinqExpression.Parameter(typeof(NumbersModel), "x");
var n1 = LinqExpression.Property(parameter, "Number1");
var n2 = LinqExpression.Property(parameter, "Number2");
var m2g8 = new Func <int, int, bool>((x1, x2) => x1 * 2 > 8);
var d2g3 = new Func <int, int, bool>((x1, x2) => x1 / 2 > 3);
var m2e0 = new Func <int, int, bool>((x1, x2) => (x1 % 2) == 0);
var a5g10 = new Func <int, int, bool>((x1, x2) => x1 + 5 > 10);
var s5g0 = new Func <int, int, bool>((x1, x2) => x1 - 5 > 0);
var mn2g10 = new Func <int, int, bool>((x1, x2) => x1 * x2 > 10);
var dn1g3 = new Func <int, int, bool>((x1, x2) => x2 / x1 > 3);
var mn2e0 = new Func <int, int, bool>((x1, x2) => (x1 % x2) == 0);
var an2e10 = new Func <int, int, bool>((x1, x2) => x1 + x2 == 10);
var sn2g0 = new Func <int, int, bool>((x1, x2) => x1 - x2 > 0);
var cases = new[] {
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Multiply(n1, LinqExpression.Constant(2)), LinqExpression.Constant(8)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)m2g8, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Divide(n1, LinqExpression.Constant(2)), LinqExpression.Constant(3)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)d2g3, parameter),
Tuple.Create((LinqExpression)LinqExpression.Equal(LinqExpression.Modulo(n1, LinqExpression.Constant(2)), LinqExpression.Constant(0)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)m2e0, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Add(n1, LinqExpression.Constant(5)), LinqExpression.Constant(10)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)a5g10, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Subtract(n1, LinqExpression.Constant(5)), LinqExpression.Constant(0)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)s5g0, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Multiply(n1, n2), LinqExpression.Constant(10)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)mn2g10, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Divide(n2, n1), LinqExpression.Constant(3)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)dn1g3, parameter),
Tuple.Create((LinqExpression)LinqExpression.Equal(LinqExpression.Modulo(n1, n2), LinqExpression.Constant(0)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)mn2e0, parameter),
Tuple.Create((LinqExpression)LinqExpression.Equal(LinqExpression.Add(n1, n2), LinqExpression.Constant(10)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)an2e10, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Subtract(n1, n2), LinqExpression.Constant(0)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)sn2g0, parameter)
};
LoadModelNumbers(10);
RunTestWithNumbers(new[] { 6, 3, 5, 5, 5, 7, 2, 3, 10, 5 }, cases);
}
private BinaryExpression BinaryExpression(
ExpressionType nodeType, System.Type type, JObject obj)
{
var left = this.Prop(obj, "left", this.Expression);
var right = this.Prop(obj, "right", this.Expression);
var method = this.Prop(obj, "method", this.Method);
var conversion = this.Prop(obj, "conversion", this.LambdaExpression);
var liftToNull = this.Prop(obj, "liftToNull").Value <bool>();
switch (nodeType)
{
case ExpressionType.Add: return(Expr.Add(left, right, method));
case ExpressionType.AddAssign: return(Expr.AddAssign(left, right, method, conversion));
case ExpressionType.AddAssignChecked: return(Expr.AddAssignChecked(left, right, method, conversion));
case ExpressionType.AddChecked: return(Expr.AddChecked(left, right, method));
case ExpressionType.And: return(Expr.And(left, right, method));
case ExpressionType.AndAlso: return(Expr.AndAlso(left, right, method));
case ExpressionType.AndAssign: return(Expr.AndAssign(left, right, method, conversion));
case ExpressionType.ArrayIndex: return(Expr.ArrayIndex(left, right));
case ExpressionType.Assign: return(Expr.Assign(left, right));
case ExpressionType.Coalesce: return(Expr.Coalesce(left, right, conversion));
case ExpressionType.Divide: return(Expr.Divide(left, right, method));
case ExpressionType.DivideAssign: return(Expr.DivideAssign(left, right, method, conversion));
case ExpressionType.Equal: return(Expr.Equal(left, right, liftToNull, method));
case ExpressionType.ExclusiveOr: return(Expr.ExclusiveOr(left, right, method));
case ExpressionType.ExclusiveOrAssign: return(Expr.ExclusiveOrAssign(left, right, method, conversion));
case ExpressionType.GreaterThan: return(Expr.GreaterThan(left, right, liftToNull, method));
case ExpressionType.GreaterThanOrEqual: return(Expr.GreaterThanOrEqual(left, right, liftToNull, method));
case ExpressionType.LeftShift: return(Expr.LeftShift(left, right, method));
case ExpressionType.LeftShiftAssign: return(Expr.LeftShiftAssign(left, right, method, conversion));
case ExpressionType.LessThan: return(Expr.LessThan(left, right, liftToNull, method));
case ExpressionType.LessThanOrEqual: return(Expr.LessThanOrEqual(left, right, liftToNull, method));
case ExpressionType.Modulo: return(Expr.Modulo(left, right, method));
case ExpressionType.ModuloAssign: return(Expr.ModuloAssign(left, right, method, conversion));
case ExpressionType.Multiply: return(Expr.Multiply(left, right, method));
case ExpressionType.MultiplyAssign: return(Expr.MultiplyAssign(left, right, method, conversion));
case ExpressionType.MultiplyAssignChecked: return(Expr.MultiplyAssignChecked(left, right, method, conversion));
case ExpressionType.MultiplyChecked: return(Expr.MultiplyChecked(left, right, method));
case ExpressionType.NotEqual: return(Expr.NotEqual(left, right, liftToNull, method));
case ExpressionType.Or: return(Expr.Or(left, right, method));
case ExpressionType.OrAssign: return(Expr.OrAssign(left, right, method, conversion));
case ExpressionType.OrElse: return(Expr.OrElse(left, right, method));
case ExpressionType.Power: return(Expr.Power(left, right, method));
case ExpressionType.PowerAssign: return(Expr.PowerAssign(left, right, method, conversion));
case ExpressionType.RightShift: return(Expr.RightShift(left, right, method));
case ExpressionType.RightShiftAssign: return(Expr.RightShiftAssign(left, right, method, conversion));
case ExpressionType.Subtract: return(Expr.Subtract(left, right, method));
case ExpressionType.SubtractAssign: return(Expr.SubtractAssign(left, right, method, conversion));
case ExpressionType.SubtractAssignChecked: return(Expr.SubtractAssignChecked(left, right, method, conversion));
case ExpressionType.SubtractChecked: return(Expr.SubtractChecked(left, right, method));
default: throw new NotSupportedException();
}
}
public static Expression Modulo(Expression arg0, Expression arg1)
{
return(new Expression(LinqExpression.Modulo(arg0, arg1)));
}
