From 3dbe2f369f89ef527d0c0add53534d4d41ee237b Mon Sep 17 00:00:00 2001
From: Kyle Lauffer <klauffer@andculture.com>
Date: Fri, 18 Mar 2022 17:09:18 -0400
Subject: [PATCH 1/2] Issue #34 and #17 Adding Async methods for
 BulkCreateAsync

---
 src/Core/Interfaces/Data/IRepositoryAsync.cs | 286 +++++++++++++++++++
 1 file changed, 286 insertions(+)
 create mode 100644 src/Core/Interfaces/Data/IRepositoryAsync.cs

diff --git a/src/Core/Interfaces/Data/IRepositoryAsync.cs b/src/Core/Interfaces/Data/IRepositoryAsync.cs
new file mode 100644
index 0000000..9661628
--- /dev/null
+++ b/src/Core/Interfaces/Data/IRepositoryAsync.cs
@@ -0,0 +1,286 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using AndcultureCode.CSharp.Core.Interfaces.Entity;
+
+namespace AndcultureCode.CSharp.Core.Interfaces.Data
+{
+    public interface IRepositoryAsync<T>
+        where T : class, IEntity
+    {
+        #region Properties
+
+        /// <summary>
+        /// Ability to set and get the underlying DbContext's command timeout
+        /// </summary>
+        int? CommandTimeout { get; set; }
+
+        #endregion Properties
+
+
+        #region Methods
+
+        /// <summary>
+        /// Perform a DbContext.BulkInsert on an enumeration of T within a single transaction
+        /// </summary>
+        /// <param name="items"></param>
+        /// <param name="createdById"></param>
+        /// <returns></returns>
+        Task<IResult<List<T>>> BulkCreate(IEnumerable<T> items, long? createdById = null);
+
+        /// <summary>
+        /// Calls BulkCreate() with a de-duped list of objects as determined by the
+        /// property (or properties) of the object for the 'property' argument
+        /// NOTE: Bulking is generally faster than batching, but locks the table.
+        /// </summary>
+        /// <param name="items">List of items to attempt to create</param>
+        /// <param name="property">Property or properties of the typed object to determine distinctness</param>
+        /// <param name="createdById">Id of the user creating the entity</param>
+        /// <typeparam name="TKey"></typeparam>
+        /// <returns></returns>
+
+        /// <summary>
+        /// Calls BulkCreate() after selecting a subset of 'items' based on the distinct value of 'property'
+        /// </summary>
+        /// <param name="items"></param>
+        /// <param name="property"></param>
+        /// <param name="createdById"></param>
+        /// <typeparam name="TKey"></typeparam>
+        /// <returns></returns>
+        Task<IResult<List<T>>> BulkCreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null);
+
+        /// <summary>
+        /// Calls BulkDelete() with a de-duped list of objects as determined by the
+        /// property (or properties) of the object for the 'property' argument
+        /// NOTE: Bulking is generally faster than batching, but locks the table.
+        /// </summary>
+        /// <param name="items"></param>
+        /// <param name="deletedById"></param>
+        /// <param name="soft"></param>
+        /// <returns></returns>
+        Task<IResult<bool>> BulkDelete(IEnumerable<T> items, long? deletedById = null, bool soft = true);
+
+        /// <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>
+        /// <returns></returns>
+        Task<IResult<bool>> BulkUpdate(IEnumerable<T> entities, long? updatedBy = default(long?));
+
+        /// <summary>
+        /// Ability to create an entity 
+        /// </summary>
+        /// <param name="item">Item to be created</param>
+        /// <param name="createdById">Id of user creating the item</param>
+        /// <returns></returns>
+        Task<IResult<T>> Create(T item, long? createdById = null);
+
+        /// <summary>
+        /// Ability to create entities individually using a list 
+        /// </summary>
+        /// <param name="items">List of items to be created</param>
+        /// <param name="createdById">Id of user creating the items</param>
+        /// <returns></returns>
+        Task<IResult<List<T>>> Create(IEnumerable<T> items, long? createdById = null);
+
+        /// <summary>
+        /// Calls batched overload of Create() with a de-duped list of objects as determined by the
+        /// property (or properties) of the object for the 'property' argument.
+        /// NOTE: Batching is generally slower than bulking, but does not lock the table.
+        /// </summary>
+        /// <param name="items">List of items to attempt to create</param>
+        /// <param name="property">Property or properties of the typed object to determine distinctness</param>
+        /// <param name="createdById">Id of the user creating the entity</param>
+        /// <typeparam name="TKey"></typeparam>
+        /// <returns></returns>
+        Task<IResult<List<T>>> CreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null);
+
+        /// <summary>
+        /// Ability to delete an entity using an Id
+        /// </summary>
+        /// <param name="id">Id of item to be deleted</param>
+        /// <param name="deletedById">Id of user deleting the item</param>
+        /// <param name="soft">Boolean flag for soft-deleting the item</param>
+        /// <returns></returns>
+        Task<IResult<bool>> Delete(long id, long? deletedById = null, bool soft = true);
+
+        /// <summary>
+        /// Ability to delete an entity using the entity itself
+        /// </summary>
+        /// <param name="o">Item to be deleted</param>
+        /// <param name="deletedById">Id of user deleting the item</param>
+        /// <param name="soft">Boolean flag for soft-deleting the item</param>
+        /// <returns></returns>
+        Task<IResult<bool>> Delete(T o, long? deletedById = null, bool soft = true);
+
+        /// <summary>
+        /// Ability to delete a list of entities by batch size.
+        /// </summary>
+        /// <param name="items">List of items to delete</param>
+        /// <param name="deletedById">Id of user deleting the items</param>
+        /// <param name="batchSize">Number of items to include in a batch, defaults to 100</param>
+        /// <param name="soft">Boolean flag for soft-deleting the items</param>
+        /// <returns></returns>
+        Task<IResult<bool>> Delete(IEnumerable<T> items, long? deletedById = null, long batchSize = 100, bool soft = true);
+
+        /// <summary>
+        /// Find all filtered, sorted and paged
+        /// </summary>
+        /// <param name="filter"></param>
+        /// <param name="orderBy"></param>
+        /// <param name="includeProperties"></param>
+        /// <param name="skip"></param>
+        /// <param name="take"></param>
+        /// <param name="ignoreQueryFilters"></param>
+        /// <param name="asNoTracking"></param>
+        /// <returns></returns>
+        Task<IResult<IQueryable<T>>> FindAll(
+            Expression<Func<T, bool>> filter = null,
+            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
+            string includeProperties = null,
+            int? skip = null,
+            int? take = null,
+            bool? ignoreQueryFilters = false,
+            bool asNoTracking = false
+        );
+
+        /// <summary>
+        /// Configure lazy loaded queryable, given provided parameters, to load a list of <typeparamref name="T"/> grouped by a <typeparamref name="TKey"/>
+        /// </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="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>
+        Task<IResult<IQueryable<IGrouping<TKey, T>>>> FindAll<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 = default(int?),
+            int? take = default(int?),
+            bool? ignoreQueryFilters = false,
+            bool asNoTracking = false
+        );
+
+        /// <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>
+        Task<IResult<IQueryable<TResult>>> FindAll<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
+        );
+
+        /// <summary>
+        /// Find all filtered, sorted and paged and converts to an IList<T>
+        /// </summary>
+        /// <param name="filter"></param>
+        /// <param name="orderBy"></param>
+        /// <param name="includeProperties"></param>
+        /// <param name="skip"></param>
+        /// <param name="take"></param>
+        /// <param name="ignoreQueryFilters"></param>
+        /// <returns></returns>
+        Task<IResult<IList<T>>> FindAllCommitted(Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, string includeProperties = null, int? skip = null, int? take = null, bool? ignoreQueryFilters = false);
+
+        /// <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>
+        /// <returns>The entity with the provided identity value.</returns>
+        Task<IResult<T>> FindById(long id, bool? ignoreQueryFilters = false);
+
+        /// <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 witht he provided identity value and filter condition met.</returns>
+        Task<IResult<T>> FindById(long id, Expression<Func<T, bool>> 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>
+        Task<IResult<T>> FindById(long id, params Expression<Func<T, object>>[] 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>
+        Task<IResult<T>> FindById(long id, bool? ignoreQueryFilters = false, params Expression<Func<T, object>>[] 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>
+        Task<IResult<T>> FindById(long id, params string[] includeProperties);
+
+        /// <summary>
+        /// Ability to restore a soft-deleted entity using the entity itself. 
+        /// </summary>
+        /// <param name="o">Entity to be restored</param>
+        /// <returns></returns>
+        Task<IResult<bool>> Restore(T o);
+
+        /// <summary>
+        /// Ability to restore a soft-deleted entity using the entity id.
+        /// </summary>
+        /// <param name="id">Id of entity to be restored</param>
+        /// <returns></returns>
+        Task<IResult<bool>> Restore(long id);
+
+        /// <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>
+        /// <returns></returns>
+        Task<IResult<bool>> Update(T item, long? updatedBy = null);
+
+        /// <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>
+        /// <returns>True if entities updated without any exceptions. False if an exception was thrown.</returns>
+        Task<IResult<bool>> Update(IEnumerable<T> entities, long? updatedBy = default(long?));
+
+        #endregion Methods
+    }
+}

From a4c62872aadcf74ddaff2fda854dedf927702c51 Mon Sep 17 00:00:00 2001
From: Kyle Lauffer <klauffer@andculture.com>
Date: Fri, 18 Mar 2022 17:10:17 -0400
Subject: [PATCH 2/2] Issue #34 and #17 Adding Async methods for
 BulkCreateAsync

---
 src/Conductors/RepositoryConductor.cs         |  68 +----
 src/Conductors/RepositoryConductorAsync.cs    |  78 +++++
 src/Conductors/RepositoryCreateConductor.cs   |  39 +--
 .../RepositoryCreateConductorAsync.cs         |  46 +++
 .../Conductors/IRepositoryCreateConductor.cs  |   9 +-
 .../IRepositoryCreateConductorAsync.cs        |  20 ++
 src/Core/Interfaces/Data/IRepository.cs       |   2 +-
 src/Core/Interfaces/Data/IRepositoryAsync.cs  | 273 +-----------------
 .../BulkCreateAsyncShould.cs                  |  63 ++++
 .../IRepositoryMock.cs                        |  24 ++
 10 files changed, 250 insertions(+), 372 deletions(-)
 create mode 100644 src/Conductors/RepositoryConductorAsync.cs
 create mode 100644 src/Conductors/RepositoryCreateConductorAsync.cs
 create mode 100644 src/Core/Interfaces/Conductors/IRepositoryCreateConductorAsync.cs
 create mode 100644 test/Conductors.Tests/RepositoryConductorTests/BulkCreateAsyncShould.cs
 create mode 100644 test/Conductors.Tests/RepositoryConductorTests/IRepositoryMock.cs

diff --git a/src/Conductors/RepositoryConductor.cs b/src/Conductors/RepositoryConductor.cs
index 9c7279d..98a9187 100644
--- a/src/Conductors/RepositoryConductor.cs
+++ b/src/Conductors/RepositoryConductor.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core;
 using AndcultureCode.CSharp.Core.Extensions;
 using AndcultureCode.CSharp.Core.Interfaces;
@@ -14,71 +15,9 @@ namespace AndcultureCode.CSharp.Conductors
     /// Provides CRUD operations on a given repository
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public class RepositoryConductor<T> : Conductor, IRepositoryConductor<T>
+    public partial class RepositoryConductor<T> : Conductor, IRepositoryConductor<T>
     where T : Entity
     {
-        #region Properties
-
-        /// <summary>
-        /// Ability to set and get the underlying repository's command timeout
-        /// </summary>
-        public int? CommandTimeout
-        {
-            get => _readConductor.CommandTimeout;
-            set
-            {
-                _createConductor.CommandTimeout = value;
-                _deleteConductor.CommandTimeout = value;
-                _readConductor.CommandTimeout   = value;
-                _updateConductor.CommandTimeout = value;
-            }
-        }
-
-        /// <summary>
-        /// Conductor property to create an entity or entities
-        /// </summary>
-        protected readonly IRepositoryCreateConductor<T> _createConductor;
-
-        /// <summary>
-        /// Conductor property to get an entity or entities
-        /// </summary>
-        protected readonly IRepositoryReadConductor<T>   _readConductor;
-
-        /// <summary>
-        /// Conductor property to update an entity or entities
-        /// </summary>
-        protected readonly IRepositoryUpdateConductor<T> _updateConductor;
-
-        /// <summary>
-        /// Conductor property to delete an entity or entities
-        /// </summary>
-        protected readonly IRepositoryDeleteConductor<T> _deleteConductor;
-
-        #endregion Properties
-
-        #region Constructor
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="createConductor">The conductor instance that should be used to perform create operations</param>
-        /// <param name="readConductor">The conductor instance that should be used to perform read operations</param>
-        /// <param name="updateConductor">The conductor instance that should be used to perform update operations</param>
-        /// <param name="deleteConductor">The conductor instance that should be used to perform delete operations</param>
-        public RepositoryConductor(
-            IRepositoryCreateConductor<T> createConductor,
-            IRepositoryReadConductor<T>   readConductor,
-            IRepositoryUpdateConductor<T> updateConductor,
-            IRepositoryDeleteConductor<T> deleteConductor)
-        {
-            _createConductor = createConductor;
-            _readConductor   = readConductor;
-            _updateConductor = updateConductor;
-            _deleteConductor = deleteConductor;
-        }
-
-        #endregion Constructor
-
         #region Public Methods
 
         #region Create
@@ -88,7 +27,8 @@ public RepositoryConductor(
         /// </summary>
         /// <param name="items">List of items to create</param>
         /// <param name="createdById">Id of user creating the items</param>
-        /// <returns></returns>
+        /// <returns>A collection of the created items</returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         public virtual IResult<List<T>> BulkCreate(IEnumerable<T> items, long? createdById = default(long?)) => _createConductor.BulkCreate(items, createdById);
 
         /// <summary>
diff --git a/src/Conductors/RepositoryConductorAsync.cs b/src/Conductors/RepositoryConductorAsync.cs
new file mode 100644
index 0000000..ce30201
--- /dev/null
+++ b/src/Conductors/RepositoryConductorAsync.cs
@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using AndcultureCode.CSharp.Core.Interfaces;
+using AndcultureCode.CSharp.Core.Interfaces.Conductors;
+using AndcultureCode.CSharp.Core.Models.Entities;
+
+namespace AndcultureCode.CSharp.Conductors
+{
+    public partial class RepositoryConductor<T> : Conductor, IRepositoryConductor<T>
+    where T : Entity
+    {
+        #region Properties
+
+        /// <summary>
+        /// Ability to set and get the underlying repository's command timeout
+        /// </summary>
+        public int? CommandTimeout
+        {
+            get => _readConductor.CommandTimeout;
+            set
+            {
+                _createConductor.CommandTimeout = value;
+                _deleteConductor.CommandTimeout = value;
+                _readConductor.CommandTimeout = value;
+                _updateConductor.CommandTimeout = value;
+            }
+        }
+
+        /// <summary>
+        /// Conductor property to create an entity or entities
+        /// </summary>
+        protected readonly IRepositoryCreateConductor<T> _createConductor;
+
+        /// <summary>
+        /// Conductor property to get an entity or entities
+        /// </summary>
+        protected readonly IRepositoryReadConductor<T> _readConductor;
+
+        /// <summary>
+        /// Conductor property to update an entity or entities
+        /// </summary>
+        protected readonly IRepositoryUpdateConductor<T> _updateConductor;
+
+        /// <summary>
+        /// Conductor property to delete an entity or entities
+        /// </summary>
+        protected readonly IRepositoryDeleteConductor<T> _deleteConductor;
+
+        #endregion Properties
+
+        #region Constructor
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="createConductor">The conductor instance that should be used to perform create operations</param>
+        /// <param name="readConductor">The conductor instance that should be used to perform read operations</param>
+        /// <param name="updateConductor">The conductor instance that should be used to perform update operations</param>
+        /// <param name="deleteConductor">The conductor instance that should be used to perform delete operations</param>
+        public RepositoryConductor(
+            IRepositoryCreateConductor<T> createConductor,
+            IRepositoryReadConductor<T> readConductor,
+            IRepositoryUpdateConductor<T> updateConductor,
+            IRepositoryDeleteConductor<T> deleteConductor)
+        {
+            _createConductor = createConductor;
+            _readConductor = readConductor;
+            _updateConductor = updateConductor;
+            _deleteConductor = deleteConductor;
+        }
+
+        #endregion Constructor
+
+
+        public Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null) => 
+            _createConductor.BulkCreateAsync(items, createdById);
+    }
+}
diff --git a/src/Conductors/RepositoryCreateConductor.cs b/src/Conductors/RepositoryCreateConductor.cs
index 6488a1a..03deac9 100644
--- a/src/Conductors/RepositoryCreateConductor.cs
+++ b/src/Conductors/RepositoryCreateConductor.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core.Interfaces;
 using AndcultureCode.CSharp.Core.Interfaces.Conductors;
 using AndcultureCode.CSharp.Core.Interfaces.Data;
@@ -11,47 +12,13 @@ namespace AndcultureCode.CSharp.Conductors
     /// Ability to create an entity or multiple entities
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public class RepositoryCreateConductor<T> : Conductor, IRepositoryCreateConductor<T>
+    public partial class RepositoryCreateConductor<T> : Conductor, IRepositoryCreateConductor<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
-
-        #region Constructor
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="repository"></param>
-        public RepositoryCreateConductor(
-            IRepository<T> repository
-            )
-        {
-            _repository = repository;
-        }
-
-        #endregion
 
         #region IRepositoryCreateConductor
 
-        /// <summary>
-        /// Ability to create entities using a list in a single bulk operation.
-        /// </summary>
-        /// <param name="items">List of items to create</param>
-        /// <param name="createdById">Id of user creating the items</param>
-        /// <returns></returns>
+        /// <inheritdoc />
         public virtual IResult<List<T>> BulkCreate(IEnumerable<T> items, long? createdById = default(long?))
         {
             return _repository.BulkCreate(items, createdById);
diff --git a/src/Conductors/RepositoryCreateConductorAsync.cs b/src/Conductors/RepositoryCreateConductorAsync.cs
new file mode 100644
index 0000000..40c6417
--- /dev/null
+++ b/src/Conductors/RepositoryCreateConductorAsync.cs
@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+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 RepositoryCreateConductor<T> : Conductor, IRepositoryCreateConductor<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 RepositoryCreateConductor(
+            IRepository<T> repository
+            )
+        {
+            _repository = repository;
+        }
+
+        /// <inheritdoc />
+        public virtual Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null) 
+        {
+            if(items == null) throw new ArgumentNullException(nameof(items));
+            if(!items.Any()) throw new ArgumentException("An empty collection was provided", nameof(items));
+            return _repository.BulkCreateAsync(items, createdById);
+        }
+    }
+}
diff --git a/src/Core/Interfaces/Conductors/IRepositoryCreateConductor.cs b/src/Core/Interfaces/Conductors/IRepositoryCreateConductor.cs
index bab32a4..99268d4 100644
--- a/src/Core/Interfaces/Conductors/IRepositoryCreateConductor.cs
+++ b/src/Core/Interfaces/Conductors/IRepositoryCreateConductor.cs
@@ -4,7 +4,7 @@
 
 namespace AndcultureCode.CSharp.Core.Interfaces.Conductors
 {
-    public interface IRepositoryCreateConductor<T>
+    public partial interface IRepositoryCreateConductor<T>
         where T : class, IEntity
     {
          #region Properties
@@ -19,6 +19,13 @@ public interface IRepositoryCreateConductor<T>
 
         #region Methods
 
+        /// <summary>
+        /// Ability to create entities using a list in a single bulk operation.
+        /// </summary>
+        /// <param name="items">List of items to create</param>
+        /// <param name="createdById">Id of user creating the items</param>
+        /// <returns></returns>
+        [Obsolete("This method is deprecated in favor of its async counter part", false)]
         IResult<List<T>> BulkCreate(IEnumerable<T> items, long? createdById = null);
 
         /// <summary>
diff --git a/src/Core/Interfaces/Conductors/IRepositoryCreateConductorAsync.cs b/src/Core/Interfaces/Conductors/IRepositoryCreateConductorAsync.cs
new file mode 100644
index 0000000..fa2d21e
--- /dev/null
+++ b/src/Core/Interfaces/Conductors/IRepositoryCreateConductorAsync.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using AndcultureCode.CSharp.Core.Interfaces.Entity;
+
+namespace AndcultureCode.CSharp.Core.Interfaces.Conductors
+{
+    public partial interface IRepositoryCreateConductor<T>
+        where T : class, IEntity
+    {
+        /// <summary>
+        /// Ability to asynchronously create entities using a list in a single bulk operation.
+        /// </summary>
+        /// <param name="items">List of items to create</param>
+        /// <param name="createdById">Id of user creating the items</param>
+        /// <returns>A collection of the created items</returns>
+        Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null);
+    }
+}
diff --git a/src/Core/Interfaces/Data/IRepository.cs b/src/Core/Interfaces/Data/IRepository.cs
index 9f196fb..c431ca9 100644
--- a/src/Core/Interfaces/Data/IRepository.cs
+++ b/src/Core/Interfaces/Data/IRepository.cs
@@ -10,7 +10,7 @@ namespace AndcultureCode.CSharp.Core.Interfaces.Data
     ///
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public interface IRepository<T>
+    public partial interface IRepository<T>
         where T : class, IEntity
     {
         #region Properties
diff --git a/src/Core/Interfaces/Data/IRepositoryAsync.cs b/src/Core/Interfaces/Data/IRepositoryAsync.cs
index 9661628..4169d2b 100644
--- a/src/Core/Interfaces/Data/IRepositoryAsync.cs
+++ b/src/Core/Interfaces/Data/IRepositoryAsync.cs
@@ -1,286 +1,19 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using AndcultureCode.CSharp.Core.Interfaces.Entity;
 
 namespace AndcultureCode.CSharp.Core.Interfaces.Data
 {
-    public interface IRepositoryAsync<T>
+    public partial interface IRepository<T>
         where T : class, IEntity
     {
-        #region Properties
-
-        /// <summary>
-        /// Ability to set and get the underlying DbContext's command timeout
-        /// </summary>
-        int? CommandTimeout { get; set; }
-
-        #endregion Properties
-
-
-        #region Methods
-
         /// <summary>
         /// Perform a DbContext.BulkInsert on an enumeration of T within a single transaction
         /// </summary>
         /// <param name="items"></param>
         /// <param name="createdById"></param>
         /// <returns></returns>
-        Task<IResult<List<T>>> BulkCreate(IEnumerable<T> items, long? createdById = null);
-
-        /// <summary>
-        /// Calls BulkCreate() with a de-duped list of objects as determined by the
-        /// property (or properties) of the object for the 'property' argument
-        /// NOTE: Bulking is generally faster than batching, but locks the table.
-        /// </summary>
-        /// <param name="items">List of items to attempt to create</param>
-        /// <param name="property">Property or properties of the typed object to determine distinctness</param>
-        /// <param name="createdById">Id of the user creating the entity</param>
-        /// <typeparam name="TKey"></typeparam>
-        /// <returns></returns>
-
-        /// <summary>
-        /// Calls BulkCreate() after selecting a subset of 'items' based on the distinct value of 'property'
-        /// </summary>
-        /// <param name="items"></param>
-        /// <param name="property"></param>
-        /// <param name="createdById"></param>
-        /// <typeparam name="TKey"></typeparam>
-        /// <returns></returns>
-        Task<IResult<List<T>>> BulkCreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null);
-
-        /// <summary>
-        /// Calls BulkDelete() with a de-duped list of objects as determined by the
-        /// property (or properties) of the object for the 'property' argument
-        /// NOTE: Bulking is generally faster than batching, but locks the table.
-        /// </summary>
-        /// <param name="items"></param>
-        /// <param name="deletedById"></param>
-        /// <param name="soft"></param>
-        /// <returns></returns>
-        Task<IResult<bool>> BulkDelete(IEnumerable<T> items, long? deletedById = null, bool soft = true);
-
-        /// <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>
-        /// <returns></returns>
-        Task<IResult<bool>> BulkUpdate(IEnumerable<T> entities, long? updatedBy = default(long?));
-
-        /// <summary>
-        /// Ability to create an entity 
-        /// </summary>
-        /// <param name="item">Item to be created</param>
-        /// <param name="createdById">Id of user creating the item</param>
-        /// <returns></returns>
-        Task<IResult<T>> Create(T item, long? createdById = null);
-
-        /// <summary>
-        /// Ability to create entities individually using a list 
-        /// </summary>
-        /// <param name="items">List of items to be created</param>
-        /// <param name="createdById">Id of user creating the items</param>
-        /// <returns></returns>
-        Task<IResult<List<T>>> Create(IEnumerable<T> items, long? createdById = null);
-
-        /// <summary>
-        /// Calls batched overload of Create() with a de-duped list of objects as determined by the
-        /// property (or properties) of the object for the 'property' argument.
-        /// NOTE: Batching is generally slower than bulking, but does not lock the table.
-        /// </summary>
-        /// <param name="items">List of items to attempt to create</param>
-        /// <param name="property">Property or properties of the typed object to determine distinctness</param>
-        /// <param name="createdById">Id of the user creating the entity</param>
-        /// <typeparam name="TKey"></typeparam>
-        /// <returns></returns>
-        Task<IResult<List<T>>> CreateDistinct<TKey>(IEnumerable<T> items, Func<T, TKey> property, long? createdById = null);
-
-        /// <summary>
-        /// Ability to delete an entity using an Id
-        /// </summary>
-        /// <param name="id">Id of item to be deleted</param>
-        /// <param name="deletedById">Id of user deleting the item</param>
-        /// <param name="soft">Boolean flag for soft-deleting the item</param>
-        /// <returns></returns>
-        Task<IResult<bool>> Delete(long id, long? deletedById = null, bool soft = true);
-
-        /// <summary>
-        /// Ability to delete an entity using the entity itself
-        /// </summary>
-        /// <param name="o">Item to be deleted</param>
-        /// <param name="deletedById">Id of user deleting the item</param>
-        /// <param name="soft">Boolean flag for soft-deleting the item</param>
-        /// <returns></returns>
-        Task<IResult<bool>> Delete(T o, long? deletedById = null, bool soft = true);
-
-        /// <summary>
-        /// Ability to delete a list of entities by batch size.
-        /// </summary>
-        /// <param name="items">List of items to delete</param>
-        /// <param name="deletedById">Id of user deleting the items</param>
-        /// <param name="batchSize">Number of items to include in a batch, defaults to 100</param>
-        /// <param name="soft">Boolean flag for soft-deleting the items</param>
-        /// <returns></returns>
-        Task<IResult<bool>> Delete(IEnumerable<T> items, long? deletedById = null, long batchSize = 100, bool soft = true);
-
-        /// <summary>
-        /// Find all filtered, sorted and paged
-        /// </summary>
-        /// <param name="filter"></param>
-        /// <param name="orderBy"></param>
-        /// <param name="includeProperties"></param>
-        /// <param name="skip"></param>
-        /// <param name="take"></param>
-        /// <param name="ignoreQueryFilters"></param>
-        /// <param name="asNoTracking"></param>
-        /// <returns></returns>
-        Task<IResult<IQueryable<T>>> FindAll(
-            Expression<Func<T, bool>> filter = null,
-            Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null,
-            string includeProperties = null,
-            int? skip = null,
-            int? take = null,
-            bool? ignoreQueryFilters = false,
-            bool asNoTracking = false
-        );
-
-        /// <summary>
-        /// Configure lazy loaded queryable, given provided parameters, to load a list of <typeparamref name="T"/> grouped by a <typeparamref name="TKey"/>
-        /// </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="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>
-        Task<IResult<IQueryable<IGrouping<TKey, T>>>> FindAll<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 = default(int?),
-            int? take = default(int?),
-            bool? ignoreQueryFilters = false,
-            bool asNoTracking = false
-        );
-
-        /// <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>
-        Task<IResult<IQueryable<TResult>>> FindAll<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
-        );
-
-        /// <summary>
-        /// Find all filtered, sorted and paged and converts to an IList<T>
-        /// </summary>
-        /// <param name="filter"></param>
-        /// <param name="orderBy"></param>
-        /// <param name="includeProperties"></param>
-        /// <param name="skip"></param>
-        /// <param name="take"></param>
-        /// <param name="ignoreQueryFilters"></param>
-        /// <returns></returns>
-        Task<IResult<IList<T>>> FindAllCommitted(Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, string includeProperties = null, int? skip = null, int? take = null, bool? ignoreQueryFilters = false);
-
-        /// <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>
-        /// <returns>The entity with the provided identity value.</returns>
-        Task<IResult<T>> FindById(long id, bool? ignoreQueryFilters = false);
-
-        /// <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 witht he provided identity value and filter condition met.</returns>
-        Task<IResult<T>> FindById(long id, Expression<Func<T, bool>> 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>
-        Task<IResult<T>> FindById(long id, params Expression<Func<T, object>>[] 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>
-        Task<IResult<T>> FindById(long id, bool? ignoreQueryFilters = false, params Expression<Func<T, object>>[] 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>
-        Task<IResult<T>> FindById(long id, params string[] includeProperties);
-
-        /// <summary>
-        /// Ability to restore a soft-deleted entity using the entity itself. 
-        /// </summary>
-        /// <param name="o">Entity to be restored</param>
-        /// <returns></returns>
-        Task<IResult<bool>> Restore(T o);
-
-        /// <summary>
-        /// Ability to restore a soft-deleted entity using the entity id.
-        /// </summary>
-        /// <param name="id">Id of entity to be restored</param>
-        /// <returns></returns>
-        Task<IResult<bool>> Restore(long id);
-
-        /// <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>
-        /// <returns></returns>
-        Task<IResult<bool>> Update(T item, long? updatedBy = null);
-
-        /// <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>
-        /// <returns>True if entities updated without any exceptions. False if an exception was thrown.</returns>
-        Task<IResult<bool>> Update(IEnumerable<T> entities, long? updatedBy = default(long?));
+        Task<IResult<List<T>>> BulkCreateAsync(IEnumerable<T> items, long? createdById = null);
 
-        #endregion Methods
     }
 }
diff --git a/test/Conductors.Tests/RepositoryConductorTests/BulkCreateAsyncShould.cs b/test/Conductors.Tests/RepositoryConductorTests/BulkCreateAsyncShould.cs
new file mode 100644
index 0000000..1263ec8
--- /dev/null
+++ b/test/Conductors.Tests/RepositoryConductorTests/BulkCreateAsyncShould.cs
@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using System.Linq;
+using AndcultureCode.CSharp.Core.Interfaces.Conductors;
+using AndcultureCode.CSharp.Testing.Extensions;
+using AndcultureCode.CSharp.Testing.Tests;
+using Moq;
+using Shouldly;
+using Xunit;
+using Xunit.Abstractions;
+using System.Linq.Expressions;
+using System;
+using AndcultureCode.CSharp.Testing.Models.Stubs;
+using System.Threading.Tasks;
+
+namespace AndcultureCode.CSharp.Conductors.Tests.RepositoryConductorTests
+{
+    public class BulkCreateAsyncShould : ProjectUnitTest
+    {
+        #region Setup
+
+        public BulkCreateAsyncShould(ITestOutputHelper output) : base(output)
+        {
+        }
+
+        private IRepositoryConductor<UserStub> SetupSut(
+            IRepositoryMock<UserStub> repositoryMock
+        )
+        {
+            var repositoryCreateConductor = new RepositoryCreateConductor<UserStub>(repositoryMock.Object);
+            return new RepositoryConductor<UserStub>(
+                createConductor: repositoryCreateConductor,
+                deleteConductor: null,
+                readConductor: null,
+                updateConductor: null
+            );
+        }
+
+        #endregion Setup
+
+        [Fact]
+        public async Task Throw_Argument_Null_Exception_When_Given_Null_Input()
+        {
+            // Arrange 
+            var repositoryMock = new IRepositoryMock<UserStub>();
+            var respositoryConductor = SetupSut(repositoryMock);
+
+            // Act & Assert
+            await Assert.ThrowsAsync<ArgumentNullException>(() => respositoryConductor.BulkCreateAsync(null));
+        }
+
+        [Fact]
+        public async Task Throw_Argument_Exception_When_Given_Empty_Input()
+        {
+            // Arrange 
+            var repositoryMock = new IRepositoryMock<UserStub>();
+            var respositoryConductor = SetupSut(repositoryMock);
+
+            // Act & Assert
+            await Assert.ThrowsAsync<ArgumentException>(() => respositoryConductor.BulkCreateAsync(new List<UserStub>()));
+        }
+
+    }
+}
diff --git a/test/Conductors.Tests/RepositoryConductorTests/IRepositoryMock.cs b/test/Conductors.Tests/RepositoryConductorTests/IRepositoryMock.cs
new file mode 100644
index 0000000..a26c13f
--- /dev/null
+++ b/test/Conductors.Tests/RepositoryConductorTests/IRepositoryMock.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+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;
+using Moq;
+
+namespace AndcultureCode.CSharp.Conductors.Tests.RepositoryConductorTests
+{
+
+
+    internal sealed class IRepositoryMock<T> : Mock<IRepository<T>>
+        where T : class, IEntity
+    {
+        public IRepositoryMock<T> BulkCreateAsync(IResult<List<T>> output, Action<long> callback)
+        {
+            Setup(x => x.BulkCreateAsync(It.IsAny<IEnumerable<T>>(), null))
+                .Returns(Task.FromResult(output));
+            return this;
+        }
+    }
+}