Code improvements of "in" filtering

Author: Milos

src/JsonApiDotNetCore/Extensions/IQueryableExtensions.cs

@@ -12,6 +12,23 @@ namespace JsonApiDotNetCore.Extensions
     // ReSharper disable once InconsistentNaming
     public static class IQueryableExtensions
     {
+        private static MethodInfo _containsMethod;
+        private static MethodInfo ContainsMethod
+        {
+            get
+            {
+                if (_containsMethod == null)
+                {
+                    _containsMethod = typeof(Enumerable)
+                      .GetMethods(BindingFlags.Static | BindingFlags.Public)
+                      .Where(m => m.Name == nameof(Enumerable.Contains) && m.GetParameters().Count() == 2)
+                      .First();
+                }
+                return _containsMethod;
+            }
+        }
+
+
         public static IQueryable<TSource> Sort<TSource>(this IQueryable<TSource> source, List<SortQuery> sortQueries)
         {
             if (sortQueries == null || sortQueries.Count == 0)
@@ -238,17 +255,7 @@ private static Expression<Func<TSource, bool>> ArrayContainsPredicate<TSource>(s
             else
                 member = Expression.Property(entity, fieldname);
 
-            var containsMethods = typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public).Where(m => m.Name == "Contains");
-            MethodInfo method = null;
-            foreach (var m in containsMethods)
-            {
-                if (m.GetParameters().Count() == 2)
-                {
-                    method = m;
-                    break;
-                }
-            }
-            method = method.MakeGenericMethod(member.Type);
+            var method = ContainsMethod.MakeGenericMethod(member.Type);
             var obj = TypeHelper.ConvertListType(propertyValues, member.Type);
 
             var exprContains = Expression.Call(method, new Expression[] { Expression.Constant(obj), member });

src/JsonApiDotNetCore/Internal/TypeHelper.cs

@@ -63,19 +63,15 @@ public static T ConvertType<T>(object value)
         /// <param name="values">Collection like ["10","20","30"]</param>
         /// <param name="type">Non array type. For e.g. int</param>
         /// <returns>Collection of concrete type</returns>
-        public static object ConvertListType(IEnumerable<string> values, Type type)
+        public static IList ConvertListType(IEnumerable<string> values, Type type)
         {
-            var convertedArray = new List<object>();
-            foreach (var value in values)
-            {
-                convertedArray.Add(ConvertType(value, type));
-            }
             var listType = typeof(List<>).MakeGenericType(type);
             IList list = (IList)Activator.CreateInstance(listType);
-            foreach (var item in convertedArray)
+            foreach (var value in values)
             {
-                list.Add(item);
+                list.Add(ConvertType(value, type));
             }
+
             return list;
         }
     }

src/JsonApiDotNetCore/Services/QueryParser.cs

@@ -85,8 +85,8 @@ protected virtual List<FilterQuery> ParseFilterQuery(string key, string value)
             var propertyName = key.Split(QueryConstants.OPEN_BRACKET, QueryConstants.CLOSE_BRACKET)[1];
 
             // InArray case
-            var op = GetFilterOperation(value);
-            if (op == FilterOperations.@in.ToString())
+            string op = GetFilterOperation(value);
+            if (string.Equals(op, FilterOperations.@in.ToString(), StringComparison.OrdinalIgnoreCase))
             {
                 (var operation, var filterValue) = ParseFilterOperation(value);
                 queries.Add(new FilterQuery(propertyName, filterValue, op));
@@ -232,16 +232,17 @@ protected virtual AttrAttribute GetAttribute(string propertyName)
 
         private string GetFilterOperation(string value)
         {
-            var operation = value.Split(QueryConstants.COLON);
+            var values = value.Split(QueryConstants.COLON);
 
-            if (operation.Length == 1)
+            if (values.Length == 1)
                 return string.Empty;
 
+            var operation = values[0];
             // remove prefix from value
-            if (Enum.TryParse(operation[0], out FilterOperations op) == false)
+            if (Enum.TryParse(operation, out FilterOperations op) == false)
                 return string.Empty;
 
-            return operation[0];
+            return operation;
         }
 
         private FilterQuery BuildFilterQuery(ReadOnlySpan<char> query, string propertyName)

test/JsonApiDotNetCoreExampleTests/Acceptance/Spec/AttributeFilterTests.cs

@@ -139,12 +139,17 @@ public async Task Can_Filter_On_In_Array_Values()
         {
             // arrange
             var context = _fixture.GetService<AppDbContext>();
-            var todoItems = _todoItemFaker.Generate(3);
+            var todoItems = _todoItemFaker.Generate(5);
             var guids = new List<Guid>();
+            var notInGuids = new List<Guid>();
             foreach (var item in todoItems)
             {
                 context.TodoItems.Add(item);
-                guids.Add(item.GuidProperty);
+                // Exclude 2 items
+                if (guids.Count < (todoItems.Count() - 2))
+                    guids.Add(item.GuidProperty);
+                else 
+                    notInGuids.Add(item.GuidProperty);
             }
             context.SaveChanges();
 
@@ -164,7 +169,10 @@ public async Task Can_Filter_On_In_Array_Values()
             Assert.Equal(HttpStatusCode.OK, response.StatusCode);
             Assert.Equal(guids.Count(), deserializedTodoItems.Count());
             foreach (var item in deserializedTodoItems)
+            {
                 Assert.True(guids.Contains(item.GuidProperty));
+                Assert.False(notInGuids.Contains(item.GuidProperty));
+            }
         }
 
         [Fact]