v2 for ContainsKey fix

Author: JonathanMagnan

src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs

@@ -1616,20 +1616,11 @@ Expression ParseMemberAccess(Type type, Expression instance)
             {
                 if (instance != null && type != typeof(string))
                 {
-                    Type dictionaryType = TypeHelper.FindGenericType(typeof(IDictionary<,>), type);
-                    if (dictionaryType != null)
-                    {
-                        if(TryParseDictionary(instance, id, type, out var expression))
-                        {
-                            return expression;
-                        }
-                    }
-
                     Type enumerableType = TypeHelper.FindGenericType(typeof(IEnumerable<>), type);
                     if (enumerableType != null)
                     {
                         Type elementType = enumerableType.GetTypeInfo().GetGenericTypeArguments()[0];
-                        return ParseAggregate(instance, elementType, id, errorPos, TypeHelper.FindGenericType(typeof(IQueryable<>), type) != null);
+                        return ParseEnumerable(instance, elementType, id, errorPos, type);
                     }
                 }
 
@@ -1725,32 +1716,19 @@ Expression ParseMemberAccess(Type type, Expression instance)
             throw ParseError(errorPos, Res.UnknownPropertyOrField, id, TypeHelper.GetTypeName(type));
         }
 
-        bool TryParseDictionary(Expression instance, string methodName, Type type, out Expression expression)
+        Expression ParseEnumerable(Expression instance, Type elementType, string methodName, int errorPos, Type type)
         {
-            expression = null;
-
-            Expression[] args = ParseArgumentList();
-
-            if (!_methodFinder.ContainsMethod(typeof(IDictionarySignatures), methodName, false, ref args))
-            {
-                return false;
-            }
-
-            var method = type.GetMethod(methodName);
-            expression = Expression.Call(instance, method, args);
-            return true;
-        }
+            bool isQueryable = TypeHelper.FindGenericType(typeof(IQueryable<>), type) != null;
+            bool isDictionary = TypeHelper.FindGenericType(typeof(IDictionary<,>), type) != null;
 
-        Expression ParseAggregate(Expression instance, Type elementType, string methodName, int errorPos, bool isQueryable)
-        {
             var oldParent = _parent;
 
             ParameterExpression outerIt = _it;
             ParameterExpression innerIt = ParameterExpressionHelper.CreateParameterExpression(elementType, string.Empty, _parsingConfig.RenameEmptyParameterExpressionNames);
 
             _parent = _it;
 
-            if (methodName == "Contains" || methodName == "Skip" || methodName == "Take")
+            if (methodName == "Contains" || methodName == "ContainsKey" || methodName == "Skip" || methodName == "Take")
             {
                 // for any method that acts on the parent element type, we need to specify the outerIt as scope.
                 _it = outerIt;
@@ -1762,6 +1740,12 @@ Expression ParseAggregate(Expression instance, Type elementType, string methodNa
 
             Expression[] args = ParseArgumentList();
 
+            if (isDictionary && _methodFinder.ContainsMethod(typeof(IDictionarySignatures), methodName, false, ref args))
+            {
+                var method = type.GetMethod(methodName);
+                return Expression.Call(instance, method, args);
+            }
+
             _it = outerIt;
             _parent = oldParent;
 
@@ -1800,8 +1784,8 @@ Expression ParseAggregate(Expression instance, Type elementType, string methodNa
             }
             else if (methodName == "SelectMany")
             {
-                var type = Expression.Lambda(args[0], innerIt).Body.Type;
-                var interfaces = type.GetInterfaces().Union(new[] { type });
+                var bodyType = Expression.Lambda(args[0], innerIt).Body.Type;
+                var interfaces = bodyType.GetInterfaces().Union(new[] { bodyType });
                 Type interfaceType = interfaces.Single(i => i.Name == typeof(IEnumerable<>).Name);
                 Type resultType = interfaceType.GetTypeInfo().GetGenericTypeArguments()[0];
                 typeArgs = new[] { elementType, resultType };

test/System.Linq.Dynamic.Core.Tests/MikArea/Dictionary.cs

@@ -63,5 +63,31 @@ public void Test_ContainsKey_2()
             Check.That("ZZZ1").IsEqualTo((string)data.First().City);
             Check.That(3).IsEqualTo(data.Count);
         }
+
+        [Fact]
+        public void Test_ContainsKey_3()
+        {
+            List<Customer> customers = new List<Customer>()
+            {
+                new Customer() { City = "ZZZ1", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() },
+                new Customer() { City = "ZZZ2", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>()  },
+                new Customer() { City = "ZZZ3", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>()  }
+            };
+            customers.ForEach(x => x.Orders.Add(x.City + "TEST1", new Order()));
+            customers.ForEach(x => x.Orders.Add(x.City + "TEST2", new Order()));
+            var noDynamicList = customers
+                .Where(x => x.Orders.Skip(1).First().Key == (x.City + "TEST2"))
+                .OrderBy(x => x.City)
+                .ToList();
+
+            var data = customers.AsQueryable()
+                .Where("Orders.Skip(1).First().Key == (it.City + \"TEST2\")")
+                .OrderBy("City")
+                .Select("new(City as City, Phone)").ToDynamicList();
+
+            Check.That(3).IsEqualTo(noDynamicList.Count);
+            Check.That("ZZZ1").IsEqualTo((string)data.First().City);
+            Check.That(3).IsEqualTo(data.Count);
+        }
     }
 }