From 37514cef5a866b128c194b7efaba99715a8a5338 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Halil=20=C4=B0brahim=20Kalkan?= <hi_kalkan@yahoo.com>
Date: Fri, 18 Sep 2020 09:53:34 +0300
Subject: [PATCH 1/2] Example implementation for the repository async
 extensions.

---
 .../Repositories/IReadOnlyRepository.cs       |  3 ++
 .../Repositories/RepositoryAsyncExtensions.cs | 41 +++++++++++++++++++
 .../Abp/Domain/Repositories/RepositoryBase.cs |  9 ++--
 3 files changed, 50 insertions(+), 3 deletions(-)
 create mode 100644 framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryAsyncExtensions.cs

diff --git a/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/IReadOnlyRepository.cs b/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/IReadOnlyRepository.cs
index 03aad9c048..499a1e58be 100644
--- a/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/IReadOnlyRepository.cs
+++ b/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/IReadOnlyRepository.cs
@@ -2,12 +2,15 @@
 using System.Linq;
 using System.Linq.Expressions;
 using Volo.Abp.Domain.Entities;
+using Volo.Abp.Linq;
 
 namespace Volo.Abp.Domain.Repositories
 {
     public interface IReadOnlyRepository<TEntity> : IQueryable<TEntity>, IReadOnlyBasicRepository<TEntity>
         where TEntity : class, IEntity
     {
+        IAsyncQueryableExecuter AsyncExecuter { get; }
+
         IQueryable<TEntity> WithDetails();
 
         IQueryable<TEntity> WithDetails(params Expression<Func<TEntity, object>>[] propertySelectors);
diff --git a/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryAsyncExtensions.cs b/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryAsyncExtensions.cs
new file mode 100644
index 0000000000..7cddb753c9
--- /dev/null
+++ b/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryAsyncExtensions.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Volo.Abp.Domain.Entities;
+
+namespace Volo.Abp.Domain.Repositories
+{
+    public static class RepositoryAsyncExtensions
+    {
+        #region Count/LongCount
+
+        public static Task<int> CountAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.CountAsync(
+                repository,
+                cancellationToken
+            );
+        }
+
+        public static Task<int> CountAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.CountAsync(
+                repository,
+                predicate,
+                cancellationToken
+            );
+        }
+
+        #endregion
+    }
+}
diff --git a/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryBase.cs b/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryBase.cs
index bd7e486d29..fd66b293c9 100644
--- a/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryBase.cs
+++ b/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryBase.cs
@@ -7,6 +7,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Entities;
+using Volo.Abp.Linq;
 using Volo.Abp.MultiTenancy;
 using Volo.Abp.Uow;
 
@@ -19,6 +20,8 @@ namespace Volo.Abp.Domain.Repositories
 
         public ICurrentTenant CurrentTenant { get; set; }
 
+        public IAsyncQueryableExecuter AsyncExecuter { get; set; }
+
         public IUnitOfWorkManager UnitOfWorkManager { get; set; }
 
         public virtual Type ElementType => GetQueryable().ElementType;
@@ -50,12 +53,12 @@ namespace Volo.Abp.Domain.Repositories
         protected abstract IQueryable<TEntity> GetQueryable();
 
         public abstract Task<TEntity> FindAsync(
-            Expression<Func<TEntity, bool>> predicate, 
+            Expression<Func<TEntity, bool>> predicate,
             bool includeDetails = true,
             CancellationToken cancellationToken = default);
 
         public async Task<TEntity> GetAsync(
-            Expression<Func<TEntity, bool>> predicate, 
+            Expression<Func<TEntity, bool>> predicate,
             bool includeDetails = true,
             CancellationToken cancellationToken = default)
         {
@@ -107,4 +110,4 @@ namespace Volo.Abp.Domain.Repositories
             await DeleteAsync(entity, autoSave, cancellationToken);
         }
     }
-}
\ No newline at end of file
+}

From a3c63afdf017b9b54a0f930c5def0cf4096b487c Mon Sep 17 00:00:00 2001
From: maliming <6908465+maliming@users.noreply.github.com>
Date: Fri, 18 Sep 2020 16:55:22 +0800
Subject: [PATCH 2/2] Add more extension methods.

---
 .../Repositories/RepositoryAsyncExtensions.cs | 420 +++++++++++++++++-
 1 file changed, 410 insertions(+), 10 deletions(-)

diff --git a/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryAsyncExtensions.cs b/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryAsyncExtensions.cs
index 7cddb753c9..f6191a152f 100644
--- a/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryAsyncExtensions.cs
+++ b/framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryAsyncExtensions.cs
@@ -1,5 +1,5 @@
 using System;
-using System.Linq;
+using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -10,6 +10,41 @@ namespace Volo.Abp.Domain.Repositories
 {
     public static class RepositoryAsyncExtensions
     {
+        #region Contains
+
+        public static Task<bool> ContainsAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] T item,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.ContainsAsync(repository, item, cancellationToken);
+        }
+
+        #endregion
+
+        #region Any/All
+
+        public static Task<bool> AnyAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AnyAsync(repository, predicate, cancellationToken);
+        }
+
+        public static Task<bool> AllAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AllAsync(repository, predicate, cancellationToken);
+        }
+
+        #endregion
+
         #region Count/LongCount
 
         public static Task<int> CountAsync<T>(
@@ -17,10 +52,7 @@ namespace Volo.Abp.Domain.Repositories
             CancellationToken cancellationToken = default)
             where T : class, IEntity
         {
-            return repository.AsyncExecuter.CountAsync(
-                repository,
-                cancellationToken
-            );
+            return repository.AsyncExecuter.CountAsync(repository, cancellationToken);
         }
 
         public static Task<int> CountAsync<T>(
@@ -29,11 +61,379 @@ namespace Volo.Abp.Domain.Repositories
             CancellationToken cancellationToken = default)
             where T : class, IEntity
         {
-            return repository.AsyncExecuter.CountAsync(
-                repository,
-                predicate,
-                cancellationToken
-            );
+            return repository.AsyncExecuter.CountAsync(repository, predicate, cancellationToken);
+        }
+
+        public static Task<long> LongCountAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.LongCountAsync(repository, cancellationToken);
+        }
+
+        public static Task<long> LongCountAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.LongCountAsync(repository, predicate, cancellationToken);
+        }
+
+        #endregion
+
+        #region First/FirstOrDefault
+
+        public static Task<T> FirstAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.FirstAsync(repository, cancellationToken);
+        }
+
+        public static Task<T> FirstAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.FirstAsync(repository, predicate, cancellationToken);
+        }
+
+        public static Task<T> FirstOrDefaultAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.FirstOrDefaultAsync(repository, cancellationToken);
+        }
+
+        public static Task<T> FirstOrDefaultAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.FirstOrDefaultAsync(repository, predicate, cancellationToken);
+        }
+
+        #endregion
+
+        #region Last/LastOrDefault
+
+        public static Task<T> LastAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.LastAsync(repository, cancellationToken);
+        }
+
+        public static Task<T> LastAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.LastAsync(repository, predicate, cancellationToken);
+        }
+
+        public static Task<T> LastOrDefaultAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.LastOrDefaultAsync(repository, cancellationToken);
+        }
+
+        public static Task<T> LastOrDefaultAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.LastOrDefaultAsync(repository, predicate, cancellationToken);
+        }
+
+        #endregion
+
+        #region Single/SingleOrDefault
+
+        public static Task<T> SingleAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SingleAsync(repository, cancellationToken);
+        }
+
+        public static Task<T> SingleAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SingleAsync(repository, predicate, cancellationToken);
+        }
+
+        public static Task<T> SingleOrDefaultAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SingleOrDefaultAsync(repository, cancellationToken);
+        }
+
+        public static Task<T> SingleOrDefaultAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, bool>> predicate,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SingleOrDefaultAsync(repository, predicate, cancellationToken);
+        }
+
+        #endregion
+
+        #region Min
+
+        public static Task<T> MinAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.MinAsync(repository, cancellationToken);
+        }
+
+        public static Task<TResult> MinAsync<T, TResult>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, TResult>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.MinAsync(repository, selector, cancellationToken);
+        }
+
+        #endregion
+
+        #region Max
+
+        public static Task<T> MaxAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.MaxAsync(repository, cancellationToken);
+        }
+
+        public static Task<TResult> MaxAsync<T, TResult>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, TResult>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.MaxAsync(repository, selector, cancellationToken);
+        }
+
+        #endregion
+
+        #region Sum
+
+        public static Task<decimal> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, decimal>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<decimal?> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, decimal?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<int> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, int>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<int?> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, int?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<long> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, long>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<long?> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, long?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<double> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, double>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<double?> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, double?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<float> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, float>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<float?> SumAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, float?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.SumAsync(repository, selector, cancellationToken);
+        }
+
+        #endregion
+
+        #region Average
+
+        public static Task<decimal> AverageAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, decimal>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AverageAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<decimal?> AverageAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, decimal?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AverageAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<double> AverageAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, int>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AverageAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<double?> AverageAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, int?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AverageAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<double> AverageAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, long>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AverageAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<double?> AverageAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, long?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AverageAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<double> AverageAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, double>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AverageAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<double?> AverageAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, double?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AverageAsync(repository, selector, cancellationToken);
+        }
+
+        public static Task<float?> AverageAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            [NotNull] Expression<Func<T, float?>> selector,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.AverageAsync(repository, selector, cancellationToken);
+        }
+
+        #endregion
+
+        #region ToList/Array
+
+        public static Task<List<T>> ToListAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.ToListAsync(repository, cancellationToken);
+        }
+
+        public static Task<T[]> ToArrayAsync<T>(
+            [NotNull] this IReadOnlyRepository<T> repository,
+            CancellationToken cancellationToken = default)
+            where T : class, IEntity
+        {
+            return repository.AsyncExecuter.ToArrayAsync(repository, cancellationToken);
         }
 
         #endregion