AllowAsyncOverSync option (#399)

Author: AlekseyMartynov

net/DevExtreme.AspNet.Data.Tests/AsyncAdapterTests.cs

@@ -21,6 +21,17 @@ public async Task NotSupported() {
             Assert.True(error is NotSupportedException);
         }
 
+        [Fact]
+        public async Task AllowAsyncOverSync() {
+            var error = await Record.ExceptionAsync(async delegate {
+                await DataSourceLoader.LoadAsync(SAMPLE_DATA, new SampleLoadOptions {
+                    AllowAsyncOverSync = true
+                });
+            });
+
+            Assert.Null(error);
+        }
+
         [Fact]
         public async Task Canceled() {
             var token = new CancellationToken(true);

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

@@ -9,62 +9,55 @@
 namespace DevExtreme.AspNet.Data.Async {
 
     class ReflectionAsyncAdapter : IAsyncAdapter {
-        QueryProviderInfo _providerInfo;
+        readonly QueryProviderInfo _providerInfo;
+
+        public static bool SupportsProvider(QueryProviderInfo providerInfo)
+            => providerInfo.IsEFCore
+            || IsEF6(providerInfo)
+            || providerInfo.IsNH
+            || providerInfo.IsXPO;
+
+        static bool IsEF6(QueryProviderInfo providerInfo)
+            => providerInfo.IsEFClassic && providerInfo.Version.Major >= 6;
 
         public ReflectionAsyncAdapter(QueryProviderInfo providerInfo) {
             _providerInfo = providerInfo;
         }
 
-        bool IsEF6 => _providerInfo.IsEFClassic && _providerInfo.Version.Major >= 6;
-        bool IsEFCore => _providerInfo.IsEFCore;
-        bool IsNH => _providerInfo.IsNH;
-        bool IsXPO => _providerInfo.IsXPO;
-
         public Task<int> CountAsync(IQueryProvider provider, Expression expr, CancellationToken cancellationToken) {
             MethodInfo GetCountAsyncMethod() {
-                if(IsEFCore)
+                if(_providerInfo.IsEFCore)
                     return EFCoreMethods.CountAsyncMethod;
 
-                if(IsEF6)
+                if(IsEF6(_providerInfo))
                     return EF6Methods.CountAsyncMethod;
 
-                if(IsNH)
+                if(_providerInfo.IsNH)
                     return NHMethods.CountAsyncMethod;
 
-                if(IsXPO)
+                if(_providerInfo.IsXPO)
                     return XpoMethods.CountAsyncMethod;
 
-                throw ProviderNotSupported(provider);
+                throw new NotSupportedException();
             }
 
             return InvokeCountAsync(GetCountAsyncMethod(), provider, expr, cancellationToken);
         }
 
         public Task<IEnumerable<T>> ToEnumerableAsync<T>(IQueryProvider provider, Expression expr, CancellationToken cancellationToken) {
-            if(IsEFCore)
+            if(_providerInfo.IsEFCore)
                 return InvokeToListAsync<T>(EFCoreMethods.ToListAsyncMethod, provider, expr, cancellationToken);
 
-            if(IsEF6)
+            if(IsEF6(_providerInfo))
                 return InvokeToListAsync<T>(EF6Methods.ToListAsyncMethod, provider, expr, cancellationToken);
 
-            if(IsNH)
+            if(_providerInfo.IsNH)
                 return InvokeToListAsync<T>(NHMethods.ToListAsyncMethod, provider, expr, cancellationToken);
 
-            if(IsXPO)
+            if(_providerInfo.IsXPO)
                 return InvokeToArrayAsync<T>(XpoMethods.ToArrayAsyncMethod, provider, expr, cancellationToken);
 
-            throw ProviderNotSupported(provider);
-        }
-
-        static Exception ProviderNotSupported(IQueryProvider provider) {
-            var providerType = provider.GetType();
-            if(providerType.IsGenericType)
-                providerType = providerType.GetGenericTypeDefinition();
-
-            var message = $"Async operations for the LINQ provider '{providerType.FullName}' are not supported."
-                + $" You can implement a custom async adapter ({typeof(IAsyncAdapter).FullName}) and register it via '{typeof(CustomAsyncAdapters).FullName}.{nameof(CustomAsyncAdapters.RegisterAdapter)}'.";
-
-            return new NotSupportedException(message);
+            throw new NotSupportedException();
         }
 
         static class EF6Methods {

net/DevExtreme.AspNet.Data/DataSourceLoadOptionsBase.cs

@@ -110,6 +110,8 @@ public class DataSourceLoadOptionsBase {
         /// </summary>
         public bool? PaginateViaPrimaryKey { get; set; }
 
+        public bool AllowAsyncOverSync { get; set; }
+
 #if DEBUG
         internal Action<Expression> ExpressionWatcher;
         internal bool UseEnumerableOnce;

net/DevExtreme.AspNet.Data/DataSourceLoaderImpl.cs

@@ -30,7 +30,7 @@ public DataSourceLoaderImpl(IQueryable source, DataSourceLoadOptionsBase options
 
             Source = source;
             Context = new DataSourceLoadContext(options, providerInfo, Source.ElementType);
-            CreateExecutor = expr => new ExpressionExecutor(Source.Provider, expr, providerInfo, cancellationToken, sync);
+            CreateExecutor = expr => new ExpressionExecutor(Source.Provider, expr, providerInfo, cancellationToken, sync, options.AllowAsyncOverSync);
 
 #if DEBUG
             ExpressionWatcher = options.ExpressionWatcher;

net/DevExtreme.AspNet.Data/ExpressionExecutor.cs

@@ -15,14 +15,16 @@ class ExpressionExecutor {
         readonly QueryProviderInfo ProviderInfo;
         readonly CancellationToken CancellationToken;
         readonly bool Sync;
+        readonly bool AllowAsyncOverSync;
 
-        public ExpressionExecutor(IQueryProvider provider, Expression expr, QueryProviderInfo providerInfo, CancellationToken cancellationToken, bool sync) {
+        public ExpressionExecutor(IQueryProvider provider, Expression expr, QueryProviderInfo providerInfo, CancellationToken cancellationToken, bool sync, bool allowAsyncOverSync) {
             Provider = provider;
             Expr = expr;
 
             ProviderInfo = providerInfo;
             CancellationToken = cancellationToken;
             Sync = sync;
+            AllowAsyncOverSync = allowAsyncOverSync;
         }
 
         public void BreakQueryableChain() {
@@ -64,8 +66,29 @@ IAsyncAdapter CreateAsyncAdapter() {
             if(Sync)
                 return AsyncOverSyncAdapter.Instance;
 
-            return CustomAsyncAdapters.GetAdapter(Provider.GetType())
-                ?? new ReflectionAsyncAdapter(ProviderInfo);
+            var providerType = Provider.GetType();
+
+            var customAdapter = CustomAsyncAdapters.GetAdapter(providerType);
+            if(customAdapter != null)
+                return customAdapter;
+
+            if(ReflectionAsyncAdapter.SupportsProvider(ProviderInfo))
+                return new ReflectionAsyncAdapter(ProviderInfo);
+
+            if(AllowAsyncOverSync)
+                return AsyncOverSyncAdapter.Instance;
+
+            throw ProviderNotSupported(providerType);
+        }
+
+        static Exception ProviderNotSupported(Type providerType) {
+            if(providerType.IsGenericType)
+                providerType = providerType.GetGenericTypeDefinition();
+
+            var message = $"Async operations for the LINQ provider '{providerType.FullName}' are not supported."
+                + $" You can implement a custom async adapter ({typeof(IAsyncAdapter).FullName}) and register it via '{typeof(CustomAsyncAdapters).FullName}.{nameof(CustomAsyncAdapters.RegisterAdapter)}'.";
+
+            return new NotSupportedException(message);
         }
 
     }