Merge branch 'dev' into Upgade-NPM-dependencies-to-latest-versions-

apiSpec/Microsoft_AspNetCore_Routing_AbpEndpointRouterOptions.md

@@ -1,7 +1,5 @@
----
 uid: Microsoft.AspNetCore.Routing.AbpEndpointRouterOptions
 summary: '*Summary test'
----
 
 *Information Test*
 

framework/src/Volo.Abp.AspNetCore.Mvc.UI.Theme.Shared/Pages/Shared/Components/AbpPageSearchBox/Default.cshtml

@@ -6,7 +6,7 @@
         <input class="form-control page-search-filter-text" placeholder="@L["Search"].Value">
         <div class="input-group-append">
             <abp-button button-type="Primary" type="submit">
-                <i class="fa fa-search" aria-hidden="true"></i>
+                <i class="fa fa-search" aria-hidden="true" style="margin-left: 10%; margin-top:50%;" ></i>
             </abp-button>
         </div>
     </div>

framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/EfCoreAsyncQueryableProvider.cs

@@ -1,5 +1,7 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
@@ -16,19 +18,332 @@ namespace Volo.Abp.EntityFrameworkCore
             return queryable.Provider is EntityQueryProvider;
         }
 
+        public Task<bool> ContainsAsync<T>(IQueryable<T> queryable, T item, CancellationToken cancellationToken = default)
+        {
+            return queryable.ContainsAsync(item, cancellationToken);
+        }
+
+        public Task<bool> AnyAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return queryable.AnyAsync(predicate, cancellationToken);
+        }
+
+        public Task<bool> AllAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return queryable.AllAsync(predicate, cancellationToken);
+        }
+
         public Task<int> CountAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
         {
             return queryable.CountAsync(cancellationToken);
         }
 
-        public Task<List<T>> ToListAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        public Task<int> CountAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
         {
-            return queryable.ToListAsync(cancellationToken);
+            return queryable.CountAsync(predicate, cancellationToken);
+        }
+
+        public Task<long> LongCountAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.LongCountAsync(cancellationToken);
+        }
+
+        public Task<long> LongCountAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return queryable.LongCountAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> FirstAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.FirstAsync(cancellationToken);
+        }
+
+        public Task<T> FirstAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return queryable.FirstAsync(predicate, cancellationToken);
         }
 
         public Task<T> FirstOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
         {
             return queryable.FirstOrDefaultAsync(cancellationToken);
         }
+
+        public Task<T> FirstOrDefaultAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+        {
+            return queryable.FirstOrDefaultAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> LastAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.LastAsync(cancellationToken);
+        }
+
+        public Task<T> LastAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return queryable.LastAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> LastOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.LastOrDefaultAsync(cancellationToken);
+        }
+
+        public Task<T> LastOrDefaultAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+        {
+            return queryable.LastOrDefaultAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> SingleAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SingleAsync(cancellationToken);
+        }
+
+        public Task<T> SingleAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return queryable.SingleAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> SingleOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SingleOrDefaultAsync(cancellationToken);
+        }
+
+        public Task<T> SingleOrDefaultAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+        {
+            return queryable.SingleOrDefaultAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> MinAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.MinAsync(cancellationToken);
+        }
+
+        public Task<TResult> MinAsync<T, TResult>(IQueryable<T> queryable, Expression<Func<T, TResult>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.MinAsync(selector, cancellationToken);
+        }
+
+        public Task<T> MaxAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.MaxAsync(cancellationToken);
+        }
+
+        public Task<TResult> MaxAsync<T, TResult>(IQueryable<T> queryable, Expression<Func<T, TResult>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.MaxAsync(selector, cancellationToken);
+        }
+
+        public Task<decimal> SumAsync(IQueryable<decimal> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<decimal?> SumAsync(IQueryable<decimal?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<decimal> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<decimal?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<int> SumAsync(IQueryable<int> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<int?> SumAsync(IQueryable<int?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<int> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, int>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<int?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, int?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<long> SumAsync(IQueryable<long> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<long?> SumAsync(IQueryable<long?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<long> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, long>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<long?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, long?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<double> SumAsync(IQueryable<double> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<double?> SumAsync(IQueryable<double?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<double> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, double>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<double?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, double?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<float> SumAsync(IQueryable<float> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<float?> SumAsync(IQueryable<float?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(cancellationToken);
+        }
+
+        public Task<float> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, float>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<float?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, float?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.SumAsync(selector, cancellationToken);
+        }
+
+        public Task<decimal> AverageAsync(IQueryable<decimal> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<decimal?> AverageAsync(IQueryable<decimal?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<decimal> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<decimal?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double> AverageAsync(IQueryable<int> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<double?> AverageAsync(IQueryable<int?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, int>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, int?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double> AverageAsync(IQueryable<long> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<double?> AverageAsync(IQueryable<long?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, long>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, long?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double> AverageAsync(IQueryable<double> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<double?> AverageAsync(IQueryable<double?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, double>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, double?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<float> AverageAsync(IQueryable<float> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<float?> AverageAsync(IQueryable<float?> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(cancellationToken);
+        }
+
+        public Task<float> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, float>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<float?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, float?>> selector, CancellationToken cancellationToken = default)
+        {
+            return queryable.AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<List<T>> ToListAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.ToListAsync(cancellationToken);
+        }
+
+        public Task<T[]> ToArrayAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return queryable.ToArrayAsync(cancellationToken);
+        }
     }
-}
+}

framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/Uow/EntityFrameworkCore/EfCoreDatabaseApi.cs

@@ -18,10 +18,5 @@ namespace Volo.Abp.Uow.EntityFrameworkCore
         {
             return DbContext.SaveChangesAsync(cancellationToken);
         }
-
-        public void SaveChanges()
-        {
-            DbContext.SaveChanges();
-        }
     }
 }

framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/Uow/EntityFrameworkCore/EfCoreTransactionApi.cs

@@ -21,7 +21,13 @@ namespace Volo.Abp.Uow.EntityFrameworkCore
             AttendedDbContexts = new List<IEfCoreDbContext>();
         }
 
-        public void Commit()
+        public Task CommitAsync()
+        {
+            Commit();
+            return Task.CompletedTask;
+        }
+        
+        protected void Commit()
         {
             DbContextTransaction.Commit();
 
@@ -36,12 +42,6 @@ namespace Volo.Abp.Uow.EntityFrameworkCore
             }
         }
 
-        public Task CommitAsync()
-        {
-            Commit();
-            return Task.CompletedTask;
-        }
-
         public void Dispose()
         {
             DbContextTransaction.Dispose();

framework/src/Volo.Abp.Http.Client/Microsoft/Extensions/DependencyInjection/ServiceCollectionDynamicHttpClientProxyExtensions.cs

@@ -45,11 +45,8 @@ namespace Microsoft.Extensions.DependencyInjection
             AddHttpClientFactoryAndPolicy(services, remoteServiceConfigurationName, configureHttpClientBuilder);
 
             //TODO: Make a configuration option and add remoteServiceName inside it!
-            //TODO: Add option to change type filter
 
-            var serviceTypes = assembly.GetTypes().Where(t =>
+            var serviceTypes = assembly.GetTypes().Where(IsSuitableForDynamicClientProxying);
-                t.IsInterface && t.IsPublic && typeof(IRemoteService).IsAssignableFrom(t)
-            );
 
             foreach (var serviceType in serviceTypes)
             {
@@ -155,7 +152,7 @@ namespace Microsoft.Extensions.DependencyInjection
             services.AddTransient(interceptorType);
 
             var interceptorAdapterType = typeof(AbpAsyncDeterminationInterceptor<>).MakeGenericType(interceptorType);
-            
+
             var validationInterceptorAdapterType =
                 typeof(AbpAsyncDeterminationInterceptor<>).MakeGenericType(typeof(ValidationInterceptor));
 
@@ -191,5 +188,21 @@ namespace Microsoft.Extensions.DependencyInjection
 
             return services;
         }
+
+        /// <summary>
+        /// Checks wether the type is suitable to use with the dynamic proxying.
+        /// Currently the type is checked statically against some fixed conditions.
+        /// </summary>
+        /// <param name="type">Type to check</param>
+        /// <returns>True, if the type is suitable for dynamic proxying. Otherwise false.</returns>
+        static bool IsSuitableForDynamicClientProxying(Type type)
+        {
+            //TODO: Add option to change type filter
+
+            return type.IsInterface
+                && type.IsPublic
+                && !type.IsGenericType
+                && typeof(IRemoteService).IsAssignableFrom(type);
+        }
     }
 }

framework/src/Volo.Abp.Http.Client/Volo/Abp/Http/Client/AbpHttpClientModule.cs

@@ -1,4 +1,6 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Http;
 using Volo.Abp.Castle;
 using Volo.Abp.Modularity;
 using Volo.Abp.MultiTenancy;
@@ -21,5 +23,24 @@ namespace Volo.Abp.Http.Client
             var configuration = context.Services.GetConfiguration();
             Configure<AbpRemoteServiceOptions>(configuration);
         }
+
+        public override void PostConfigureServices(ServiceConfigurationContext context)
+        {
+            Configure<AbpHttpClientOptions>(options =>
+            {
+                if (options.HttpClientActions.Any())
+                {
+                    var httpClientNames = options.HttpClientProxies.Select(x => x.Value.RemoteServiceName);
+                    foreach (var httpClientName in httpClientNames)
+                    {
+                        foreach (var httpClientAction in options.HttpClientActions)
+                        {
+                            context.Services.Configure<HttpClientFactoryOptions>(httpClientName,
+                                x => x.HttpClientActions.Add(httpClientAction.Invoke(httpClientName)));
+                        }
+                    }
+                }
+            });
+        }
     }
 }

framework/src/Volo.Abp.Http.Client/Volo/Abp/Http/Client/AbpHttpClientOptions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Net.Http;
 using Volo.Abp.Http.Client.DynamicProxying;
 
 namespace Volo.Abp.Http.Client
@@ -8,9 +9,12 @@ namespace Volo.Abp.Http.Client
     {
         public Dictionary<Type, DynamicHttpClientProxyConfig> HttpClientProxies { get; set; }
 
+        public List<Func<string, Action<HttpClient>>> HttpClientActions { get; }
+
         public AbpHttpClientOptions()
         {
             HttpClientProxies = new Dictionary<Type, DynamicHttpClientProxyConfig>();
+            HttpClientActions = new List<Func<string, Action<HttpClient>>>();
         }
     }
-}
+}

framework/src/Volo.Abp.IdentityModel/Volo/Abp/IdentityModel/IdentityModelAuthenticationService.cs

@@ -25,17 +25,20 @@ namespace Volo.Abp.IdentityModel
         protected ICancellationTokenProvider CancellationTokenProvider { get; }
         protected IHttpClientFactory HttpClientFactory { get; }
         protected ICurrentTenant CurrentTenant { get; }
+        protected IdentityModelHttpRequestMessageOptions IdentityModelHttpRequestMessageOptions { get; }
 
         public IdentityModelAuthenticationService(
             IOptions<AbpIdentityClientOptions> options,
             ICancellationTokenProvider cancellationTokenProvider,
             IHttpClientFactory httpClientFactory,
-            ICurrentTenant currentTenant)
+            ICurrentTenant currentTenant,
+            IOptions<IdentityModelHttpRequestMessageOptions> identityModelHttpRequestMessageOptions)
         {
             ClientOptions = options.Value;
             CancellationTokenProvider = cancellationTokenProvider;
             HttpClientFactory = httpClientFactory;
             CurrentTenant = currentTenant;
+            IdentityModelHttpRequestMessageOptions = identityModelHttpRequestMessageOptions.Value;
             Logger = NullLogger<IdentityModelAuthenticationService>.Instance;
         }
 
@@ -74,7 +77,7 @@ namespace Volo.Abp.IdentityModel
             }
 
             var tokenResponse = await GetTokenResponse(discoveryResponse, configuration);
-           
+
             if (tokenResponse.IsError)
             {
                 if (tokenResponse.ErrorDescription != null)
@@ -112,14 +115,16 @@ namespace Volo.Abp.IdentityModel
         {
             using (var httpClient = HttpClientFactory.CreateClient(HttpClientName))
             {
-                return await httpClient.GetDiscoveryDocumentAsync(new DiscoveryDocumentRequest
+                var request = new DiscoveryDocumentRequest
                 {
                     Address = configuration.Authority,
                     Policy =
                     {
                         RequireHttps = configuration.RequireHttps
                     }
-                });
+                };
+                IdentityModelHttpRequestMessageOptions.ConfigureHttpRequestMessage(request);
+                return await httpClient.GetDiscoveryDocumentAsync(request);
             }
         }
 
@@ -160,6 +165,7 @@ namespace Volo.Abp.IdentityModel
                 UserName = configuration.UserName,
                 Password = configuration.UserPassword
             };
+            IdentityModelHttpRequestMessageOptions.ConfigureHttpRequestMessage(request);
 
             AddParametersToRequestAsync(configuration, request);
 
@@ -177,6 +183,7 @@ namespace Volo.Abp.IdentityModel
                 ClientId = configuration.ClientId,
                 ClientSecret = configuration.ClientSecret
             };
+            IdentityModelHttpRequestMessageOptions.ConfigureHttpRequestMessage(request);
 
             AddParametersToRequestAsync(configuration, request);
 

framework/src/Volo.Abp.IdentityModel/Volo/Abp/IdentityModel/IdentityModelHttpRequestMessageOptions.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Net.Http;
+
+namespace Volo.Abp.IdentityModel
+{
+    public class IdentityModelHttpRequestMessageOptions
+    {
+        public Action<HttpRequestMessage> ConfigureHttpRequestMessage { get; set; }
+    }
+}

framework/src/Volo.Abp.MongoDB/Volo/Abp/MongoDB/MongoDbAsyncQueryableProvider.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.DependencyInjection;
@@ -17,19 +18,337 @@ namespace Volo.Abp.MongoDB
             return queryable.Provider.GetType().Namespace?.StartsWith("MongoDB") ?? false;
         }
 
+        protected IMongoQueryable<T> GetMongoQueryable<T>(IQueryable<T> queryable)
+        {
+            return (IMongoQueryable<T>) queryable;
+        }
+
+        public Task<bool> ContainsAsync<T>(IQueryable<T> queryable, T item, CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(GetMongoQueryable(queryable).Contains(item));
+        }
+
+        public Task<bool> AnyAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AnyAsync(predicate, cancellationToken);
+        }
+
+        public Task<bool> AllAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(GetMongoQueryable(queryable).All(predicate));
+        }
+
         public Task<int> CountAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
         {
-            return ((IMongoQueryable<T>) queryable).CountAsync(cancellationToken);
+            return GetMongoQueryable(queryable).CountAsync(cancellationToken);
         }
 
-        public Task<List<T>> ToListAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        public Task<int> CountAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).CountAsync(predicate, cancellationToken);
+        }
+
+        public Task<long> LongCountAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).LongCountAsync(cancellationToken);
+        }
+
+        public Task<long> LongCountAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).LongCountAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> FirstAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).FirstAsync(cancellationToken);
+        }
+
+        public Task<T> FirstAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
         {
-            return ((IMongoQueryable<T>) queryable).ToListAsync(cancellationToken);
+            return GetMongoQueryable(queryable).FirstAsync(predicate, cancellationToken);
         }
 
         public Task<T> FirstOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
         {
-            return ((IMongoQueryable<T>) queryable).FirstOrDefaultAsync(cancellationToken);
+            return GetMongoQueryable(queryable).FirstOrDefaultAsync(cancellationToken);
+        }
+
+        public Task<T> FirstOrDefaultAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).FirstOrDefaultAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> LastAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(GetMongoQueryable(queryable).Last());
+        }
+
+        public Task<T> LastAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(GetMongoQueryable(queryable).Last(predicate));
+        }
+
+        public Task<T> LastOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(GetMongoQueryable(queryable).LastOrDefault());
+        }
+
+        public Task<T> LastOrDefaultAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(GetMongoQueryable(queryable).LastOrDefault(predicate));
+        }
+
+        public Task<T> SingleAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SingleAsync(cancellationToken);
+        }
+
+        public Task<T> SingleAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SingleAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> SingleOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SingleOrDefaultAsync(cancellationToken);
+        }
+
+        public Task<T> SingleOrDefaultAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SingleOrDefaultAsync(predicate, cancellationToken);
+        }
+
+        public Task<T> MinAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).MinAsync(cancellationToken);
+        }
+
+        public Task<TResult> MinAsync<T, TResult>(IQueryable<T> queryable, Expression<Func<T, TResult>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).MinAsync(selector, cancellationToken);
+        }
+
+        public Task<T> MaxAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).MaxAsync(cancellationToken);
+        }
+
+        public Task<TResult> MaxAsync<T, TResult>(IQueryable<T> queryable, Expression<Func<T, TResult>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).MaxAsync(selector, cancellationToken);
+        }
+
+        public Task<decimal> SumAsync(IQueryable<decimal> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<decimal?> SumAsync(IQueryable<decimal?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<decimal> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<decimal?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<int> SumAsync(IQueryable<int> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<int?> SumAsync(IQueryable<int?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<int> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, int>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<int?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, int?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<long> SumAsync(IQueryable<long> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<long?> SumAsync(IQueryable<long?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<long> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, long>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<long?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, long?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<double> SumAsync(IQueryable<double> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<double?> SumAsync(IQueryable<double?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<double> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, double>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<double?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, double?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<float> SumAsync(IQueryable<float> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<float?> SumAsync(IQueryable<float?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(cancellationToken);
+        }
+
+        public Task<float> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, float>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<float?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, float?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).SumAsync(selector, cancellationToken);
+        }
+
+        public Task<decimal> AverageAsync(IQueryable<decimal> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<decimal?> AverageAsync(IQueryable<decimal?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<decimal> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<decimal?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double> AverageAsync(IQueryable<int> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<double?> AverageAsync(IQueryable<int?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, int>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, int?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double> AverageAsync(IQueryable<long> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<double?> AverageAsync(IQueryable<long?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, long>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, long?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double> AverageAsync(IQueryable<double> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<double?> AverageAsync(IQueryable<double?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, double>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, double?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<float> AverageAsync(IQueryable<float> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<float?> AverageAsync(IQueryable<float?> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(cancellationToken);
+        }
+
+        public Task<float> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, float>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<float?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, float?>> selector, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).AverageAsync(selector, cancellationToken);
+        }
+
+        public Task<List<T>> ToListAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return GetMongoQueryable(queryable).ToListAsync(cancellationToken);
+        }
+
+        public async Task<T[]> ToArrayAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return (await GetMongoQueryable(queryable).ToListAsync(cancellationToken)).ToArray();
         }
     }
-}
+}

framework/src/Volo.Abp.Threading/Volo/Abp/Linq/AsyncQueryableExecuter.cs

@@ -1,5 +1,7 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.DependencyInjection;
@@ -15,9 +17,36 @@ namespace Volo.Abp.Linq
             Providers = providers;
         }
 
-        public virtual Task<int> CountAsync<T>(
+        protected virtual IAsyncQueryableProvider FindProvider<T>(IQueryable<T> queryable)
-            IQueryable<T> queryable, 
+        {
-            CancellationToken cancellationToken = default)
+            return Providers.FirstOrDefault(p => p.CanExecute(queryable));
+        }
+
+        public Task<bool> ContainsAsync<T>(IQueryable<T> queryable, T item, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.ContainsAsync(queryable, item, cancellationToken)
+                : Task.FromResult(queryable.Contains(item));
+        }
+
+        public Task<bool> AnyAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AnyAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.Any(predicate));
+        }
+
+        public Task<bool> AllAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AllAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.All(predicate));
+        }
+
+        public Task<int> CountAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
         {
             var provider = FindProvider(queryable);
             return provider != null
@@ -25,19 +54,47 @@ namespace Volo.Abp.Linq
                 : Task.FromResult(queryable.Count());
         }
 
-        public virtual Task<List<T>> ToListAsync<T>(
+        public Task<int> CountAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
-            IQueryable<T> queryable,
-            CancellationToken cancellationToken = default)
         {
             var provider = FindProvider(queryable);
             return provider != null
-                ? provider.ToListAsync(queryable, cancellationToken)
+                ? provider.CountAsync(queryable, predicate, cancellationToken)
-                : Task.FromResult(queryable.ToList());
+                : Task.FromResult(queryable.Count(predicate));
         }
 
-        public virtual Task<T> FirstOrDefaultAsync<T>(
+        public Task<long> LongCountAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
-            IQueryable<T> queryable,
+        {
-            CancellationToken cancellationToken = default)
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.LongCountAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.LongCount());
+        }
+
+        public Task<long> LongCountAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.LongCountAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.LongCount(predicate));
+        }
+
+        public Task<T> FirstAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.FirstAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.First());
+        }
+
+        public Task<T> FirstAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.FirstAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.First(predicate));
+        }
+
+        public Task<T> FirstOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
         {
             var provider = FindProvider(queryable);
             return provider != null
@@ -45,9 +102,447 @@ namespace Volo.Abp.Linq
                 : Task.FromResult(queryable.FirstOrDefault());
         }
 
-        protected virtual IAsyncQueryableProvider FindProvider<T>(IQueryable<T> queryable)
+        public Task<T> FirstOrDefaultAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
         {
-            return Providers.FirstOrDefault(p => p.CanExecute(queryable));
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.FirstOrDefaultAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.FirstOrDefault(predicate));
+        }
+
+        public Task<T> LastAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.LastAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Last());
+        }
+
+        public Task<T> LastAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.LastAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.Last(predicate));
+        }
+
+        public Task<T> LastOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.LastOrDefaultAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.LastOrDefault());
+        }
+
+        public Task<T> LastOrDefaultAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.LastOrDefaultAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.LastOrDefault(predicate));
+        }
+
+        public Task<T> SingleAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SingleAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Single());
+        }
+
+        public Task<T> SingleAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SingleAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.Single(predicate));
+        }
+
+        public Task<T> SingleOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SingleOrDefaultAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.SingleOrDefault());
+        }
+
+        public Task<T> SingleOrDefaultAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SingleOrDefaultAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.SingleOrDefault(predicate));
+        }
+
+        public Task<T> MinAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.MinAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Min());
+        }
+
+        public Task<TResult> MinAsync<T, TResult>(IQueryable<T> queryable, Expression<Func<T, TResult>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.MinAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Min(selector));
+        }
+
+        public Task<T> MaxAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.MaxAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Max());
+        }
+
+        public Task<TResult> MaxAsync<T, TResult>(IQueryable<T> queryable, Expression<Func<T, TResult>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.MaxAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Max(selector));
+        }
+
+        public Task<decimal> SumAsync(IQueryable<decimal> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<decimal?> SumAsync(IQueryable<decimal?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<decimal> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<decimal?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<int> SumAsync(IQueryable<int> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<int?> SumAsync(IQueryable<int?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<int> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, int>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<int?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, int?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<long> SumAsync(IQueryable<long> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<long?> SumAsync(IQueryable<long?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<long> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, long>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<long?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, long?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<double> SumAsync(IQueryable<double> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<double?> SumAsync(IQueryable<double?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<double> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, double>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<double?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, double?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<float> SumAsync(IQueryable<float> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<float?> SumAsync(IQueryable<float?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Sum());
+        }
+
+        public Task<float> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, float>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<float?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, float?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.SumAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Sum(selector));
+        }
+
+        public Task<decimal> AverageAsync(IQueryable<decimal> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<decimal?> AverageAsync(IQueryable<decimal?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<decimal> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<decimal?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, decimal?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<double> AverageAsync(IQueryable<int> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<double?> AverageAsync(IQueryable<int?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, int>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, int?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<double> AverageAsync(IQueryable<long> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<double?> AverageAsync(IQueryable<long?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, long>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, long?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<double> AverageAsync(IQueryable<double> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<double?> AverageAsync(IQueryable<double?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, double>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, double?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<float> AverageAsync(IQueryable<float> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<float?> AverageAsync(IQueryable<float?> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.Average());
+        }
+
+        public Task<float> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, float>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<float?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, float?>> selector, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.AverageAsync(queryable, selector, cancellationToken)
+                : Task.FromResult(queryable.Average(selector));
+        }
+
+        public Task<List<T>> ToListAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.ToListAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.ToList());
+        }
+
+        public Task<T[]> ToArrayAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            var provider = FindProvider(queryable);
+            return provider != null
+                ? provider.ToArrayAsync(queryable, cancellationToken)
+                : Task.FromResult(queryable.ToArray());
         }
     }
-}
+}

framework/src/Volo.Abp.Threading/Volo/Abp/Linq/IAsyncQueryableExecuter.cs

@@ -1,25 +1,398 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 
 namespace Volo.Abp.Linq
 {
     public interface IAsyncQueryableExecuter
     {
+        #region Contains
+
+        Task<bool> ContainsAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] T item,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Any/All
+
+        Task<bool> AnyAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        Task<bool> AllAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Count/LongCount
+
         Task<int> CountAsync<T>(
-            IQueryable<T> queryable,
+            [NotNull] IQueryable<T> queryable,
-            CancellationToken cancellationToken = default
+            CancellationToken cancellationToken = default);
-        );
+
+
+        Task<int> CountAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long> LongCountAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long> LongCountAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region First/FirstOrDefault
+
+        Task<T> FirstAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> FirstAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
 
-        Task<List<T>> ToListAsync<T>(
-            IQueryable<T> queryable,
-            CancellationToken cancellationToken = default
-        );
 
         Task<T> FirstOrDefaultAsync<T>(
-            IQueryable<T> queryable,
+            [NotNull] IQueryable<T> queryable,
-            CancellationToken cancellationToken = default
+            CancellationToken cancellationToken = default);
-        );
+
+
+        Task<T> FirstOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Last/LastOrDefault
+
+        Task<T> LastAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> LastAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> LastOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> LastOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Single/SingleOrDefault
+
+        Task<T> SingleAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> SingleAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        Task<T> SingleOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+        Task<T> SingleOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Min
+
+        Task<T> MinAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<TResult> MinAsync<T, TResult>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, TResult>> selector,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Max
+
+        Task<T> MaxAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<TResult> MaxAsync<T, TResult>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, TResult>> selector,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Sum
+
+        Task<decimal> SumAsync(
+            [NotNull] IQueryable<decimal> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal?> SumAsync(
+            [NotNull] IQueryable<decimal?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, decimal>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, decimal?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<int> SumAsync(
+            [NotNull] IQueryable<int> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<int?> SumAsync(
+            [NotNull] IQueryable<int?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<int> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, int>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<int?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, int?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long> SumAsync(
+            [NotNull] IQueryable<long> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long?> SumAsync(
+            [NotNull] IQueryable<long?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, long>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, long?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> SumAsync(
+            [NotNull] IQueryable<double> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> SumAsync(
+            [NotNull] IQueryable<double?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, double>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, double?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float> SumAsync(
+            [NotNull] IQueryable<float> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float?> SumAsync(
+            [NotNull] IQueryable<float?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, float>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, float?>> selector,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Average
+
+        Task<decimal> AverageAsync(
+            [NotNull] IQueryable<decimal> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal?> AverageAsync(
+            [NotNull] IQueryable<decimal?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, decimal>> selector,
+            CancellationToken cancellationToken = default);
+
+        Task<decimal?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, decimal?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync(
+            [NotNull] IQueryable<int> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync(
+            [NotNull] IQueryable<int?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, int>> selector,
+            CancellationToken cancellationToken = default);
+
+        Task<double?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, int?>> selector,
+            CancellationToken cancellationToken = default);
+
+        Task<double> AverageAsync(
+            [NotNull] IQueryable<long> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync(
+            [NotNull] IQueryable<long?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, long>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, long?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync(
+            [NotNull] IQueryable<double> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync(
+            [NotNull] IQueryable<double?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, double>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, double?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float> AverageAsync(
+            [NotNull] IQueryable<float> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float?> AverageAsync(
+            [NotNull] IQueryable<float?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, float>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, float?>> selector,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region ToList/Array
+
+        Task<List<T>> ToListAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T[]> ToArrayAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+        #endregion
     }
-}
+}

framework/src/Volo.Abp.Threading/Volo/Abp/Linq/IAsyncQueryableProvider.cs

@@ -1,18 +1,400 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 
 namespace Volo.Abp.Linq
 {
     public interface IAsyncQueryableProvider
     {
         bool CanExecute<T>(IQueryable<T> queryable);
-        
-        Task<int> CountAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default);
 
-        Task<List<T>> ToListAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default);
+        #region Contains
 
-        Task<T> FirstOrDefaultAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default);
+        Task<bool> ContainsAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] T item,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Any/All
+
+        Task<bool> AnyAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        Task<bool> AllAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Count/LongCount
+
+        Task<int> CountAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<int> CountAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long> LongCountAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long> LongCountAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region First/FirstOrDefault
+
+        Task<T> FirstAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> FirstAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> FirstOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> FirstOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Last/LastOrDefault
+
+        Task<T> LastAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> LastAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> LastOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> LastOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Single/SingleOrDefault
+
+        Task<T> SingleAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T> SingleAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        Task<T> SingleOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+        Task<T> SingleOrDefaultAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Min
+
+        Task<T> MinAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<TResult> MinAsync<T, TResult>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, TResult>> selector,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Max
+
+        Task<T> MaxAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<TResult> MaxAsync<T, TResult>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, TResult>> selector,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Sum
+
+        Task<decimal> SumAsync(
+            [NotNull] IQueryable<decimal> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal?> SumAsync(
+            [NotNull] IQueryable<decimal?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, decimal>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, decimal?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<int> SumAsync(
+            [NotNull] IQueryable<int> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<int?> SumAsync(
+            [NotNull] IQueryable<int?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<int> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, int>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<int?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, int?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long> SumAsync(
+            [NotNull] IQueryable<long> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long?> SumAsync(
+            [NotNull] IQueryable<long?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, long>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<long?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, long?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> SumAsync(
+            [NotNull] IQueryable<double> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> SumAsync(
+            [NotNull] IQueryable<double?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, double>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, double?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float> SumAsync(
+            [NotNull] IQueryable<float> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float?> SumAsync(
+            [NotNull] IQueryable<float?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, float>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float?> SumAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, float?>> selector,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region Average
+
+        Task<decimal> AverageAsync(
+            [NotNull] IQueryable<decimal> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal?> AverageAsync(
+            [NotNull] IQueryable<decimal?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<decimal> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, decimal>> selector,
+            CancellationToken cancellationToken = default);
+
+        Task<decimal?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, decimal?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync(
+            [NotNull] IQueryable<int> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync(
+            [NotNull] IQueryable<int?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, int>> selector,
+            CancellationToken cancellationToken = default);
+
+        Task<double?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, int?>> selector,
+            CancellationToken cancellationToken = default);
+
+        Task<double> AverageAsync(
+            [NotNull] IQueryable<long> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync(
+            [NotNull] IQueryable<long?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, long>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, long?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync(
+            [NotNull] IQueryable<double> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync(
+            [NotNull] IQueryable<double?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, double>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<double?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, double?>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float> AverageAsync(
+            [NotNull] IQueryable<float> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float?> AverageAsync(
+            [NotNull] IQueryable<float?> source,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, float>> selector,
+            CancellationToken cancellationToken = default);
+
+
+        Task<float?> AverageAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            [NotNull] Expression<Func<T, float?>> selector,
+            CancellationToken cancellationToken = default);
+
+        #endregion
+
+        #region ToList/Array
+
+        Task<List<T>> ToListAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+
+        Task<T[]> ToArrayAsync<T>(
+            [NotNull] IQueryable<T> queryable,
+            CancellationToken cancellationToken = default);
+
+        #endregion
     }
-}
+}

framework/src/Volo.Abp.Uow/Volo/Abp/Uow/ISupportsSavingChanges.cs

@@ -5,8 +5,6 @@ namespace Volo.Abp.Uow
 {
     public interface ISupportsSavingChanges
     {
-        void SaveChanges();
-
         Task SaveChangesAsync(CancellationToken cancellationToken = default);
     }
 }

framework/src/Volo.Abp.Uow/Volo/Abp/Uow/ITransactionApi.cs

@@ -5,8 +5,6 @@ namespace Volo.Abp.Uow
 {
     public interface ITransactionApi : IDisposable
     {
-        void Commit();
-
         Task CommitAsync();
     }
 }

framework/src/Volo.Abp.Uow/Volo/Abp/Uow/UnitOfWork.cs

@@ -302,15 +302,7 @@ namespace Volo.Abp.Uow
                 }
             }
         }
-
+        
-        protected virtual void CommitTransactions()
-        {
-            foreach (var transaction in GetAllActiveTransactionApis())
-            {
-                transaction.Commit();
-            }
-        }
-
         protected virtual async Task CommitTransactionsAsync()
         {
             foreach (var transaction in GetAllActiveTransactionApis())

modules/virtual-file-explorer/app/Volo.Abp.VirtualFileExplorer.DemoApp/package.json

@@ -4,8 +4,6 @@
   "private": true,
   "dependencies": {
     "@abp/aspnetcore.mvc.ui.theme.basic": "^2.7.0",
-    "@abp/virtual-file-explorer": "^2.7.0",
+    "@abp/virtual-file-explorer": "^2.7.0"
-    "@abp/clipboard": "^2.7.0",
-    "@abp/prismjs": "^2.7.0"
   }
 }

modules/virtual-file-explorer/app/Volo.Abp.VirtualFileExplorer.DemoApp/yarn.lock

@@ -56,12 +56,12 @@
     "@abp/core" "^2.7.0"
     bootstrap "^4.3.1"
 
-"@abp/clipboard@^2.7.0":
+"@abp/clipboard@^2.9.0":
-  version "2.7.0"
+  version "2.9.0"
-  resolved "https://registry.yarnpkg.com/@abp/clipboard/-/clipboard-2.7.0.tgz#8f4b7aafae369759315481e5a331a832e61cc602"
+  resolved "https://registry.yarnpkg.com/@abp/clipboard/-/clipboard-2.9.0.tgz#b6d7180fbe3d8043e71b182ee620efa4877b8cf6"
-  integrity sha512-kPIASn3WPlpIUiluWPy1eIGKRZcueDGBz9K6houqyvPwspMpc0C+LtqN917svsYq4sAsaPFyGi3VfJE5lm4KZw==
+  integrity sha512-1rGd0PTQRWUUn2KkfOZF+2pp7rw7iSV5nUGOJ3sdTc/rLiH8tKv8FL4Sdj9EfaCiU8QVwDVmLtd5Kt6fLxeKDg==
   dependencies:
-    "@abp/core" "^2.7.0"
+    "@abp/core" "^2.9.0"
     clipboard "^2.0.4"
 
 "@abp/core@^2.7.0":
@@ -71,6 +71,13 @@
   dependencies:
     "@abp/utils" "^2.7.0"
 
+"@abp/core@^2.9.0":
+  version "2.9.0"
+  resolved "https://registry.yarnpkg.com/@abp/core/-/core-2.9.0.tgz#5460925a121c88f8afb69dbce65da1cd4257b024"
+  integrity sha512-6Hn6dPN47kqmJF0VbxNcDu370oNZPTlEGMm1dQcgM31DvOMS8ICy/4thxNYTTEr0DN9chujkw38aHFd2XqyBnw==
+  dependencies:
+    "@abp/utils" "^2.9.0"
+
 "@abp/datatables.net-bs4@^2.7.0":
   version "2.7.0"
   resolved "https://registry.yarnpkg.com/@abp/datatables.net-bs4/-/datatables.net-bs4-2.7.0.tgz#a113ca6f02b63b57e678a3b12fc06c2daa4eaff6"
@@ -150,12 +157,13 @@
     "@abp/core" "^2.7.0"
     malihu-custom-scrollbar-plugin "^3.1.5"
 
-"@abp/prismjs@^2.7.0":
+"@abp/prismjs@^2.9.0":
-  version "2.7.0"
+  version "2.9.0"
-  resolved "https://registry.yarnpkg.com/@abp/prismjs/-/prismjs-2.7.0.tgz#32794af1d83b19dd49b62f41cd2414fe021be70a"
+  resolved "https://registry.yarnpkg.com/@abp/prismjs/-/prismjs-2.9.0.tgz#d82ba6a5f03a09c4cc6697b3ae47955d3b4bbc20"
-  integrity sha512-RIe+Q39R0kNInkmE7TrqyCVqk+SWFQNyjHRVkqJkdj2lqfs3mIg10EwRQxDLg2KdOutEaSaK05TEEwwFSjGx8A==
+  integrity sha512-WErltCoD6N1NTUTY9936OKzLjM/5lUJlB/utFs4gxR7yrtImW9ryUsjkRbIy42taZ+FkkB+suDDwa5g/9hujBA==
   dependencies:
-    "@abp/core" "^2.7.0"
+    "@abp/clipboard" "^2.9.0"
+    "@abp/core" "^2.9.0"
     prismjs "^1.17.1"
 
 "@abp/select2@^2.7.0":
@@ -197,6 +205,21 @@
   dependencies:
     just-compare "^1.3.0"
 
+"@abp/utils@^2.9.0":
+  version "2.9.0"
+  resolved "https://registry.yarnpkg.com/@abp/utils/-/utils-2.9.0.tgz#8a66b7e1d422eae5898d32af7810d6bd625276f2"
+  integrity sha512-0gvWUH3jT7YE4ym2C45uKDzHs/oOdMW5lPq9ncCZ58wMxTrgPvxXNuMmRW0P259OcXYiRwmsNtb09/WlTQQbKA==
+  dependencies:
+    just-compare "^1.3.0"
+
+"@abp/virtual-file-explorer@^2.7.0":
+  version "2.9.0"
+  resolved "https://registry.yarnpkg.com/@abp/virtual-file-explorer/-/virtual-file-explorer-2.9.0.tgz#a55b94c8beafbb8757ca0b9794e3fa957e61221d"
+  integrity sha512-/CWxu3q5QF5jshLX3lw4XNWxTBBOGvZDSkuCM/pE9XNPXjIu6G3YB9XCBmqvk8toSp0d6QjShwzPcjAKPCQcpA==
+  dependencies:
+    "@abp/clipboard" "^2.9.0"
+    "@abp/prismjs" "^2.9.0"
+
 "@fortawesome/fontawesome-free@^5.11.2":
   version "5.13.0"
   resolved "https://registry.yarnpkg.com/@fortawesome/fontawesome-free/-/fontawesome-free-5.13.0.tgz#fcb113d1aca4b471b709e8c9c168674fbd6e06d9"