DataSourceLoader.LoadAsync (#377)

AlekseyMartynov · web-flow · commit 069dd26ebee9 · 2019-08-15T12:17:56.000+03:00
diff --git a/net/DevExtreme.AspNet.Data.Tests.Common/AsyncTestHelper.cs b/net/DevExtreme.AspNet.Data.Tests.Common/AsyncTestHelper.cs
@@ -0,0 +1,52 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests {
+
+    public static class AsyncTestHelper {
+
+        public interface IDataItem {
+            int Value { get; set; }
+        }
+
+        public static IEnumerable<T> CreateTestData<T>(Func<T> itemFactory) where T : IDataItem {
+            for(var i = 1; i <= 3; i++) {
+                var item = itemFactory();
+                item.Value = i;
+                yield return item;
+            }
+        }
+
+        public static async Task RunAsync<T>(IQueryable<T> data) {
+            var loadOptions = new SampleLoadOptions {
+                RequireTotalCount = true,
+                Take = 1,
+                RemoteGrouping = true
+            };
+
+            {
+                var loadResult = await DataSourceLoader.LoadAsync(data, loadOptions);
+                Assert.Equal(3, loadResult.totalCount);
+                Assert.Single(loadResult.data);
+            }
+
+            {
+                loadOptions.TotalSummary = new[] {
+                    new SummaryInfo { SummaryType = "sum", Selector = nameof(IDataItem.Value) }
+                };
+
+                var loadResult = await DataSourceLoader.LoadAsync(data, loadOptions);
+                Assert.Equal(6m, loadResult.summary[0]);
+            }
+
+            Assert.Contains(loadOptions.ExpressionLog, i => i.EndsWith(".Count()"));
+            Assert.Contains(loadOptions.ExpressionLog, i => i.EndsWith(".Take(1)"));
+            Assert.Contains(loadOptions.ExpressionLog, i => i.Contains(".GroupBy"));
+        }
+
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data.Tests.EF6/Async.cs b/net/DevExtreme.AspNet.Data.Tests.EF6/Async.cs
@@ -0,0 +1,29 @@
+﻿using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.EF6 {
+    using DataItem = Async_DataItem;
+
+    public class Async_DataItem : AsyncTestHelper.IDataItem {
+        public int ID { get; set; }
+        public int Value { get; set; }
+    }
+
+    public class Async {
+
+        [Fact]
+        public async Task Scenario() {
+            await TestDbContext.ExecAsync(async context => {
+                var set = context.Set<DataItem>();
+                set.AddRange(AsyncTestHelper.CreateTestData(() => new DataItem()));
+                await context.SaveChangesAsync();
+
+                await AsyncTestHelper.RunAsync(set);
+            });
+        }
+
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data.Tests.EF6/DevExtreme.AspNet.Data.Tests.EF6.csproj b/net/DevExtreme.AspNet.Data.Tests.EF6/DevExtreme.AspNet.Data.Tests.EF6.csproj
@@ -79,6 +79,7 @@
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Async.cs" />
     <Compile Include="AssemblyInfo.cs" />
     <Compile Include="Bug179.cs" />
     <Compile Include="Bug184.cs" />
diff --git a/net/DevExtreme.AspNet.Data.Tests.EF6/TestDbContext.cs b/net/DevExtreme.AspNet.Data.Tests.EF6/TestDbContext.cs
@@ -32,6 +32,7 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder) {
             modelBuilder.Entity<RemoteGroupingStress_DataItem>();
             modelBuilder.Entity<Summary_DataItem>();
             modelBuilder.Entity<PaginateViaPrimaryKey_DataItem>().HasKey(i => new { i.K1, i.K2 });
+            modelBuilder.Entity<Async_DataItem>();
         }
 
         public static async Task ExecAsync(Func<TestDbContext, Task> action) {
diff --git a/net/DevExtreme.AspNet.Data.Tests.EFCore/Async.cs b/net/DevExtreme.AspNet.Data.Tests.EFCore/Async.cs
@@ -0,0 +1,27 @@
+﻿using System;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.EFCore {
+
+    public class Async {
+
+        public class DataItem : AsyncTestHelper.IDataItem {
+            public int ID { get; set; }
+            public int Value { get; set; }
+        }
+
+        [Fact]
+        public async Task Scenario() {
+            await TestDbContext.ExecAsync(async context => {
+                var set = context.Set<DataItem>();
+                set.AddRange(AsyncTestHelper.CreateTestData(() => new DataItem()));
+                await context.SaveChangesAsync();
+
+                await AsyncTestHelper.RunAsync(set);
+            });
+        }
+
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data.Tests.EFCore/TestDbContext.cs b/net/DevExtreme.AspNet.Data.Tests.EFCore/TestDbContext.cs
@@ -21,6 +21,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) {
             modelBuilder.Entity<Bug120.DataItem>();
             modelBuilder.Entity<Bug326.Entity>();
             modelBuilder.Entity<PaginateViaPrimaryKey.DataItem>().HasKey("K1", "K2");
+            modelBuilder.Entity<Async.DataItem>();
         }
 
         public static async Task ExecAsync(Func<TestDbContext, Task> action) {
diff --git a/net/DevExtreme.AspNet.Data.Tests.NH/Async.cs b/net/DevExtreme.AspNet.Data.Tests.NH/Async.cs
@@ -0,0 +1,39 @@
+﻿using FluentNHibernate.Mapping;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.NH {
+
+    public class Async {
+
+        public class DataItem : AsyncTestHelper.IDataItem {
+            public virtual int Id { get; set; }
+            public virtual int Value { get; set; }
+        }
+
+        public class DataItemMap : ClassMap<DataItem> {
+            public DataItemMap() {
+                Table(nameof(Async) + "_" + nameof(DataItem));
+                Id(p => p.Id);
+                Map(p => p.Value);
+            }
+        }
+
+        [Fact]
+        public async Task Scenario() {
+            await SessionFactoryHelper.ExecAsync(async session => {
+                using(var tx = session.BeginTransaction()) {
+                    foreach(var i in AsyncTestHelper.CreateTestData(() => new DataItem()))
+                        session.Save(i);
+                    await tx.CommitAsync();
+                }
+
+                await AsyncTestHelper.RunAsync(session.Query<DataItem>());
+            });
+        }
+
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data.Tests.Xpo/Async.cs b/net/DevExtreme.AspNet.Data.Tests.Xpo/Async.cs
@@ -0,0 +1,30 @@
+﻿using DevExpress.Xpo;
+using System;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.Xpo {
+
+    public class Async {
+
+        [Persistent(nameof(Async) + "_" + nameof(DataItem))]
+        public class DataItem : AsyncTestHelper.IDataItem {
+            [Key(AutoGenerate = true)]
+            public int ID { get; set; }
+            public int Value { get; set; }
+        }
+
+        [Fact]
+        public async Task Scenario() {
+            await UnitOfWorkHelper.ExecAsync(async uow => {
+                foreach(var i in AsyncTestHelper.CreateTestData(() => new DataItem()))
+                    uow.Save(i);
+
+                uow.CommitChanges();
+                await AsyncTestHelper.RunAsync(uow.Query<DataItem>());
+            });
+        }
+
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data.Tests.Xpo/DevExtreme.AspNet.Data.Tests.Xpo.csproj b/net/DevExtreme.AspNet.Data.Tests.Xpo/DevExtreme.AspNet.Data.Tests.Xpo.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="DevExpress.Xpo" Version="18.1.3" />
+    <PackageReference Include="DevExpress.Xpo" Version="18.2.10" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.7.0" />
     <PackageReference Include="xunit" Version="2.3.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
diff --git a/net/DevExtreme.AspNet.Data.Tests.Xpo/UnitOfWorkHelper.cs b/net/DevExtreme.AspNet.Data.Tests.Xpo/UnitOfWorkHelper.cs
@@ -22,7 +22,8 @@ public static async Task ExecAsync(Func<UnitOfWork, Task> action) {
                     typeof(RemoteGroupingStress.DataItem),
                     typeof(Summary.DataItem),
                     typeof(Bug339.DataItem),
-                    typeof(PaginateViaPrimaryKey.DataItem)
+                    typeof(PaginateViaPrimaryKey.DataItem),
+                    typeof(Async.DataItem)
                 );
 
                 var provider = XpoDefault.GetConnectionProvider(
diff --git a/net/DevExtreme.AspNet.Data.Tests/AsyncAdapterTests.cs b/net/DevExtreme.AspNet.Data.Tests/AsyncAdapterTests.cs
@@ -0,0 +1,74 @@
+﻿using DevExtreme.AspNet.Data.Async;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests {
+
+    public class AsyncAdapterTests {
+        readonly IQueryable<int> SAMPLE_DATA = new EnumerableQuery<int>(new int[0]);
+
+        [Fact]
+        public async Task NotSupported() {
+            var error = await Record.ExceptionAsync(async delegate {
+                await DataSourceLoader.LoadAsync(SAMPLE_DATA, new SampleLoadOptions());
+            });
+
+            Assert.True(error is NotSupportedException);
+        }
+
+        [Fact]
+        public async Task Canceled() {
+            var token = new CancellationToken(true);
+
+            async Task Case(DataSourceLoadOptionsBase loadOptions) {
+                var error = await Record.ExceptionAsync(async delegate {
+                    await DataSourceLoader.LoadAsync(SAMPLE_DATA, loadOptions, token);
+                });
+
+                Assert.True(error is OperationCanceledException);
+            }
+
+            await Case(new SampleLoadOptions());
+            await Case(new SampleLoadOptions { IsCountQuery = true });
+        }
+
+        [Fact]
+        public async Task RegisterAdapter() {
+            try {
+                var adapter = new MyAdapter();
+                CustomAsyncAdapters.RegisterAdapter(typeof(EnumerableQuery), adapter);
+
+                await DataSourceLoader.LoadAsync(SAMPLE_DATA, new SampleLoadOptions {
+                    RequireTotalCount = true
+                });
+
+                Assert.True(adapter.CountCalled);
+                Assert.True(adapter.ToEnumerableCalled);
+            } finally {
+                CustomAsyncAdapters.Clear();
+            }
+        }
+
+        class MyAdapter : IAsyncAdapter {
+            public bool
+                CountCalled,
+                ToEnumerableCalled;
+
+            public Task<int> CountAsync(IQueryProvider provider, Expression expr, CancellationToken cancellationToken) {
+                CountCalled = true;
+                return Task.FromResult(provider.Execute<int>(expr));
+            }
+
+            public Task<IEnumerable<T>> ToEnumerableAsync<T>(IQueryProvider provider, Expression expr, CancellationToken cancellationToken) {
+                ToEnumerableCalled = true;
+                return Task.FromResult(provider.CreateQuery<T>(expr).AsEnumerable());
+            }
+        }
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data/Async/AsyncHelper.cs b/net/DevExtreme.AspNet.Data/Async/AsyncHelper.cs
@@ -0,0 +1,38 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace DevExtreme.AspNet.Data.Async {
+
+    class AsyncHelper {
+        readonly IQueryProvider Provider;
+        readonly QueryProviderInfo ProviderInfo;
+        readonly CancellationToken CancellationToken;
+
+        public AsyncHelper(IQueryProvider provider, QueryProviderInfo providerInfo, CancellationToken cancellationToken) {
+            Provider = provider;
+            ProviderInfo = providerInfo;
+            CancellationToken = cancellationToken;
+        }
+
+        public Task<int> CountAsync(Expression expr) {
+            CancellationToken.ThrowIfCancellationRequested();
+            return CreateAdapter().CountAsync(Provider, expr, CancellationToken);
+        }
+
+        public Task<IEnumerable<T>> ToEnumerableAsync<T>(Expression expr) {
+            CancellationToken.ThrowIfCancellationRequested();
+            return CreateAdapter().ToEnumerableAsync<T>(Provider, expr, CancellationToken);
+        }
+
+        IAsyncAdapter CreateAdapter() {
+            return CustomAsyncAdapters.GetAdapter(Provider.GetType())
+                ?? new ReflectionAsyncAdapter(ProviderInfo);
+        }
+
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data/Async/CustomAsyncAdapters.cs b/net/DevExtreme.AspNet.Data/Async/CustomAsyncAdapters.cs
@@ -0,0 +1,34 @@
+﻿using System;
+using System.Linq;
+using System.Collections.Generic;
+
+namespace DevExtreme.AspNet.Data.Async {
+    using RegisteredAdapters = List<Tuple<Func<Type, bool>, IAsyncAdapter>>;
+
+    public static class CustomAsyncAdapters {
+        static readonly RegisteredAdapters _registeredAdapters = new RegisteredAdapters();
+
+        public static void RegisterAdapter(Func<Type, bool> queryProviderTypePredicate, IAsyncAdapter adapter) {
+            _registeredAdapters.Add(Tuple.Create(queryProviderTypePredicate, adapter));
+        }
+
+        public static void RegisterAdapter(Type queryProviderType, IAsyncAdapter adapter) {
+            RegisterAdapter(type => queryProviderType.IsAssignableFrom(type), adapter);
+        }
+
+        internal static IAsyncAdapter GetAdapter(Type queryProviderType) {
+            foreach(var i in _registeredAdapters) {
+                if(i.Item1(queryProviderType))
+                    return i.Item2;
+            }
+            return null;
+        }
+
+#if DEBUG
+        internal static void Clear() {
+            _registeredAdapters.Clear();
+        }
+#endif
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data/Async/IAsyncAdapter.cs b/net/DevExtreme.AspNet.Data/Async/IAsyncAdapter.cs
@@ -0,0 +1,15 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace DevExtreme.AspNet.Data.Async {
+
+    public interface IAsyncAdapter {
+        Task<int> CountAsync(IQueryProvider queryProvider, Expression expr, CancellationToken cancellationToken);
+        Task<IEnumerable<T>> ToEnumerableAsync<T>(IQueryProvider queryProvider, Expression expr, CancellationToken cancellationToken);
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data/Async/ReflectionAsyncAdapter.cs b/net/DevExtreme.AspNet.Data/Async/ReflectionAsyncAdapter.cs
diff --git a/net/DevExtreme.AspNet.Data/DataSourceLoader.cs b/net/DevExtreme.AspNet.Data/DataSourceLoader.cs
diff --git a/net/DevExtreme.AspNet.Data/DataSourceLoaderImpl.cs b/net/DevExtreme.AspNet.Data/DataSourceLoaderImpl.cs
diff --git a/net/DevExtreme.AspNet.Data/QueryProviderInfo.cs b/net/DevExtreme.AspNet.Data/QueryProviderInfo.cs
diff --git a/net/Sample/Controllers/NorthwindController.cs b/net/Sample/Controllers/NorthwindController.cs

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder) {`
`32`	`32`	`modelBuilder.Entity<RemoteGroupingStress_DataItem>();`
`33`	`33`	`modelBuilder.Entity<Summary_DataItem>();`
`34`	`34`	`modelBuilder.Entity<PaginateViaPrimaryKey_DataItem>().HasKey(i => new { i.K1, i.K2 });`
	`35`	`+ modelBuilder.Entity<Async_DataItem>();`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`public static async Task ExecAsync(Func<TestDbContext, Task> action) {`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) {`
`21`	`21`	`modelBuilder.Entity<Bug120.DataItem>();`
`22`	`22`	`modelBuilder.Entity<Bug326.Entity>();`
`23`	`23`	`modelBuilder.Entity<PaginateViaPrimaryKey.DataItem>().HasKey("K1", "K2");`
	`24`	`+ modelBuilder.Entity<Async.DataItem>();`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`public static async Task ExecAsync(Func<TestDbContext, Task> action) {`