Issue rsm-hcd#34 and rsm-hcd#17: Adding Read Async methods

Author: klauffer

src/Conductors/RepositoryConductor.cs

@@ -238,17 +238,8 @@ public partial class RepositoryConductor<T> : Conductor, IRepositoryConductor<T>
 
         #region FindAll
 
-        /// <summary>
-        /// Find all filtered, sorted and paged.
-        /// </summary>
-        /// <param name="filter">Filter to be used for querying.</param>
-        /// <param name="orderBy">Properties that should be used for sorting.</param>
-        /// <param name="includeProperties">Navigation properties that should be included.</param>
-        /// <param name="skip">Number of entities that should be skipped.</param>
-        /// <param name="take">Number of entities per page.</param>
-        /// <param name="ignoreQueryFilters">If true, global query filters will be ignored for this query.</param>
-        /// <param name="asNoTracking">Ignore change tracking on the result. Set <code>true</code> for read-only operations.</param>
-        /// <returns>A queryable collection of entities for the given criteria.</returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<IQueryable<T>> FindAll(
             Expression<Func<T, bool>> filter = null,
             Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
@@ -259,18 +250,8 @@ public virtual IResult<IQueryable<T>> FindAll(
             bool asNoTracking = false
         ) => _readConductor.FindAll(filter, orderBy, includeProperties, skip, take, ignoreQueryFilters, asNoTracking);
 
-        /// <summary>
-        /// Find all filtered, sorted and paged by grouping the result
-        /// </summary>
-        /// <param name="filter"></param>
-        /// <param name="orderBy"></param>
-        /// <param name="groupBy"></param>
-        /// <param name="includeProperties"></param>
-        /// <param name="skip"></param>
-        /// <param name="take"></param>
-        /// <param name="ignoreQueryFilters"></param>
-        /// <param name="asNoTracking">Ignore change tracking on the result. Set <code>true</code> for read-only operations.</param>
-        /// <returns></returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public IResult<IQueryable<IGrouping<TKey, T>>> FindAll<TKey>(
             Expression<Func<T, bool>> filter = null,
             Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
@@ -282,21 +263,8 @@ public IResult<IQueryable<IGrouping<TKey, T>>> FindAll<TKey>(
             bool asNoTracking = false
         ) => _readConductor.FindAll(filter, orderBy, groupBy, includeProperties, skip, take, ignoreQueryFilters, asNoTracking);
 
-        /// <summary>
-        /// Configure lazy loaded queryable, given provided parameters, to load a list of <typeparamref name="T"/>
-        /// grouped by a <typeparamref name="TKey"/> and selected by groupBySelector tranformed into <typeparamref name="TResult"/>
-        /// ref to: https://docs.microsoft.com/en-us/dotnet/api/system.linq.queryable.groupby?view=netcore-3.1#System_Linq_Queryable_GroupBy__3_System_Linq_IQueryable___0__System_Linq_Expressions_Expression_System_Func___0___1___System_Linq_Expressions_Expression_System_Func___1_System_Collections_Generic_IEnumerable___0____2___
-        /// </summary>
-        /// <param name="filter">Filter to be used for querying.</param>
-        /// <param name="orderBy">Properties that should be used for sorting.</param>
-        /// <param name="groupBy">Filter to be used for grouping by <typeparamref name="TKey"/> of <typeparamref name="T"/> .</param>
-        /// <param name="groupBySelector">Selector to be used on groupBy used to create a result of <typeparamref name="TResult"/> value from each group.</param>
-        /// <param name="includeProperties">Navigation properties that should be included.</param>
-        /// <param name="skip">Number of entities that should be skipped.</param>
-        /// <param name="take">Number of entities per page.</param>
-        /// <param name="ignoreQueryFilters">If true, global query filters will be ignored for this query.</param>
-        /// <param name="asNoTracking">Ignore change tracking on the result. Set <code>true</code> for read-only operations.</param>
-        /// <returns></returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public IResult<IQueryable<TResult>> FindAll<TKey, TResult>(
             Expression<Func<T, bool>> filter = null,
             Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
@@ -308,18 +276,10 @@ public IResult<IQueryable<TResult>> FindAll<TKey, TResult>(
             bool? ignoreQueryFilters = false,
             bool asNoTracking = false
         ) => _readConductor.FindAll(filter, orderBy, groupBy, groupBySelector, includeProperties, skip, take, ignoreQueryFilters, asNoTracking);
-    
 
-        /// <summary>
-        /// Alternative FindAll for retrieving records using NextLinkParams in place of traditional
-        /// determinate pagination mechanisms, such as; skip and take.
-        /// </summary>
-        /// <param name="nextLinkParams">Currently nothing is provided for NextLinkParams by this base class. Exists for overriding subclasses.</param>
-        /// <param name="filter">Filter to be used for querying.</param>
-        /// <param name="orderBy">Properties that should be used for sorting.</param>
-        /// <param name="ignoreQueryFilters">If true, global query filters will be ignored for this query.</param>
-        /// <param name="asNoTracking">Ignore change tracking on the result. Set <code>true</code> for read-only operations.</param>
-        /// <returns>A queryable collection of entities for the given criteria.</returns>
+
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<IQueryable<T>> FindAll(
             Dictionary<string, string> nextLinkParams,
             Expression<Func<T, bool>> filter = null,
@@ -328,16 +288,8 @@ public virtual IResult<IQueryable<T>> FindAll(
             bool asNoTracking = false
         ) => _readConductor.FindAll(nextLinkParams, filter, orderBy, ignoreQueryFilters, asNoTracking);
 
-        /// <summary>
-        /// Similar to FindAll but loading the result into memory.
-        /// </summary>
-        /// <param name="filter">Filter to be used for querying.</param>
-        /// <param name="orderBy">Properties that should be used for sorting.</param>
-        /// <param name="includeProperties">Navigation properties that should be included.</param>
-        /// <param name="skip">Number of entities that should be skipped.</param>
-        /// <param name="take">Number of entities per page.</param>
-        /// <param name="ignoreQueryFilters">If true, global query filters will be ignored for this query.</param>
-        /// <returns>An in-memory collection of entities for the given criteria.</returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<IList<T>> FindAllCommitted(
             Expression<Func<T, bool>> filter = null,
             Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
@@ -347,14 +299,8 @@ public virtual IResult<IList<T>> FindAllCommitted(
             bool? ignoreQueryFilters = false
         ) => _readConductor.FindAllCommitted(filter, orderBy, includeProperties, skip, take, ignoreQueryFilters);
 
-        /// <summary>
-        /// Similar to FindAll but loading the result into memory.
-        /// </summary>
-        /// <param name="nextLinkParams">Currently nothing is provided for NextLinkParams by this base class. Exists for overriding subclasses.</param>
-        /// <param name="filter">Filter to be used for querying.</param>
-        /// <param name="orderBy">Properties that should be used for sorting.</param>
-        /// <param name="ignoreQueryFilters">If true, global query filters will be ignored for this query.</param>
-        /// <returns>An in-memory collection of entities for the given criteria.</returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<IList<T>> FindAllCommitted(
             Dictionary<string, string> nextLinkParams,
             Expression<Func<T, bool>> filter = null,
@@ -366,52 +312,28 @@ public virtual IResult<IList<T>> FindAllCommitted(
 
         #region FindById
 
-        /// <summary>
-        /// Finds an entity by its Id.
-        /// </summary>
-        /// <param name="id">The entity identity value.</param>
-        /// <returns>The entity with the provided identity value.</returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<T> FindById(long id) => _readConductor.FindById(id);
 
-        /// <summary>
-        /// Finds an entity by its Id that also matches a filter.
-        /// </summary>
-        /// <param name="id">The entity identity value.</param>
-        /// <param name="filter">Filter to be used for querying.</param>
-        /// <returns>The entity with the provided identity value and filter condition met.</returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<T> FindById(long id, Expression<Func<T, bool>> filter) => _readConductor.FindById(id, filter);
 
-        /// <summary>
-        /// Finds an entity by its Id.
-        /// </summary>
-        /// <param name="id">The entity identity value.</param>
-        /// <param name="includeProperties">Navigation properties that should be included.</param>
-        /// <returns>The entity with the provided identity value.</returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<T> FindById(long id, params Expression<Func<T, object>>[] includeProperties) => _readConductor.FindById(id, includeProperties);
 
-        /// <summary>
-        /// Finds an entity by its Id.
-        /// </summary>
-        /// <param name="id">The entity identity value.</param>
-        /// <param name="ignoreQueryFilters">If true, global query filters will be ignored for this query.</param>
-        /// <param name="includeProperties">Navigation properties that should be included.</param>
-        /// <returns>The entity with the provided identity value.</returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<T> FindById(long id, bool ignoreQueryFilters, params Expression<Func<T, object>>[] includeProperties) => _readConductor.FindById(id, ignoreQueryFilters, includeProperties);
 
-        /// <summary>
-        /// Finds an entity by its Id.
-        /// </summary>
-        /// <param name="id">The entity identity value.</param>
-        /// <param name="includeProperties">Navigation properties that should be included.</param>
-        /// <returns>The entity with the provided identity value.</returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public IResult<T> FindById(long id, params string[] includeProperties) => _readConductor.FindById(id, includeProperties);
 
-        /// <summary>
-        /// Finds an entity by its Id.
-        /// </summary>
-        /// <param name="id">The entity identity value.</param>
-        /// <param name="includeProperties">Navigation property that should be included.</param>
-        /// <returns>The entity with the provided identity value.</returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public IResult<T> FindById(long id, string includeProperties) => _readConductor.FindById(id, includeProperties);
 
         #endregion FindById

src/Conductors/RepositoryConductorAsync.cs

@@ -1,4 +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 AndcultureCode.CSharp.Core.Interfaces;
@@ -138,5 +141,156 @@ public Task<IResult<bool>> RestoreAsync(long id, CancellationToken cancellationT
             _updateConductor.UpdateAsync(items, updatedBy, cancellationToken);
 
         #endregion Update
+
+        #region Read
+
+        #region FindAll
+
+        /// <inheritdoc />
+        public Task<IResult<IQueryable<T>>> FindAllAsync(
+            Expression<Func<T, bool>> filter = null,
+            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
+            string includeProperties = null,
+            int? skip = default(int?),
+            int? take = default(int?),
+            bool? ignoreQueryFilters = false,
+            bool asNoTracking = false,
+            CancellationToken cancellationToken = default
+        ) => _readConductor.FindAllAsync(
+            filter,
+            orderBy,
+            includeProperties,
+            skip,
+            take,
+            ignoreQueryFilters,
+            asNoTracking,
+            cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<IQueryable<IGrouping<TKey, T>>>> FindAllAsync<TKey>(
+            Expression<Func<T, bool>> filter = null,
+            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
+            Expression<Func<T, TKey>> groupBy = null,
+            string includeProperties = null,
+            int? skip = null,
+            int? take = null,
+            bool? ignoreQueryFilters = false,
+            bool asNoTracking = false,
+            CancellationToken cancellationToken = default
+        ) => _readConductor.FindAllAsync(
+            filter,
+            orderBy,
+            groupBy,
+            includeProperties,
+            skip,
+            take,
+            ignoreQueryFilters,
+            asNoTracking,
+            cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<IQueryable<TResult>>> FindAllAsync<TKey, TResult>(
+            Expression<Func<T, bool>> filter = null,
+            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
+            Expression<Func<T, TKey>> groupBy = null,
+            Expression<Func<TKey, IEnumerable<T>, TResult>> groupBySelector = null,
+            string includeProperties = null,
+            int? skip = default(int?),
+            int? take = default(int?),
+            bool? ignoreQueryFilters = false,
+            bool asNoTracking = false,
+            CancellationToken cancellationToken = default
+        ) => _readConductor.FindAllAsync(
+            filter,
+            orderBy,
+            groupBy,
+            groupBySelector,
+            includeProperties,
+            skip,
+            take,
+            ignoreQueryFilters,
+            asNoTracking,
+            cancellationToken);
+
+
+        /// <inheritdoc />
+        public Task<IResult<IQueryable<T>>> FindAllAsync(
+            Dictionary<string, string> nextLinkParams,
+            Expression<Func<T, bool>> filter = null,
+            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
+            bool? ignoreQueryFilters = false,
+            bool asNoTracking = false,
+            CancellationToken cancellationToken = default
+        ) => _readConductor.FindAllAsync(
+            nextLinkParams,
+            filter,
+            orderBy,
+            ignoreQueryFilters,
+            asNoTracking,
+            cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<IList<T>>> FindAllCommittedAsync(
+            Expression<Func<T, bool>> filter = null,
+            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
+            string includeProperties = null,
+            int? skip = default(int?),
+            int? take = default(int?),
+            bool? ignoreQueryFilters = false,
+            CancellationToken cancellationToken = default
+        ) => _readConductor.FindAllCommittedAsync(
+            filter,
+            orderBy,
+            includeProperties,
+            skip,
+            take,
+            ignoreQueryFilters,
+            cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<IList<T>>> FindAllCommittedAsync(
+            Dictionary<string, string> nextLinkParams,
+            Expression<Func<T, bool>> filter = null,
+            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
+            bool? ignoreQueryFilters = false,
+            CancellationToken cancellationToken = default
+        ) => _readConductor.FindAllCommittedAsync(
+            nextLinkParams,
+            filter,
+            orderBy,
+            ignoreQueryFilters,
+            cancellationToken);
+
+        #endregion FindAll
+
+        #region FindById
+
+        /// <inheritdoc />
+        public Task<IResult<T>>FindByIdAsync(long id, bool ignoreQueryFilters = false, CancellationToken cancellationToken = default) => 
+            _readConductor.FindByIdAsync(id, ignoreQueryFilters, cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<T>> FindByIdAsync(long id, Expression<Func<T, bool>> filter, CancellationToken cancellationToken = default) => 
+            _readConductor.FindByIdAsync(id, filter, cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<T>> FindByIdAsync(long id, CancellationToken cancellationToken = default, params Expression<Func<T, object>>[] includeProperties) => 
+            _readConductor.FindByIdAsync(id, cancellationToken, includeProperties);
+
+        /// <inheritdoc />
+        public Task<IResult<T>> FindByIdAsync(long id, bool ignoreQueryFilters, CancellationToken cancellationToken = default, params Expression<Func<T, object>>[] includeProperties) => 
+            _readConductor.FindByIdAsync(id, ignoreQueryFilters, cancellationToken, includeProperties);
+
+        /// <inheritdoc />
+        public Task<IResult<T>> FindByIdAsync(long id, CancellationToken cancellationToken = default, params string[] includeProperties) => 
+            _readConductor.FindByIdAsync(id, cancellationToken, includeProperties);
+
+        /// <inheritdoc />
+        public Task<IResult<T>> FindByIdAsync(long id, string includeProperties, CancellationToken cancellationToken = default) => 
+            _readConductor.FindByIdAsync(id, cancellationToken, includeProperties);
+
+        #endregion FindById
+
+        #endregion Read
     }
 }