Refactoring: Inline AsyncHelper into ExpressionExecutor (#405)

Author: AlekseyMartynov

net/DevExtreme.AspNet.Data/Async/AsyncHelper.cs

@@ -0,0 +1,25 @@
+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 AsyncOverSyncAdapter : IAsyncAdapter {
+        public static readonly IAsyncAdapter Instance = new AsyncOverSyncAdapter();
+
+        private AsyncOverSyncAdapter() {
+        }
+
+        // NOTE on Task.FromResult vs. Task.Run https://stackoverflow.com/a/34005461
+
+        Task<int> IAsyncAdapter.CountAsync(IQueryProvider queryProvider, Expression expr, CancellationToken _)
+            => Task.FromResult(queryProvider.Execute<int>(expr));
+
+        Task<IEnumerable<T>> IAsyncAdapter.ToEnumerableAsync<T>(IQueryProvider queryProvider, Expression expr, CancellationToken _)
+            => Task.FromResult(queryProvider.CreateQuery<T>(expr).AsEnumerable());
+    }
+
+}

net/DevExtreme.AspNet.Data/Async/AsyncOverSyncAdapter.cs

@@ -136,15 +136,11 @@ static Task<int> InvokeCountAsync(MethodInfo method, IQueryProvider provider, Ex
             return (Task<int>)InvokeQueryExtensionMethod(method, query.ElementType, query, cancellationToken);
         }
 
-        static Task<IEnumerable<T>> InvokeToArrayAsync<T>(MethodInfo method, IQueryProvider provider, Expression expr, CancellationToken cancellationToken) {
-            var arrayTask = (Task<T[]>)InvokeQueryExtensionMethod(method, typeof(T), provider.CreateQuery(expr), cancellationToken);
-            return arrayTask.ContinueWith(t => (IEnumerable<T>)t.Result);
-        }
+        async static Task<IEnumerable<T>> InvokeToArrayAsync<T>(MethodInfo method, IQueryProvider provider, Expression expr, CancellationToken cancellationToken)
+            => await (Task<T[]>)InvokeQueryExtensionMethod(method, typeof(T), provider.CreateQuery(expr), cancellationToken);
 
-        static Task<IEnumerable<T>> InvokeToListAsync<T>(MethodInfo method, IQueryProvider provider, Expression expr, CancellationToken cancellationToken) {
-            var listTask = (Task<List<T>>)InvokeQueryExtensionMethod(method, typeof(T), provider.CreateQuery(expr), cancellationToken);
-            return listTask.ContinueWith(t => (IEnumerable<T>)t.Result);
-        }
+        async static Task<IEnumerable<T>> InvokeToListAsync<T>(MethodInfo method, IQueryProvider provider, Expression expr, CancellationToken cancellationToken)
+            => await (Task<List<T>>)InvokeQueryExtensionMethod(method, typeof(T), provider.CreateQuery(expr), cancellationToken);
 
         static object InvokeQueryExtensionMethod(MethodInfo method, Type elementType, IQueryable query, CancellationToken cancellationToken) {
             return method

net/DevExtreme.AspNet.Data/Async/ReflectionAsyncAdapter.cs

@@ -17,25 +17,20 @@ namespace DevExtreme.AspNet.Data {
 
     class DataSourceLoaderImpl<S> {
         readonly IQueryable<S> Source;
-
-        readonly CancellationToken CancellationToken;
-        readonly bool Sync;
-
-        readonly QueryProviderInfo ProviderInfo;
         readonly DataSourceLoadContext Context;
+        readonly Func<Expression, ExpressionExecutor> CreateExecutor;
 
 #if DEBUG
         readonly Action<Expression> ExpressionWatcher;
         readonly bool UseEnumerableOnce;
 #endif
 
         public DataSourceLoaderImpl(IQueryable<S> source, DataSourceLoadOptionsBase options, CancellationToken cancellationToken, bool sync) {
-            Source = source;
-            CancellationToken = cancellationToken;
-            Sync = sync;
+            var providerInfo = new QueryProviderInfo(source.Provider);
 
-            ProviderInfo = new QueryProviderInfo(source.Provider);
-            Context = new DataSourceLoadContext(options, ProviderInfo, typeof(S));
+            Source = source;
+            Context = new DataSourceLoadContext(options, providerInfo, typeof(S));
+            CreateExecutor = expr => new ExpressionExecutor(Source.Provider, expr, providerInfo, cancellationToken, sync);
 
 #if DEBUG
             ExpressionWatcher = options.ExpressionWatcher;
@@ -170,7 +165,7 @@ Task<int> ExecCountAsync(Expression expr) {
             ExpressionWatcher?.Invoke(expr);
 #endif
 
-            var executor = new ExpressionExecutor(Source.Provider, expr, CancellationToken, Sync);
+            var executor = CreateExecutor(expr);
 
             if(Context.RequireQueryableChainBreak)
                 executor.BreakQueryableChain();
@@ -197,7 +192,7 @@ async Task<IEnumerable<R>> ExecExprAsync<R>(Expression expr) {
             ExpressionWatcher?.Invoke(expr);
 #endif
 
-            var executor = new ExpressionExecutor(Source.Provider, expr, CancellationToken, Sync);
+            var executor = CreateExecutor(expr);
 
             if(Context.RequireQueryableChainBreak)
                 executor.BreakQueryableChain();

net/DevExtreme.AspNet.Data/DataSourceLoaderImpl.cs

@@ -12,14 +12,17 @@ class ExpressionExecutor {
         IQueryProvider Provider;
         Expression Expr;
 
+        readonly QueryProviderInfo ProviderInfo;
         readonly CancellationToken CancellationToken;
         readonly bool Sync;
 
-        public ExpressionExecutor(IQueryProvider provider, Expression expr, CancellationToken cancellationToken, bool sync) {
+        public ExpressionExecutor(IQueryProvider provider, Expression expr, QueryProviderInfo providerInfo, CancellationToken cancellationToken, bool sync) {
             Provider = provider;
             Expr = expr;
-            Sync = sync;
+
+            ProviderInfo = providerInfo;
             CancellationToken = cancellationToken;
+            Sync = sync;
         }
 
         public void BreakQueryableChain() {
@@ -48,20 +51,23 @@ public void BreakQueryableChain() {
         }
 
         public Task<IEnumerable<T>> ToEnumerableAsync<T>() {
-            if(!Sync)
-                return CreateAsyncHelper().ToEnumerableAsync<T>(Expr);
-
-            return Task.FromResult((IEnumerable<T>)Provider.CreateQuery<T>(Expr));
+            CancellationToken.ThrowIfCancellationRequested();
+            return CreateAsyncAdapter().ToEnumerableAsync<T>(Provider, Expr, CancellationToken);
         }
 
         public Task<int> CountAsync() {
-            if(!Sync)
-                return CreateAsyncHelper().CountAsync(Expr);
+            CancellationToken.ThrowIfCancellationRequested();
+            return CreateAsyncAdapter().CountAsync(Provider, Expr, CancellationToken);
+        }
+
+        IAsyncAdapter CreateAsyncAdapter() {
+            if(Sync)
+                return AsyncOverSyncAdapter.Instance;
 
-            return Task.FromResult(Provider.Execute<int>(Expr));
+            return CustomAsyncAdapters.GetAdapter(Provider.GetType())
+                ?? new ReflectionAsyncAdapter(ProviderInfo);
         }
 
-        AsyncHelper CreateAsyncHelper() => new AsyncHelper(Provider, new QueryProviderInfo(Provider), CancellationToken);
     }
 
 }