diff --git a/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/EfCoreAsyncQueryableProvider.cs b/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/EfCoreAsyncQueryableProvider.cs
index f9ef8c86e0..68ff261588 100644
--- a/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/EfCoreAsyncQueryableProvider.cs
+++ b/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);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/framework/src/Volo.Abp.MongoDB/Volo/Abp/MongoDB/MongoDbAsyncQueryableProvider.cs b/framework/src/Volo.Abp.MongoDB/Volo/Abp/MongoDB/MongoDbAsyncQueryableProvider.cs
index 8b0c56c812..a2bca09bdc 100644
--- a/framework/src/Volo.Abp.MongoDB/Volo/Abp/MongoDB/MongoDbAsyncQueryableProvider.cs
+++ b/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 Task<T[]> ToArrayAsync<T>(IQueryable<T> queryable, CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(GetMongoQueryable(queryable).ToArray());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/framework/src/Volo.Abp.Threading/Volo/Abp/Linq/AsyncQueryableExecuter.cs b/framework/src/Volo.Abp.Threading/Volo/Abp/Linq/AsyncQueryableExecuter.cs
index 3548f81ad1..f5b3cf3a6d 100644
--- a/framework/src/Volo.Abp.Threading/Volo/Abp/Linq/AsyncQueryableExecuter.cs
+++ b/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>(
-            IQueryable<T> queryable, 
-            CancellationToken cancellationToken = default)
+        protected virtual IAsyncQueryableProvider FindProvider<T>(IQueryable<T> queryable)
+        {
+            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>(
-            IQueryable<T> queryable,
-            CancellationToken cancellationToken = default)
+        public Task<int> CountAsync<T>(IQueryable<T> queryable, Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default)
         {
             var provider = FindProvider(queryable);
             return provider != null
-                ? provider.ToListAsync(queryable, cancellationToken)
-                : Task.FromResult(queryable.ToList());
+                ? provider.CountAsync(queryable, predicate, cancellationToken)
+                : Task.FromResult(queryable.Count(predicate));
         }
 
-        public virtual Task<T> FirstOrDefaultAsync<T>(
-            IQueryable<T> queryable,
-            CancellationToken cancellationToken = default)
+        public Task<long> LongCountAsync<T>(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());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/framework/src/Volo.Abp.Threading/Volo/Abp/Linq/IAsyncQueryableExecuter.cs b/framework/src/Volo.Abp.Threading/Volo/Abp/Linq/IAsyncQueryableExecuter.cs
index 0a19318c40..7273754b77 100644
--- a/framework/src/Volo.Abp.Threading/Volo/Abp/Linq/IAsyncQueryableExecuter.cs
+++ b/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,
-            CancellationToken cancellationToken = default
-        );
+            [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<List<T>> ToListAsync<T>(
-            IQueryable<T> queryable,
-            CancellationToken cancellationToken = default
-        );
 
         Task<T> FirstOrDefaultAsync<T>(
-            IQueryable<T> queryable,
-            CancellationToken cancellationToken = default
-        );
+            [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
     }
-}
\ No newline at end of file
+}
diff --git a/framework/src/Volo.Abp.Threading/Volo/Abp/Linq/IAsyncQueryableProvider.cs b/framework/src/Volo.Abp.Threading/Volo/Abp/Linq/IAsyncQueryableProvider.cs
index 43d8b6d40e..ce62ea738c 100644
--- a/framework/src/Volo.Abp.Threading/Volo/Abp/Linq/IAsyncQueryableProvider.cs
+++ b/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
     }
-}
\ No newline at end of file
+}