Issue rsm-hcd#34 and rsm-hcd#17: Adding Update async methods

Author: klauffer

src/Conductors/RepositoryConductor.cs

@@ -418,29 +418,20 @@ public virtual IResult<IList<T>> FindAllCommitted(
 
         #region Update
 
-        /// <summary>
-        /// Ability to update a list of entities in a single bulk operation.
-        /// </summary>
-        /// <param name="items">List of items to update</param>
-        /// <param name="updatedBy">Id of user updating the entity</param>
-        /// <returns></returns>
-        public virtual IResult<bool> BulkUpdate(IEnumerable<T> items, long? updatedBy = default(long?)) => _updateConductor.BulkUpdate(items, updatedBy);
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
+        public virtual IResult<bool> BulkUpdate(IEnumerable<T> items, long? updatedBy = default(long?)) => 
+            _updateConductor.BulkUpdate(items, updatedBy);
 
-        /// <summary>
-        /// Ability to update an entity
-        /// </summary>
-        /// <param name="item">Item to update</param>
-        /// <param name="updatedBy">Id of user updating the entity</param>
-        /// <returns></returns>
-        public virtual IResult<bool> Update(T item, long? updatedBy = default(long?)) => _updateConductor.Update(item, updatedBy);
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
+        public virtual IResult<bool> Update(T item, long? updatedBy = default(long?)) => 
+            _updateConductor.Update(item, updatedBy);
 
-        /// <summary>
-        /// Ability to update a list of items but each item is updated individually.
-        /// </summary>
-        /// <param name="items">List of items to update</param>
-        /// <param name="updatedBy">Id of user updating the entity</param>
-        /// <returns></returns>
-        public virtual IResult<bool> Update(IEnumerable<T> items, long? updatedBy = default(long?)) => _updateConductor.Update(items, updatedBy);
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
+        public virtual IResult<bool> Update(IEnumerable<T> items, long? updatedBy = default(long?)) => 
+            _updateConductor.Update(items, updatedBy);
 
         #endregion Update
 

src/Conductors/RepositoryConductorAsync.cs

@@ -122,5 +122,21 @@ public Task<IResult<bool>> RestoreAsync(long id, CancellationToken cancellationT
             _deleteConductor.RestoreAsync(id, cancellationToken);
 
         #endregion Delete
+
+        #region Update
+
+        /// <inheritdoc />
+        public Task<IResult<bool>> BulkUpdateAsync(IEnumerable<T> items, long? updatedBy = default(long?), CancellationToken cancellationToken = default) => 
+            _updateConductor.BulkUpdateAsync(items, updatedBy, cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<bool>> UpdateAsync(T item, long? updatedBy = default(long?), CancellationToken cancellationToken = default) => 
+            _updateConductor.UpdateAsync(item, updatedBy, cancellationToken);
+
+        /// <inheritdoc />
+        public Task<IResult<bool>> UpdateAsync(IEnumerable<T> items, long? updatedBy = default(long?), CancellationToken cancellationToken = default) => 
+            _updateConductor.UpdateAsync(items, updatedBy, cancellationToken);
+
+        #endregion Update
     }
 }

src/Conductors/RepositoryUpdateConductor.cs

@@ -1,7 +1,7 @@
+using System;
 using System.Collections.Generic;
 using AndcultureCode.CSharp.Core.Interfaces;
 using AndcultureCode.CSharp.Core.Interfaces.Conductors;
-using AndcultureCode.CSharp.Core.Interfaces.Data;
 using AndcultureCode.CSharp.Core.Interfaces.Entity;
 
 namespace AndcultureCode.CSharp.Conductors
@@ -10,69 +10,27 @@ namespace AndcultureCode.CSharp.Conductors
     /// Ability to update an entity or a list of entities
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public class RepositoryUpdateConductor<T> : Conductor, IRepositoryUpdateConductor<T>
+    public partial class RepositoryUpdateConductor<T> : Conductor, IRepositoryUpdateConductor<T>
         where T : class, IEntity
     {
-        #region Properties
-
-        /// <summary>
-        /// Ability to set and get the underlying DbContext's command timeout
-        /// </summary>
-        public int? CommandTimeout
-        {
-            get => _repository.CommandTimeout;
-            set => _repository.CommandTimeout = value;
-        }
-
-        readonly IRepository<T> _repository;
-
-        #endregion Properties
-
-        #region Constructor
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="repository"></param>
-        public RepositoryUpdateConductor(
-            IRepository<T> repository
-            )
-        {
-            _repository = repository;
-        }
-
-        #endregion Constructor
-
         #region IRepositoryUpdateConductor Implementation
 
-        /// <summary>
-        /// Ability to update a list of entities in a single bulk operation.
-        /// </summary>
-        /// <param name="items">List of items to update</param>
-        /// <param name="updatedBy">Id of user updating the entity</param>
-        /// <returns></returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<bool> BulkUpdate(IEnumerable<T> items, long? updatedBy = default(long?))
         {
             return _repository.BulkUpdate(items, updatedBy);
         }
 
-        /// <summary>
-        /// Ability to update an entity
-        /// </summary>
-        /// <param name="item">Item to update</param>
-        /// <param name="updatedBy">Id of user updating the entity</param>
-        /// <returns></returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<bool> Update(T item, long? updatedBy = default(long?))
         {
             return _repository.Update(item, updatedBy);
         }
 
-        /// <summary>
-        /// Ability to update a list of items but each item is updated individually.
-        /// </summary>
-        /// <param name="items">List of items to update</param>
-        /// <param name="updatedBy">Id of user updating the entity</param>
-        /// <returns></returns>
+        /// <inheritdoc />
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<bool> Update(IEnumerable<T> items, long? updatedBy = default(long?))
         {
             return _repository.Update(items, updatedBy);

src/Conductors/RepositoryUpdateConductorAsync.cs

@@ -0,0 +1,75 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using AndcultureCode.CSharp.Core.Interfaces;
+using AndcultureCode.CSharp.Core.Interfaces.Conductors;
+using AndcultureCode.CSharp.Core.Interfaces.Data;
+using AndcultureCode.CSharp.Core.Interfaces.Entity;
+
+namespace AndcultureCode.CSharp.Conductors
+{
+    public partial class RepositoryUpdateConductor<T> : Conductor, IRepositoryUpdateConductor<T>
+    where T : class, IEntity
+    {
+        /// <summary>
+        /// Ability to set and get the underlying DbContext's command timeout
+        /// </summary>
+        public int? CommandTimeout
+        {
+            get => _repository.CommandTimeout;
+            set => _repository.CommandTimeout = value;
+        }
+
+        readonly IRepository<T> _repository;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="repository"></param>
+        public RepositoryUpdateConductor(
+            IRepository<T> repository
+            )
+        {
+            _repository = repository;
+        }
+
+        /// <summary>
+        /// Ability to update a list of entities in a single bulk operation.
+        /// </summary>
+        /// <param name="items">List of items to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        public Task<IResult<bool>> BulkUpdateAsync(IEnumerable<T> items, long? updatedBy = default(long?), CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return _repository.BulkUpdateAsync(items, updatedBy, cancellationToken);
+        }
+
+        /// <summary>
+        /// Ability to update an entity
+        /// </summary>
+        /// <param name="item">Item to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        public Task<IResult<bool>> UpdateAsync(T item, long? updatedBy = default(long?), CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return _repository.UpdateAsync(item, updatedBy, cancellationToken);
+        }
+
+        /// <summary>
+        /// Ability to update a list of items but each item is updated individually.
+        /// </summary>
+        /// <param name="items">List of items to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        public Task<IResult<bool>> UpdateAsync(IEnumerable<T> items, long? updatedBy = default(long?), CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return _repository.UpdateAsync(items, updatedBy, cancellationToken);
+        }
+    }
+}

src/Core/Interfaces/Conductors/IRepositoryUpdateConductor.cs

@@ -1,27 +1,37 @@
+using System;
 using System.Collections.Generic;
 using AndcultureCode.CSharp.Core.Interfaces.Entity;
 
 namespace AndcultureCode.CSharp.Core.Interfaces.Conductors
 {
-    public interface IRepositoryUpdateConductor<T>
+    public partial interface IRepositoryUpdateConductor<T>
         where T : class, IEntity
     {
-         #region Properties
-
         /// <summary>
-        /// Ability to set and get the underlying DbContext's command timeout
+        /// Ability to update a list of entities in a single bulk operation.
         /// </summary>
-        int? CommandTimeout { get; set; }
-
-        #endregion Properties
-
-
-        #region Methods
-
+        /// <param name="items">List of items to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         IResult<bool> BulkUpdate(IEnumerable<T> items, long? updatedBy = null);
+
+        /// <summary>
+        /// Ability to update an entity
+        /// </summary>
+        /// <param name="item">Item to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         IResult<bool> Update(T item, long? updatedBy = null);
-        IResult<bool> Update(IEnumerable<T> items, long? updatedBy = default(long?));
 
-        #endregion Methods
+        /// <summary>
+        /// Ability to update a list of items but each item is updated individually.
+        /// </summary>
+        /// <param name="items">List of items to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
+        IResult<bool> Update(IEnumerable<T> items, long? updatedBy = default(long?));
     }
 }

src/Core/Interfaces/Conductors/IRepositoryUpdateConductorAsync.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using AndcultureCode.CSharp.Core.Interfaces.Entity;
+
+namespace AndcultureCode.CSharp.Core.Interfaces.Conductors
+{
+    public partial interface IRepositoryUpdateConductor<T>
+        where T : class, IEntity
+    {
+        /// <summary>
+        /// Ability to set and get the underlying DbContext's command timeout
+        /// </summary>
+        int? CommandTimeout { get; set; }
+
+        /// <summary>
+        /// Ability to update a list of entities in a single bulk operation.
+        /// </summary>
+        /// <param name="items">List of items to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        Task<IResult<bool>> BulkUpdateAsync(IEnumerable<T> items, long? updatedBy = null, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Ability to update an entity
+        /// </summary>
+        /// <param name="item">Item to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        Task<IResult<bool>> UpdateAsync(T item, long? updatedBy = null, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Ability to update a list of items but each item is updated individually.
+        /// </summary>
+        /// <param name="items">List of items to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        Task<IResult<bool>> UpdateAsync(IEnumerable<T> items, long? updatedBy = default(long?), CancellationToken cancellationToken = default);
+    }
+}

src/Core/Interfaces/Data/IRepository.cs

@@ -64,6 +64,7 @@ public partial interface IRepository<T>
         /// <param name="entities">List of items to update</param>
         /// <param name="updatedBy">Id of user updating the entity</param>
         /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         IResult<bool> BulkUpdate(IEnumerable<T> entities, long? updatedBy = default(long?));
 
         /// <summary>
@@ -274,6 +275,7 @@ IResult<IQueryable<TResult>> FindAll<TKey, TResult>(
         /// <param name="item">Item to create or update</param>
         /// <param name="updatedBy">Id of user creating or updating the entity</param>
         /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         IResult<bool> Update(T item, long? updatedBy = null);
 
         /// <summary>
@@ -283,6 +285,7 @@ IResult<IQueryable<TResult>> FindAll<TKey, TResult>(
         /// <param name="entities"></param>
         /// <param name="updatedBy"></param>
         /// <returns>True if entities updated without any exceptions. False if an exception was thrown.</returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         IResult<bool> Update(IEnumerable<T> entities, long? updatedBy = default(long?));
 
         #endregion Methods

src/Core/Interfaces/Data/IRepositoryAsync.cs

@@ -127,5 +127,37 @@ public partial interface IRepository<T>
 
         #endregion Delete
 
+        #region Update
+
+        /// <summary>
+        /// Ability to update a list of entities in a single bulk operation.
+        /// </summary>
+        /// <param name="entities">List of items to update</param>
+        /// <param name="updatedBy">Id of user updating the entity</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        Task<IResult<bool>> BulkUpdateAsync(IEnumerable<T> entities, long? updatedBy = default(long?), CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Ability to create or update an entity
+        /// </summary>
+        /// <param name="item">Item to create or update</param>
+        /// <param name="updatedBy">Id of user creating or updating the entity</param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns></returns>
+        Task<IResult<bool>> UpdateAsync(T item, long? updatedBy = null, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Calls Update one-by-one for each item in the enumerated entities.
+        /// For large operations, BulkUpdate() is more efficient.
+        /// </summary>
+        /// <param name="entities"></param>
+        /// <param name="updatedBy"></param>
+        /// <param name="cancellationToken">a token allowing aborting of this request</param>
+        /// <returns>True if entities updated without any exceptions. False if an exception was thrown.</returns>
+        Task<IResult<bool>> UpdateAsync(IEnumerable<T> entities, long? updatedBy = default(long?), CancellationToken cancellationToken = default);
+
+        #endregion Update
+
     }
 }