Support comparison operations for enums (#344)

Author: AlekseyMartynov

net/DevExtreme.AspNet.Data.Tests/FilterExpressionCompilerTests.cs

@@ -317,6 +317,32 @@ public void GuidComparison() {
             );
         }
 
+
+        [Fact]
+        public void EnumComparison() {
+            // https://github.com/DevExpress/DevExtreme.AspNet.Data/issues/164
+
+            Assert.Equal(
+                "(obj.CompareTo(Monday) > 0)",
+                Compile<DayOfWeek>(new object[] { "this", ">", DayOfWeek.Monday }).Body.ToString()
+            );
+
+            Assert.Equal(
+                "(obj.Value.CompareTo(Tuesday) < 0)",
+                Compile<DayOfWeek?>(new object[] { "this", "<", DayOfWeek.Tuesday }).Body.ToString()
+            );
+
+            Assert.Equal(
+                "IIF((obj == null), False, (obj.Value.CompareTo(Wednesday) >= 0))",
+                Compile<DayOfWeek?>(new object[] { "this", ">=", DayOfWeek.Wednesday }, true).Body.ToString()
+            );
+
+            Assert.Equal(
+                "False",
+                Compile<DayOfWeek?>(new[] { "this", "<=", null }).Body.ToString()
+            );
+        }
+
     }
 
 }

net/DevExtreme.AspNet.Data/FilterExpressionCompiler.cs

@@ -88,8 +88,17 @@ Expression CompileBinary(ParameterExpression dataItemExpr, IList criteriaJson) {
                 if(_stringToLower && clientValue is String)
                     clientValue = ((string)clientValue).ToLower();
 
-                if((accessorExpr.Type == typeof(Guid) || accessorExpr.Type == typeof(Guid?)) && IsInequality(expressionType))
-                    return CompileGuidComparison(accessorExpr, expressionType, clientValue);
+                if(IsInequality(expressionType)) {
+                    if(accessorExpr.Type == typeof(Guid) || accessorExpr.Type == typeof(Guid?)) {
+                        var method = typeof(Guid).GetMethod(nameof(Guid.CompareTo), new[] { typeof(Guid) });
+                        return CompileCompareToCall(accessorExpr, expressionType, clientValue, method);
+                    }
+
+                    if(Utils.StripNullableType(accessorExpr.Type).IsEnum) {
+                        var method = typeof(Enum).GetMethod(nameof(Enum.CompareTo), new[] { typeof(object) });
+                        return CompileCompareToCall(accessorExpr, expressionType, clientValue, method);
+                    }
+                }
 
                 Expression valueExpr = Expression.Constant(clientValue, accessorExpr.Type);
 
@@ -120,16 +129,16 @@ bool IsInequality(ExpressionType type) {
             return type == ExpressionType.LessThan || type == ExpressionType.LessThanOrEqual || type == ExpressionType.GreaterThanOrEqual || type == ExpressionType.GreaterThan;
         }
 
-        Expression CompileGuidComparison(Expression accessorExpr, ExpressionType expressionType, object clientValue) {
+        Expression CompileCompareToCall(Expression accessorExpr, ExpressionType expressionType, object clientValue, MethodInfo compareToMethod) {
             if(clientValue == null)
                 return Expression.Constant(false);
 
             var result = Expression.MakeBinary(
                 expressionType,
                 Expression.Call(
                     Utils.IsNullable(accessorExpr.Type) ? Expression.Property(accessorExpr, "Value") : accessorExpr,
-                    typeof(Guid).GetMethod(nameof(Guid.CompareTo), new[] { typeof(Guid) }),
-                    Expression.Constant(clientValue, typeof(Guid))
+                    compareToMethod,
+                    Expression.Constant(clientValue, compareToMethod.GetParameters()[0].ParameterType)
                 ),
                 Expression.Constant(0)
             );