|
public static GreaterThanOrEqual ( |
||
| left | An |
|
| right | An |
|
| return | ||
public void TestWhereComparison()
{
// Partial LINQ expression (x => x.Number1)
var parameter = LinqExpression.Parameter(typeof(NumbersModel), "x");
var n1 = LinqExpression.Property(parameter, "Number1");
var l3 = new Func <int, bool>(n => n < 3);
var le3 = new Func <int, bool>(n => n <= 3);
var g6 = new Func <int, bool>(n => n > 6);
var ge6 = new Func <int, bool>(n => n >= 6);
var e7 = new Func <int, bool>(n => n == 7);
var ne7 = new Func <int, bool>(n => n != 7);
var cases = new[] {
Tuple.Create((LinqExpression)LinqExpression.LessThan(n1, LinqExpression.Constant(3)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)l3, parameter),
Tuple.Create((LinqExpression)LinqExpression.LessThanOrEqual(n1, LinqExpression.Constant(3)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)le3, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(n1, LinqExpression.Constant(6)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)g6, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThanOrEqual(n1, LinqExpression.Constant(6)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)ge6, parameter),
Tuple.Create((LinqExpression)LinqExpression.Equal(n1, LinqExpression.Constant(7)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)e7, parameter),
Tuple.Create((LinqExpression)LinqExpression.NotEqual(n1, LinqExpression.Constant(7)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)ne7, parameter)
};
LoadModelNumbers(10);
Db.Count.Should().Be(10);
RunTestWithNumbers(new[] { 2, 3, 4, 5, 1, 9 }, 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 CreateLambdaExpression <T, TModel>(IEnumerable <FilterElement> filterElements, Type querytype, ParameterExpression arg)
{
Expression expression = Expression.Constant(true);
foreach (var filterElement in filterElements)
{
string[] props = filterElement.FilterSpecs.DataElement.Split('.');
Expression propertyExpression = arg;
var type = typeof(T);
Expression notNullExpression = Expression.Constant(true);
foreach (var property in props)
{
PropertyInfo pi = type.GetProperty(property);
propertyExpression = Expression.Property(propertyExpression, pi);
var nullExpression = Expression.Constant(GetNullExpressionForType(pi.PropertyType), pi.PropertyType);
notNullExpression = Expression.AndAlso(notNullExpression, Expression.NotEqual(propertyExpression, nullExpression));
type = pi.PropertyType;
}
var isLiteralType = type.IsEquivalentTo(typeof(string));
var valueExpression = Expression.Constant(filterElement.FieldValue, filterElement.Property.PropertyType);
Expression inputExpression, variableExpression;
if (filterElement.FilterSpecs.CaseSensitive && isLiteralType)
{
variableExpression = Expression.Call(propertyExpression,
typeof(String).GetMethod("ToUpper", new Type[] { }));
inputExpression = Expression.Call(valueExpression,
typeof(String).GetMethod("ToUpper", new Type[] { }));
}
else
{
// special case to handle nullable values
if (valueExpression.Type.IsNullable())
{
valueExpression = Expression.Constant(valueExpression.Value, filterElement.Property.PropertyType.NullableOf());
}
inputExpression = valueExpression;
variableExpression = propertyExpression;
}
BinaryExpression conditionExpression = Expression.Equal(variableExpression, valueExpression);
switch (filterElement.FilterSpecs.OperatorOption)
{
case Operator.Equal:
conditionExpression = Expression.Equal(variableExpression, inputExpression);
break;
case Operator.GreaterThan:
conditionExpression = Expression.GreaterThan(variableExpression, inputExpression);
break;
case Operator.GreaterThanOrEqualTo:
conditionExpression = Expression.GreaterThanOrEqual(variableExpression, inputExpression);
break;
case Operator.LessThan:
conditionExpression = Expression.LessThan(variableExpression, inputExpression);
break;
case Operator.LessThanOrEqualTo:
conditionExpression = Expression.LessThanOrEqual(variableExpression, inputExpression);
break;
case Operator.Unequal:
conditionExpression = Expression.NotEqual(variableExpression, inputExpression);
break;
case Operator.Like:
MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
var containsMethodCall = Expression.Call(variableExpression, method, inputExpression);
conditionExpression = Expression.Equal(containsMethodCall, Expression.Constant(true));
break;
}
var clausePart = Expression.AndAlso(notNullExpression, conditionExpression);
if (!filterElement.FieldValue.Equals(GetNullExpressionForType(filterElement.Property.PropertyType)))
{
expression = Expression.AndAlso(expression, clausePart);
}
}
return(expression);
}
/// <summary>
/// 创建大于等于运算表达式
/// </summary>
/// <param name="left">左操作数</param>
/// <param name="right">右操作数</param>
public static MicrosoftExpression GreaterEqual(this MicrosoftExpression left, MicrosoftExpression right)
{
return(MicrosoftExpression.GreaterThanOrEqual(left, right));
}
private static LinqExpression Compile(ElementExpression value, CompilationData data)
{
data.Cache ??= new Dictionary <CachedExpression, ParameterExpression>();
data.GroupCache ??= new Dictionary <ExpressionGroup, LinqExpression[]>();
switch (value)
{
case ICLRExpression s:
return(s.Compile(e => Compile(e, data)));
case Constant c:
return(LinqExpression.Constant(c.Value));
case Binary b:
var ea = Compile(b.OpA, data);
var eb = Compile(b.OpB, data);
if (b.Operation == Binary.Op.Pow)
{
var o = LinqExpression.Call(typeof(Math).GetMethod(nameof(Math.Pow)),
LinqExpression.Convert(ea, typeof(double)), LinqExpression.Convert(eb, typeof(double)));
return(LinqExpression.Convert(o, typeof(float)));
}
if (b.Operation == Binary.Op.Atan2)
{
var o = LinqExpression.Call(typeof(Math).GetMethod(nameof(Math.Atan2)),
LinqExpression.Convert(ea, typeof(double)), LinqExpression.Convert(eb, typeof(double)));
return(LinqExpression.Convert(o, typeof(float)));
}
return(BinaryOps[b.Operation](ea, eb));
case Unary u:
var input = Compile(u.Operand, data);
var output = LinqExpression.Call(MethodOps[u.Operation], LinqExpression.Convert(input, typeof(double)));
return(LinqExpression.Convert(output, typeof(float)));
case CachedExpression v:
if (!data.Cache.TryGetValue(v, out var varExpr))
{
var result = Compile(v.Value, data);
data.Cache.Add(v, varExpr = LinqExpression.Parameter(result.Type));
data.Statements.Add(LinqExpression.Assign(varExpr, result));
data.Variables.Add(varExpr);
}
return(varExpr);
case Mux m:
if (m.Operands.Count == 2)
{
return(LinqExpression.Condition(
LinqExpression.LessThan(Compile(m.Selector, data), LinqExpression.Constant(1f)),
Compile(m.Operands[0], data), Compile(m.Operands[1], data)));
}
var sel = LinqExpression.Convert(Compile(m.Selector, data), typeof(int));
var clampedSel =
LinqExpression.Condition(
LinqExpression.GreaterThanOrEqual(sel, LinqExpression.Constant(m.Operands.Count)),
LinqExpression.Constant(m.Operands.Count - 1), sel);
var cases = m.Operands.Select(
(c, i) => LinqExpression.SwitchCase(Compile(c, data), LinqExpression.Constant(i)))
.ToArray();
return(LinqExpression.Switch(clampedSel, cases[0].Body, cases));
case State s:
if (data.ResolveState == null)
{
throw new Exception("Tried to compile a State expression outside of an ExpressionGroup");
}
return(data.ResolveState(s));
case ExpressionGroupElement groupElement:
if (!data.GroupCache.TryGetValue(groupElement.Group, out var groupList))
{
data.GroupCache.Add(groupElement.Group, groupList = CompileGroup(groupElement.Group, data));
}
return(groupList[groupElement.Index]);
}
throw new Exception("Unknown expression " + value);
}
private static BinaryExpression GreaterThanOrEqualExpression(ParameterExpression parameter, string propertyName, object value)
{
var(bodyLeft, bodyRight) = GetBodyExpressions(parameter, propertyName, value);
return(SystemExpression.GreaterThanOrEqual(bodyLeft, bodyRight));
}
public static Expression GreaterThanOrEqual(Expression arg0, Expression arg1)
{
return(new Expression(LinqExpression.GreaterThanOrEqual(arg0, arg1)));
}
