Complete methods of IAsyncQueryableExecuter.

Resolve #4342
6 years ago · 66b4cd2b72
5 changed files with 1924 additions and 40 deletions
--- 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);
+        }
    }
-}
+}
--- 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());
        }
    }
-}
+}
--- 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());
        }
    }
-}
+}
--- 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
    }
-}
+}
--- 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
    }
-}
+}