Fix IQueryable item type detection (#416)

Author: AlekseyMartynov

net/DevExtreme.AspNet.Data.Tests.EFCore/Include.cs

@@ -0,0 +1,71 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.EFCore {
+
+    public class Include {
+
+        [Table(nameof(Include) + "_" + nameof(Category))]
+        public class Category {
+            [Key]
+            public int CategoryID { get; set; }
+            public string CategoryName { get; set; }
+
+            [InverseProperty(nameof(Include.Product.Category))]
+            public virtual ICollection<Product> Products { get; set; }
+        }
+
+        [Table(nameof(Include) + "_" + nameof(ProductID))]
+        public class Product {
+            [Key]
+            public int ProductID { get; set; }
+            public string ProductName { get; set; }
+            public decimal UnitPrice { get; set; }
+
+            public int? CategoryID { get; set; }
+
+            [ForeignKey(nameof(CategoryID))]
+            [InverseProperty(nameof(Include.Category.Products))]
+            public virtual Category Category { get; set; }
+        }
+
+        [Fact]
+        public async Task Scenario() {
+            await TestDbContext.ExecAsync(context => {
+                var categories = context.Set<Category>();
+                var products = context.Set<Product>();
+
+                var beverages = new Category {
+                    CategoryName = "Beverages"
+                };
+
+                var chai = new Product {
+                    ProductName = "Chai",
+                    UnitPrice = 18,
+                    Category = beverages
+                };
+
+                categories.Add(beverages);
+                products.Add(chai);
+
+                context.SaveChanges();
+
+                Assert.Null(Record.Exception(delegate {
+                    var loadResult = DataSourceLoader.Load(products.Include(p => p.Category), new SampleLoadOptions {
+                        Filter = new[] { "UnitPrice", ">", "15" }
+                    });
+
+                    loadResult.data.Cast<object>().ToArray();
+                }));
+            });
+        }
+
+    }
+
+}

net/DevExtreme.AspNet.Data.Tests.EFCore/TestDbContext.cs

@@ -26,6 +26,9 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) {
 #if !EFCORE1 && !EFCORE2
             modelBuilder.Entity<ExpandLinqSumType.DataItem>();
 #endif
+
+            modelBuilder.Entity<Include.Category>();
+            modelBuilder.Entity<Include.Product>();
         }
 
         public static async Task ExecAsync(Func<TestDbContext, Task> action) {

net/DevExtreme.AspNet.Data/DataSourceExpressionBuilder.cs

@@ -16,8 +16,6 @@ public DataSourceExpressionBuilder(Expression expr, DataSourceLoadContext contex
             Context = context;
         }
 
-        Type ItemType => Expr.Type.GenericTypeArguments[0];
-
         public Expression BuildLoadExpr(bool paginate, IList filterOverride = null, IReadOnlyList<string> selectOverride = null) {
             AddFilter(filterOverride);
             AddSort();
@@ -52,16 +50,16 @@ public Expression BuildGroupCountExpr() {
         void AddFilter(IList filterOverride = null) {
             if(filterOverride != null || Context.HasFilter) {
                 var filterExpr = filterOverride != null && filterOverride.Count < 1
-                    ? Expression.Lambda(Expression.Constant(false), Expression.Parameter(ItemType))
-                    : new FilterExpressionCompiler(ItemType, Context.GuardNulls, Context.UseStringToLower).Compile(filterOverride ?? Context.Filter);
+                    ? Expression.Lambda(Expression.Constant(false), Expression.Parameter(GetItemType()))
+                    : new FilterExpressionCompiler(GetItemType(), Context.GuardNulls, Context.UseStringToLower).Compile(filterOverride ?? Context.Filter);
 
                 Expr = QueryableCall(nameof(Queryable.Where), Expression.Quote(filterExpr));
             }
         }
 
         void AddSort() {
             if(Context.HasAnySort)
-                Expr = new SortExpressionCompiler(ItemType, Context.GuardNulls).Compile(Expr, Context.GetFullSort());
+                Expr = new SortExpressionCompiler(GetItemType(), Context.GuardNulls).Compile(Expr, Context.GetFullSort());
         }
 
         void AddSelect(IReadOnlyList<string> selectOverride = null) {
@@ -79,7 +77,7 @@ void AddPaging() {
 
         void AddRemoteGrouping(bool suppressGroups, bool suppressTotals) {
             var compiler = new RemoteGroupExpressionCompiler(
-                ItemType, Context.GuardNulls, Context.ExpandLinqSumType, Context.CreateAnonTypeNewTweaks(),
+                GetItemType(), Context.GuardNulls, Context.ExpandLinqSumType, Context.CreateAnonTypeNewTweaks(),
                 suppressGroups ? null : Context.Group,
                 suppressTotals ? null : Context.TotalSummary,
                 suppressGroups ? null : Context.GroupSummary
@@ -92,13 +90,27 @@ void AddCount() {
         }
 
         SelectExpressionCompiler CreateSelectCompiler()
-            => new SelectExpressionCompiler(ItemType, Context.GuardNulls, Context.CreateAnonTypeNewTweaks());
+            => new SelectExpressionCompiler(GetItemType(), Context.GuardNulls, Context.CreateAnonTypeNewTweaks());
 
         Expression QueryableCall(string methodName)
-            => Expression.Call(typeof(Queryable), methodName, Expr.Type.GenericTypeArguments, Expr);
+            => Expression.Call(typeof(Queryable), methodName, GetQueryableGenericArguments(), Expr);
 
         Expression QueryableCall(string methodName, Expression arg)
-            => Expression.Call(typeof(Queryable), methodName, Expr.Type.GenericTypeArguments, Expr, arg);
+            => Expression.Call(typeof(Queryable), methodName, GetQueryableGenericArguments(), Expr, arg);
+
+        Type[] GetQueryableGenericArguments() {
+            const string queryable1 = "IQueryable`1";
+            var type = Expr.Type;
+
+            if(type.IsInterface && type.Name == queryable1)
+                return type.GenericTypeArguments;
+
+            return type.GetInterface(queryable1).GenericTypeArguments;
+        }
+
+        Type GetItemType()
+            => GetQueryableGenericArguments().First();
+
     }
 
 }