From a7391e06f83f198eabdf2c88889d833453ae69fa Mon Sep 17 00:00:00 2001
From: Alexandre SPIESER <a.spieser@gmail.com>
Date: Thu, 11 Apr 2019 23:59:34 +0100
Subject: [PATCH 1/4] first step to split function into separate classes for
 better reuse and easier maintenance.

---
 .../MongoDbTKeyDocumentTestBase.cs            |   1 +
 .../IKeyTypedReadOnlyMongoRepository.cs       |   3 +-
 .../IMongoDbCollectionIndexRepository.cs      |  99 +----
 .../BaseMongoDbIndexRepository.cs             | 230 ++++++++++
 .../BaseMongoDbRepository.IndexManagement.cs  | 106 +----
 .../BaseMongoDbRepository.cs                  | 379 ++++++-----------
 ...epository.cs => BaseReadOnlyRepository.cs} | 224 +++++-----
 .../DataAccess/Base/DataAccessBase.cs         | 158 +++++++
 .../DataAccess/Create/MongoDbCreator.cs       | 142 +++++++
 .../DataAccess/Delete/MongoDbEraser.cs        | 180 ++++++++
 .../DataAccess/Read/MongoDbReader.cs          | 393 ++++++++++++++++++
 .../DataAccess/Update/MongoDbUpdater.cs       | 190 +++++++++
 .../KeyTypedBaseMongoDbRepository.cs          | 239 ++++++++---
 .../KeyTypedReadOnlyMongoRepository.cs        | 154 ++++---
 MongoDbGenericRepository/MongoDbContext.cs    |  69 +--
 .../ReadOnlyMongoRepository.cs                | 356 ++++++++++++++++
 16 files changed, 2189 insertions(+), 734 deletions(-)
 create mode 100644 MongoDbGenericRepository/BaseMongoDbIndexRepository.cs
 rename MongoDbGenericRepository/{BaseRepository.cs => BaseReadOnlyRepository.cs} (84%)
 create mode 100644 MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs
 create mode 100644 MongoDbGenericRepository/DataAccess/Create/MongoDbCreator.cs
 create mode 100644 MongoDbGenericRepository/DataAccess/Delete/MongoDbEraser.cs
 create mode 100644 MongoDbGenericRepository/DataAccess/Read/MongoDbReader.cs
 create mode 100644 MongoDbGenericRepository/DataAccess/Update/MongoDbUpdater.cs

diff --git a/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.cs b/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.cs
index e4b0843..e048f14 100644
--- a/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.cs
+++ b/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.cs
@@ -1119,6 +1119,7 @@ namespace CoreIntegrationTests.Infrastructure
         #endregion Math
 
         #region Test Utils
+
         [MethodImpl(MethodImplOptions.NoInlining)]
         private string GetCurrentMethod()
         {
diff --git a/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs b/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs
index a2b42c1..2b73f76 100644
--- a/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs
@@ -7,8 +7,7 @@ using MongoDbGenericRepository.Models;
 
 namespace MongoDbGenericRepository
 {
-    public interface IKeyTypedReadOnlyMongoRepository<TKey> : IBaseReadOnlyRepository 
-        where TKey : IEquatable<TKey>
+    public interface IKeyTypedReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
     {
         #region Read
 
diff --git a/MongoDbGenericRepository/Abstractions/IMongoDbCollectionIndexRepository.cs b/MongoDbGenericRepository/Abstractions/IMongoDbCollectionIndexRepository.cs
index 01c0add..3fa09b9 100644
--- a/MongoDbGenericRepository/Abstractions/IMongoDbCollectionIndexRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IMongoDbCollectionIndexRepository.cs
@@ -9,7 +9,7 @@ namespace MongoDbGenericRepository
     /// <summary>
     /// The repository interface for managing indexes
     /// </summary>
-    public interface IMongoDbCollectionIndexRepository
+    public interface IMongoDbCollectionIndexRepository : IBaseMongoDbIndexRepository
     {
         /// <summary>
         /// Create a text index on the given field.
@@ -24,21 +24,6 @@ namespace MongoDbGenericRepository
         Task<string> CreateTextIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument;
 
-        /// <summary>
-        /// Create a text index on the given field.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateTextIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
         /// <summary>
         /// Creates an index on the given field in ascending order.
         /// IndexCreationOptions can be supplied to further specify 
@@ -51,21 +36,6 @@ namespace MongoDbGenericRepository
         /// <returns>The result of the create index operation.</returns>
         Task<string> CreateAscendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null) where TDocument : IDocument;
 
-        /// <summary>
-        /// Creates an index on the given field in ascending order.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateAscendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
         /// <summary>
         /// Creates an index on the given field in descending order.
         /// IndexCreationOptions can be supplied to further specify 
@@ -79,21 +49,6 @@ namespace MongoDbGenericRepository
         Task<string> CreateDescendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument;
 
-        /// <summary>
-        /// Creates an index on the given field in descending order.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateDescendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
         /// <summary>
         /// Creates a hashed index on the given field.
         /// IndexCreationOptions can be supplied to further specify 
@@ -107,21 +62,6 @@ namespace MongoDbGenericRepository
         Task<string> CreateHashedIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument;
 
-        /// <summary>
-        /// Creates a hashed index on the given field.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateHashedIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
         /// <summary>
         /// Creates a combined text index.
         /// IndexCreationOptions can be supplied to further specify 
@@ -135,21 +75,6 @@ namespace MongoDbGenericRepository
         Task<string> CreateCombinedTextIndexAsync<TDocument>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument;
 
-        /// <summary>
-        /// Creates a combined text index.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="fields">The fields we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateCombinedTextIndexAsync<TDocument, TKey>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
         /// <summary>
         /// Drops the index given a field name
         /// </summary>
@@ -159,17 +84,6 @@ namespace MongoDbGenericRepository
         Task DropIndexAsync<TDocument>(string indexName, string partitionKey = null)
             where TDocument : IDocument;
 
-        /// <summary>
-        /// Drops the index given a field name
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="indexName">The name of the index</param>
-        /// <param name="partitionKey">An optional partition key</param>
-        Task DropIndexAsync<TDocument, TKey>(string indexName, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
         /// <summary>
         /// Returns the names of the indexes present on a collection.
         /// </summary>
@@ -178,16 +92,5 @@ namespace MongoDbGenericRepository
         /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
         Task<List<string>> GetIndexesNamesAsync<TDocument>(string partitionKey = null)
             where TDocument : IDocument;
-
-        /// <summary>
-        /// Returns the names of the indexes present on a collection.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="partitionKey">An optional partition key</param>
-        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
-        Task<List<string>> GetIndexesNamesAsync<TDocument, TKey>(string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
     }
 }
diff --git a/MongoDbGenericRepository/BaseMongoDbIndexRepository.cs b/MongoDbGenericRepository/BaseMongoDbIndexRepository.cs
new file mode 100644
index 0000000..8edd0a7
--- /dev/null
+++ b/MongoDbGenericRepository/BaseMongoDbIndexRepository.cs
@@ -0,0 +1,230 @@
+using MongoDB.Driver;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository
+{
+    public interface IBaseMongoDbIndexRepository
+    {
+        /// <summary>
+        /// Create a text index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateTextIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Creates an index on the given field in ascending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateAscendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Creates an index on the given field in descending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateDescendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Creates a hashed index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateHashedIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Creates a combined text index.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="fields">The fields we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateCombinedTextIndexAsync<TDocument, TKey>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Drops the index given a field name
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="indexName">The name of the index</param>
+        /// <param name="partitionKey">An optional partition key</param>
+        Task DropIndexAsync<TDocument, TKey>(string indexName, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns the names of the indexes present on a collection.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="partitionKey">An optional partition key</param>
+        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
+        Task<List<string>> GetIndexesNamesAsync<TDocument, TKey>(string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+    }
+
+    public class BaseMongoDbIndexRepository : BaseReadOnlyRepository, IBaseMongoDbIndexRepository
+    {
+        /// <summary>
+        /// The constructor taking a connection string and a database name.
+        /// </summary>
+        /// <param name="connectionString">The connection string of the MongoDb server.</param>
+        /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
+        protected BaseMongoDbIndexRepository(string connectionString, string databaseName = null) : base(connectionString, databaseName)
+        {
+        }
+
+        /// <summary>
+        /// The contructor taking a <see cref="IMongoDbContext"/>.
+        /// </summary>
+        /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
+        protected BaseMongoDbIndexRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        {
+        }
+
+        /// <summary>
+        /// The contructor taking a <see cref="IMongoDatabase"/>.
+        /// </summary>
+        /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
+        protected BaseMongoDbIndexRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
+        {
+        }
+
+        #region Index Management TKey
+
+        /// <inheritdoc />
+        public async virtual Task<List<string>> GetIndexesNamesAsync<TDocument, TKey>(string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var indexCursor = await HandlePartitioned<TDocument, TKey>(partitionKey).Indexes.ListAsync();
+            var indexes = await indexCursor.ToListAsync();
+            return indexes.Select(e => e["name"].ToString()).ToList();
+        }
+
+        /// <inheritdoc />
+        public async virtual Task<string> CreateTextIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await HandlePartitioned<TDocument, TKey>(partitionKey).Indexes
+                                                                   .CreateOneAsync(
+                                                                     new CreateIndexModel<TDocument>(
+                                                                     Builders<TDocument>.IndexKeys.Text(field),
+                                                                     indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions)
+                                                                   ));
+        }
+
+        /// <inheritdoc />
+        public async virtual Task<string> CreateAscendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var collection = HandlePartitioned<TDocument, TKey>(partitionKey);
+            var createOptions = indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions);
+            var indexKey = Builders<TDocument>.IndexKeys;
+            return await collection.Indexes
+                                   .CreateOneAsync(
+                new CreateIndexModel<TDocument>(indexKey.Ascending(field), createOptions));
+        }
+
+        /// <inheritdoc />
+        public async virtual Task<string> CreateDescendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var collection = HandlePartitioned<TDocument, TKey>(partitionKey);
+            var createOptions = indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions);
+            var indexKey = Builders<TDocument>.IndexKeys;
+            return await collection.Indexes
+                                   .CreateOneAsync(
+                new CreateIndexModel<TDocument>(indexKey.Descending(field), createOptions));
+        }
+
+
+        /// <inheritdoc />
+        public async virtual Task<string> CreateHashedIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var collection = HandlePartitioned<TDocument, TKey>(partitionKey);
+            var createOptions = indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions);
+            var indexKey = Builders<TDocument>.IndexKeys;
+            return await collection.Indexes
+                                   .CreateOneAsync(
+                new CreateIndexModel<TDocument>(indexKey.Hashed(field), createOptions));
+        }
+
+        /// <inheritdoc />
+        public async virtual Task<string> CreateCombinedTextIndexAsync<TDocument, TKey>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var collection = HandlePartitioned<TDocument, TKey>(partitionKey);
+            var createOptions = indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions);
+            var listOfDefs = new List<IndexKeysDefinition<TDocument>>();
+            foreach (var field in fields)
+            {
+                listOfDefs.Add(Builders<TDocument>.IndexKeys.Text(field));
+            }
+            return await collection.Indexes
+                                   .CreateOneAsync(new CreateIndexModel<TDocument>(Builders<TDocument>.IndexKeys.Combine(listOfDefs), createOptions));
+        }
+
+        /// <inheritdoc />
+        public async virtual Task DropIndexAsync<TDocument, TKey>(string indexName, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            await HandlePartitioned<TDocument, TKey>(partitionKey).Indexes.DropOneAsync(indexName);
+        }
+
+        #endregion Index Management TKey
+
+    }
+}
diff --git a/MongoDbGenericRepository/BaseMongoDbRepository.IndexManagement.cs b/MongoDbGenericRepository/BaseMongoDbRepository.IndexManagement.cs
index 440e143..b82294f 100644
--- a/MongoDbGenericRepository/BaseMongoDbRepository.IndexManagement.cs
+++ b/MongoDbGenericRepository/BaseMongoDbRepository.IndexManagement.cs
@@ -23,38 +23,12 @@ namespace MongoDbGenericRepository
             return await CreateTextIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
         }
 
-        /// <inheritdoc />
-        public async Task<string> CreateTextIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await HandlePartitioned<TDocument, TKey>(partitionKey).Indexes
-                                                                   .CreateOneAsync(
-                                                                     new CreateIndexModel<TDocument>(
-                                                                     Builders<TDocument>.IndexKeys.Text(field),
-                                                                     indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions)
-                                                                   ));
-        }
-
         /// <inheritdoc />
         public async Task<string> CreateAscendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null) where TDocument : IDocument
         {
             return await CreateAscendingIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
         }
 
-        /// <inheritdoc />
-        public async Task<string> CreateAscendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var collection = HandlePartitioned<TDocument, TKey>(partitionKey);
-            var createOptions = indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions);
-            var indexKey = Builders<TDocument>.IndexKeys;
-            return await collection.Indexes
-                                   .CreateOneAsync(
-                new CreateIndexModel<TDocument>(indexKey.Ascending(field), createOptions));
-        }
-
         /// <inheritdoc />
         public async Task<string> CreateDescendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument
@@ -62,18 +36,6 @@ namespace MongoDbGenericRepository
             return await CreateDescendingIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
         }
 
-        /// <inheritdoc />
-        public async Task<string> CreateDescendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var collection = HandlePartitioned<TDocument, TKey>(partitionKey);
-            var createOptions = indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions);
-            var indexKey = Builders<TDocument>.IndexKeys;
-            return await collection.Indexes
-                                   .CreateOneAsync(
-                new CreateIndexModel<TDocument>(indexKey.Descending(field), createOptions));
-        }
 
         /// <inheritdoc />
         public async Task<string> CreateHashedIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
@@ -82,40 +44,12 @@ namespace MongoDbGenericRepository
             return await CreateHashedIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
         }
 
-        /// <inheritdoc />
-        public async Task<string> CreateHashedIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var collection = HandlePartitioned<TDocument, TKey>(partitionKey);
-            var createOptions = indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions);
-            var indexKey = Builders<TDocument>.IndexKeys;
-            return await collection.Indexes
-                                   .CreateOneAsync(
-                new CreateIndexModel<TDocument>(indexKey.Hashed(field), createOptions));
-        }
-
         /// <inheritdoc />
         public async Task<string> CreateCombinedTextIndexAsync<TDocument>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null) where TDocument : IDocument
         {
             return await CreateCombinedTextIndexAsync<TDocument, Guid>(fields, indexCreationOptions, partitionKey);
         }
 
-        /// <inheritdoc />
-        public async Task<string> CreateCombinedTextIndexAsync<TDocument, TKey>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var collection = HandlePartitioned<TDocument, TKey>(partitionKey);
-            var createOptions = indexCreationOptions == null ? null : MapIndexOptions(indexCreationOptions);
-            var listOfDefs = new List<IndexKeysDefinition<TDocument>>();
-            foreach (var field in fields)
-            {
-                listOfDefs.Add(Builders<TDocument>.IndexKeys.Text(field));
-            }
-            return await collection.Indexes
-                                   .CreateOneAsync(new CreateIndexModel<TDocument>(Builders<TDocument>.IndexKeys.Combine(listOfDefs), createOptions));
-        }
 
         /// <inheritdoc />
         public async Task DropIndexAsync<TDocument>(string indexName, string partitionKey = null)
@@ -124,14 +58,6 @@ namespace MongoDbGenericRepository
             await DropIndexAsync<TDocument, Guid>(indexName, partitionKey);
         }
 
-        /// <inheritdoc />
-        public async Task DropIndexAsync<TDocument, TKey>(string indexName, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            await HandlePartitioned<TDocument, TKey>(partitionKey).Indexes.DropOneAsync(indexName);
-        }
-
         /// <inheritdoc />
         public async Task<List<string>> GetIndexesNamesAsync<TDocument>(string partitionKey = null)
             where TDocument : IDocument
@@ -139,38 +65,8 @@ namespace MongoDbGenericRepository
             return await GetIndexesNamesAsync<TDocument, Guid>(partitionKey);
         }
 
-        /// <inheritdoc />
-        public async Task<List<string>> GetIndexesNamesAsync<TDocument, TKey>(string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var indexCursor = await HandlePartitioned<TDocument, TKey>(partitionKey).Indexes.ListAsync();
-            var indexes = await indexCursor.ToListAsync();
-            return indexes.Select(e => e["name"].ToString()).ToList();
-        }
-
-
         #endregion Index Management
 
-        private CreateIndexOptions MapIndexOptions(IndexCreationOptions indexCreationOptions)
-        {
-            return new CreateIndexOptions
-            {
-                Unique = indexCreationOptions.Unique,
-                TextIndexVersion = indexCreationOptions.TextIndexVersion,
-                SphereIndexVersion = indexCreationOptions.SphereIndexVersion,
-                Sparse = indexCreationOptions.Sparse,
-                Name = indexCreationOptions.Name,
-                Min = indexCreationOptions.Min,
-                Max = indexCreationOptions.Max,
-                LanguageOverride = indexCreationOptions.LanguageOverride,
-                ExpireAfter = indexCreationOptions.ExpireAfter,
-                DefaultLanguage = indexCreationOptions.DefaultLanguage,
-                BucketSize = indexCreationOptions.BucketSize,
-                Bits = indexCreationOptions.Bits,
-                Background = indexCreationOptions.Background,
-                Version = indexCreationOptions.Version
-            };
-        }
+
     }
 }
\ No newline at end of file
diff --git a/MongoDbGenericRepository/BaseMongoDbRepository.cs b/MongoDbGenericRepository/BaseMongoDbRepository.cs
index db9dd3d..2fd1ad2 100644
--- a/MongoDbGenericRepository/BaseMongoDbRepository.cs
+++ b/MongoDbGenericRepository/BaseMongoDbRepository.cs
@@ -1,11 +1,13 @@
 using MongoDB.Driver;
+using MongoDbGenericRepository.DataAccess.Create;
+using MongoDbGenericRepository.DataAccess.Update;
+using MongoDbGenericRepository.Models;
+using MongoDbGenericRepository.Utils;
 using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
-using System.Linq.Expressions;
-using MongoDbGenericRepository.Models;
 using System.Linq;
-using MongoDbGenericRepository.Utils;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
@@ -15,6 +17,45 @@ namespace MongoDbGenericRepository
     /// </summary>
     public abstract partial class BaseMongoRepository : ReadOnlyMongoRepository, IBaseMongoRepository
     {
+        private object _initLock;
+        private MongoDbCreator _mongoDbCreator;
+        protected MongoDbCreator MongoDbCreator
+        {
+            get
+            {
+                if (_mongoDbCreator != null) { return _mongoDbCreator; }
+
+                lock (_initLock)
+                {
+                    if (_mongoDbCreator == null)
+                    {
+                        _mongoDbCreator = new MongoDbCreator(MongoDbContext);
+                    }
+                }
+
+                return _mongoDbCreator;
+            }
+        }
+
+        private MongoDbUpdater _mongoDbUpdater;
+        protected MongoDbUpdater MongoDbUpdater
+        {
+            get
+            {
+                if (_mongoDbUpdater != null) { return _mongoDbUpdater; }
+
+                lock (_initLock)
+                {
+                    if (_mongoDbUpdater == null)
+                    {
+                        _mongoDbUpdater = new MongoDbUpdater(MongoDbContext);
+                    }
+                }
+
+                return _mongoDbUpdater;
+            }
+        }
+
         /// <summary>
         /// The constructor taking a connection string and a database name.
         /// </summary>
@@ -40,94 +81,6 @@ namespace MongoDbGenericRepository
         {
         }
 
-        #region Create
-
-        /// <summary>
-        /// Asynchronously adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public virtual async Task AddOneAsync<TDocument>(TDocument document) where TDocument : IDocument
-        {
-            FormatDocument(document);
-            await HandlePartitioned(document).InsertOneAsync(document);
-        }
-
-        /// <summary>
-        /// Adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public virtual void AddOne<TDocument>(TDocument document) where TDocument : IDocument
-        {
-            FormatDocument(document);
-            HandlePartitioned(document).InsertOne(document);
-        }
-
-        /// <summary>
-        /// Asynchronously adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The documents you want to add.</param>
-        public virtual async Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument
-        {
-            if (!documents.Any())
-            {
-                return;
-            }
-            foreach (var document in documents)
-            {
-                FormatDocument(document);
-            }
-            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
-            if (documents.Any(e => e is IPartitionedDocument))
-            {
-                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
-                {
-                    await HandlePartitioned(group.FirstOrDefault()).InsertManyAsync(group.ToList());
-                }
-            }
-            else
-            {
-                await GetCollection<TDocument>().InsertManyAsync(documents.ToList());
-            }
-        }
-
-        /// <summary>
-        /// Adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The documents you want to add.</param>
-        public virtual void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument
-        {
-            if (!documents.Any())
-            {
-                return;
-            }
-            foreach (var document in documents)
-            {
-                FormatDocument(document);
-            }
-            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
-            if (documents.Any(e => e is IPartitionedDocument))
-            {
-                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
-                {
-                    HandlePartitioned(group.FirstOrDefault()).InsertMany(group.ToList());
-                }
-            }
-            else
-            {
-                GetCollection<TDocument>().InsertMany(documents.ToList());
-            }
-        }
-
-        #endregion Create
-
         #region Create TKey
 
         /// <summary>
@@ -141,8 +94,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            FormatDocument<TDocument, TKey>(document);
-            await HandlePartitioned<TDocument, TKey>(document).InsertOneAsync(document);
+            await MongoDbCreator.AddOneAsync<TDocument, TKey>(document);
         }
 
         /// <summary>
@@ -156,8 +108,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            FormatDocument<TDocument, TKey>(document);
-            HandlePartitioned<TDocument, TKey>(document).InsertOne(document);
+            MongoDbCreator.AddOne<TDocument, TKey>(document);
         }
 
         /// <summary>
@@ -171,26 +122,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            if (!documents.Any())
-            {
-                return;
-            }
-            foreach (var document in documents)
-            {
-                FormatDocument<TDocument, TKey>(document);
-            }
-            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
-            if (documents.Any(e => e is IPartitionedDocument))
-            {
-                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
-                {
-                    await HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).InsertManyAsync(group.ToList());
-                }
-            }
-            else
-            {
-                await GetCollection<TDocument, TKey>().InsertManyAsync(documents.ToList());
-            }
+            await MongoDbCreator.AddManyAsync<TDocument, TKey>(documents);
         }
 
         /// <summary>
@@ -204,26 +136,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            if (!documents.Any())
-            {
-                return;
-            }
-            foreach (var document in documents)
-            {
-                FormatDocument<TDocument, TKey>(document);
-            }
-            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
-            if (documents.Any(e => e is IPartitionedDocument))
-            {
-                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
-                {
-                    HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).InsertMany(group.ToList());
-                }
-            }
-            else
-            {
-                GetCollection<TDocument, TKey>().InsertMany(documents.ToList());
-            }
+            MongoDbCreator.AddMany<TDocument, TKey>(documents);
         }
 
         #endregion 
@@ -237,8 +150,7 @@ namespace MongoDbGenericRepository
         /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
         public virtual async Task<bool> UpdateOneAsync<TDocument>(TDocument modifiedDocument) where TDocument : IDocument
         {
-            var updateRes = await HandlePartitioned(modifiedDocument).ReplaceOneAsync(x => x.Id == modifiedDocument.Id, modifiedDocument);
-            return updateRes.ModifiedCount == 1;
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid>(modifiedDocument);
         }
 
         /// <summary>
@@ -248,8 +160,7 @@ namespace MongoDbGenericRepository
         /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
         public virtual bool UpdateOne<TDocument>(TDocument modifiedDocument) where TDocument : IDocument
         {
-            var updateRes = HandlePartitioned(modifiedDocument).ReplaceOne(x => x.Id == modifiedDocument.Id, modifiedDocument);
-            return updateRes.ModifiedCount == 1;
+            return MongoDbUpdater.UpdateOne<TDocument, Guid>(modifiedDocument);
         }
 
         /// <summary>
@@ -261,9 +172,20 @@ namespace MongoDbGenericRepository
         public virtual async Task<bool> UpdateOneAsync<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
             where TDocument : IDocument
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
-            var updateRes = await HandlePartitioned(documentToModify).UpdateOneAsync(filter, update);
-            return updateRes.ModifiedCount == 1;
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid>(documentToModify, update);
+
+        }
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        public virtual bool UpdateOne<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, Guid>(documentToModify, update);
         }
 
         /// <summary>
@@ -277,9 +199,7 @@ namespace MongoDbGenericRepository
         public virtual bool UpdateOne<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
             where TDocument : IDocument
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
-            var updateRes = HandlePartitioned(documentToModify).UpdateOne(filter, Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
+            return MongoDbUpdater.UpdateOne<TDocument, Guid, TField>(documentToModify, field, value);
         }
 
         /// <summary>
@@ -293,9 +213,7 @@ namespace MongoDbGenericRepository
         public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
             where TDocument : IDocument
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
-            var updateRes = await HandlePartitioned(documentToModify).UpdateOneAsync(filter, Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid, TField>(documentToModify, field, value);
         }
 
         /// <summary>
@@ -310,9 +228,7 @@ namespace MongoDbGenericRepository
         public virtual bool UpdateOne<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
             where TDocument : IDocument
         {
-            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument>() : GetCollection<TDocument>(partitionKey);
-            var updateRes = collection.UpdateOne(filter, Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
+            return MongoDbUpdater.UpdateOne<TDocument, Guid, TField>(filter, field, value, partitionKey);
         }
 
         /// <summary>
@@ -327,9 +243,7 @@ namespace MongoDbGenericRepository
         public virtual bool UpdateOne<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
             where TDocument : IDocument
         {
-            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument>() : GetCollection<TDocument>(partitionKey);
-            var updateRes = collection.UpdateOne(Builders<TDocument>.Filter.Where(filter), Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
+            return MongoDbUpdater.UpdateOne<TDocument, Guid, TField>(filter, field, value, partitionKey);
         }
 
         /// <summary>
@@ -344,9 +258,7 @@ namespace MongoDbGenericRepository
         public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
             where TDocument : IDocument
         {
-            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument>() : GetCollection<TDocument>(partitionKey);
-            var updateRes = await collection.UpdateOneAsync(filter, Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid, TField>(filter, field, value, partitionKey);
         }
 
         /// <summary>
@@ -361,24 +273,9 @@ namespace MongoDbGenericRepository
         public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
             where TDocument : IDocument
         {
-            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument>() : GetCollection<TDocument>(partitionKey);
-            var updateRes = await collection.UpdateOneAsync(Builders<TDocument>.Filter.Where(filter), Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid, TField>(filter, field, value, partitionKey);
         }
 
-        /// <summary>
-        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="update">The update definition for the document.</param>
-        public virtual bool UpdateOne<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
-            where TDocument : IDocument
-        {
-            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
-            var updateRes = HandlePartitioned(documentToModify).UpdateOne(filter, update, new UpdateOptions { IsUpsert = true });
-            return updateRes.ModifiedCount == 1;
-        }
 
         #endregion Update
 
@@ -394,9 +291,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", modifiedDocument.Id);
-            var updateRes = await HandlePartitioned<TDocument, TKey>(modifiedDocument).ReplaceOneAsync(filter, modifiedDocument);
-            return updateRes.ModifiedCount == 1;
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey>(modifiedDocument);
         }
 
         /// <summary>
@@ -409,9 +304,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", modifiedDocument.Id);
-            var updateRes = HandlePartitioned<TDocument, TKey>(modifiedDocument).ReplaceOne(filter, modifiedDocument);
-            return updateRes.ModifiedCount == 1;
+            return MongoDbUpdater.UpdateOne<TDocument, TKey>(modifiedDocument);
         }
 
         /// <summary>
@@ -425,9 +318,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
-            var updateRes = await HandlePartitioned<TDocument, TKey>(documentToModify).UpdateOneAsync(filter, update, new UpdateOptions { IsUpsert = true });
-            return updateRes.ModifiedCount == 1;
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey>(documentToModify, update);
         }
 
         /// <summary>
@@ -441,27 +332,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
-            var updateRes = HandlePartitioned<TDocument, TKey>(documentToModify).UpdateOne(filter, update, new UpdateOptions { IsUpsert = true });
-            return updateRes.ModifiedCount == 1;
-        }
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
-            var updateRes = await HandlePartitioned<TDocument, TKey>(documentToModify).UpdateOneAsync(filter, Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
+            return MongoDbUpdater.UpdateOne<TDocument, TKey>(documentToModify, update);
         }
 
         /// <summary>
@@ -477,9 +348,57 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
-            var updateRes = HandlePartitioned<TDocument, TKey>(documentToModify).UpdateOne(filter, Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
+            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(documentToModify, field, value);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(documentToModify, field, value);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        public virtual bool UpdateOne<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        public virtual bool UpdateOne<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(filter, field, value, partitionKey);
         }
 
         /// <summary>
@@ -496,9 +415,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument, TKey>() : GetCollection<TDocument, TKey>(partitionKey);
-            var updateRes = await collection.UpdateOneAsync(filter, Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(filter, field, value, partitionKey);
         }
 
         /// <summary>
@@ -518,42 +435,6 @@ namespace MongoDbGenericRepository
             return await UpdateOneAsync<TDocument, TKey, TField>(Builders<TDocument>.Filter.Where(filter), field, value, partitionKey);
         }
 
-        /// <summary>
-        /// Updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The value of the partition key.</param>
-        public virtual bool UpdateOne<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument, TKey>() : GetCollection<TDocument, TKey>(partitionKey);
-            var updateRes = collection.UpdateOne(filter, Builders<TDocument>.Update.Set(field, value));
-            return updateRes.ModifiedCount == 1;
-        }
-
-        /// <summary>
-        /// For the entity selected by the filter, updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The partition key for the document.</param>
-        public virtual bool UpdateOne<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return UpdateOne<TDocument, TKey, TField>(Builders<TDocument>.Filter.Where(filter), field, value, partitionKey);
-        }
-
         #endregion Update
 
         #region Delete
@@ -1055,9 +936,9 @@ namespace MongoDbGenericRepository
         /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public virtual async Task<List<TDocument>> GetPaginatedAsync<TDocument>(
-            Expression<Func<TDocument, bool>> filter, 
-            int skipNumber = 0, 
-            int takeNumber = 50, 
+            Expression<Func<TDocument, bool>> filter,
+            int skipNumber = 0,
+            int takeNumber = 50,
             string partitionKey = null)
             where TDocument : IDocument
         {
diff --git a/MongoDbGenericRepository/BaseRepository.cs b/MongoDbGenericRepository/BaseReadOnlyRepository.cs
similarity index 84%
rename from MongoDbGenericRepository/BaseRepository.cs
rename to MongoDbGenericRepository/BaseReadOnlyRepository.cs
index 823c1f8..57ac920 100644
--- a/MongoDbGenericRepository/BaseRepository.cs
+++ b/MongoDbGenericRepository/BaseReadOnlyRepository.cs
@@ -1,5 +1,6 @@
 using MongoDB.Driver;
 using MongoDB.Driver.Linq;
+using MongoDbGenericRepository.DataAccess.Read;
 using MongoDbGenericRepository.Models;
 using System;
 using System.Collections.Generic;
@@ -323,6 +324,11 @@ namespace MongoDbGenericRepository
         /// </summary>
         protected IMongoDbContext MongoDbContext = null;
 
+        /// <summary>
+        /// A MongoDb Reader for read operations
+        /// </summary>
+        protected MongoDbReader MongoDbReader = null;
+
         /// <summary>
         /// The constructor taking a connection string and a database name.
         /// </summary>
@@ -337,7 +343,7 @@ namespace MongoDbGenericRepository
             }
             ConnectionString = connectionString;
             DatabaseName = databaseName;
-            MongoDbContext = new MongoDbContext(connectionString, databaseName);
+            SetupMongoDbContext(new MongoDbContext(connectionString, databaseName));
         }
 
         /// <summary>
@@ -346,7 +352,7 @@ namespace MongoDbGenericRepository
         /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
         protected BaseReadOnlyRepository(IMongoDbContext mongoDbContext)
         {
-            MongoDbContext = mongoDbContext;
+            SetupMongoDbContext(mongoDbContext);
         }
 
         /// <summary>
@@ -355,9 +361,14 @@ namespace MongoDbGenericRepository
         /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
         protected BaseReadOnlyRepository(IMongoDatabase mongoDatabase)
         {
-            MongoDbContext = new MongoDbContext(mongoDatabase);
+            SetupMongoDbContext(new MongoDbContext(mongoDatabase));
         }
 
+        protected void SetupMongoDbContext(IMongoDbContext mongoDbContext)
+        {
+            MongoDbContext = mongoDbContext;
+            MongoDbReader = new MongoDbReader(MongoDbContext);
+        }
 
         #region Read TKey
 
@@ -368,12 +379,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="id">The Id of the document you want to get.</param>
         /// <param name="partitionKey">An optional partition key.</param>
-        public async Task<TDocument> GetByIdAsync<TDocument, TKey>(TKey id, string partitionKey = null)
+        public async virtual Task<TDocument> GetByIdAsync<TDocument, TKey>(TKey id, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", id);
-            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefaultAsync();
+            return await MongoDbReader.GetByIdAsync<TDocument, TKey>(id, partitionKey);
         }
 
         /// <summary>
@@ -383,12 +393,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="id">The Id of the document you want to get.</param>
         /// <param name="partitionKey">An optional partition key.</param>
-        public TDocument GetById<TDocument, TKey>(TKey id, string partitionKey = null)
+        public virtual TDocument GetById<TDocument, TKey>(TKey id, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var filter = Builders<TDocument>.Filter.Eq("Id", id);
-            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefault();
+            return MongoDbReader.GetById<TDocument, TKey>(id, partitionKey);
         }
 
         /// <summary>
@@ -398,11 +407,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
-        public async Task<TDocument> GetOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public async virtual Task<TDocument> GetOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefaultAsync();
+            return await MongoDbReader.GetOneAsync<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -412,11 +421,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
-        public TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public virtual TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefault();
+            return MongoDbReader.GetOne<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -426,11 +435,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
-        public IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public virtual IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter);
+            return MongoDbReader.GetCursor<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -440,12 +449,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
-        public async Task<bool> AnyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public async virtual Task<bool> AnyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var count = await HandlePartitioned<TDocument, TKey>(partitionKey).CountDocumentsAsync(filter);
-            return (count > 0);
+            return await MongoDbReader.AnyAsync<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -455,12 +463,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
-        public bool Any<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public virtual bool Any<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var count = HandlePartitioned<TDocument, TKey>(partitionKey).CountDocuments(filter);
-            return (count > 0);
+            return MongoDbReader.Any<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -470,11 +477,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
-        public async Task<List<TDocument>> GetAllAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public async virtual Task<List<TDocument>> GetAllAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).ToListAsync();
+            return await MongoDbReader.GetAllAsync<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -484,11 +491,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
-        public List<TDocument> GetAll<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public virtual List<TDocument> GetAll<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).ToList();
+            return MongoDbReader.GetAll<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -498,11 +505,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partitionKey</param>
-        public async Task<long> CountAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public async virtual Task<long> CountAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await HandlePartitioned<TDocument, TKey>(partitionKey).CountDocumentsAsync(filter);
+            return await MongoDbReader.CountAsync<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -512,11 +519,11 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partitionKey</param>
-        public long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public virtual long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).CountDocuments();
+            return MongoDbReader.Count<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -527,14 +534,11 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="maxValueSelector">A property selector to order by descending.</param>
         /// <param name="partitionKey">An optional partitionKey.</param>
-        public async Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
+        public async virtual Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
-                                                                     .SortByDescending(maxValueSelector)
-                                                                     .Limit(1)
-                                                                     .FirstOrDefaultAsync();
+            return await MongoDbReader.GetByMaxAsync<TDocument, TKey>(filter, maxValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -545,14 +549,11 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="maxValueSelector">A property selector to order by descending.</param>
         /// <param name="partitionKey">An optional partitionKey.</param>
-        public TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
+        public virtual TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
-                                                               .SortByDescending(maxValueSelector)
-                                                               .Limit(1)
-                                                               .FirstOrDefault();
+            return MongoDbReader.GetByMax<TDocument, TKey>(filter, maxValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -563,14 +564,11 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="minValueSelector">A property selector to order by ascending.</param>
         /// <param name="partitionKey">An optional partitionKey.</param>
-        public async Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
+        public async virtual Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
-                                                                     .SortBy(minValueSelector)
-                                                                     .Limit(1)
-                                                                     .FirstOrDefaultAsync();
+            return await MongoDbReader.GetByMinAsync<TDocument, TKey>(filter, minValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -581,50 +579,11 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="minValueSelector">A property selector to order by ascending.</param>
         /// <param name="partitionKey">An optional partitionKey.</param>
-        public TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
+        public virtual TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
-                                                               .SortBy(minValueSelector)
-                                                               .Limit(1)
-                                                               .FirstOrDefault();
-        }
-
-        /// <summary>
-        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="minValueSelector">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        private IFindFluent<TDocument, TDocument> GetMinMongoQuery<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
-                    where TDocument : IDocument<TKey>
-                    where TKey : IEquatable<TKey>
-        {
-            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
-                                                               .SortBy(ConvertExpression(minValueSelector))
-                                                               .Limit(1);
-        }
-
-        /// <summary>
-        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="maxValueSelector">A property selector to order by descending.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        private IFindFluent<TDocument, TDocument> GetMaxMongoQuery<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
-                    where TDocument : IDocument<TKey>
-                    where TKey : IEquatable<TKey>
-        {
-            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
-                                                               .SortByDescending(ConvertExpression(maxValueSelector))
-                                                               .Limit(1);
+            return MongoDbReader.GetByMin<TDocument, TKey>(filter, minValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -635,13 +594,11 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="orderByAscending">A property selector to order by ascending.</param>
         /// <param name="partitionKey">An optional partitionKey.</param>
-        public async Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+        public async virtual Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await GetMaxMongoQuery<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey)
-                                .Project(maxValueSelector)
-                                .FirstOrDefaultAsync();
+            return await MongoDbReader.GetMaxValueAsync<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -653,14 +610,11 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="maxValueSelector">A property selector to order by ascending.</param>
         /// <param name="partitionKey">An optional partitionKey.</param>
-        public TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+        public virtual TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-
-            return GetMaxMongoQuery<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey)
-                      .Project(maxValueSelector)
-                      .FirstOrDefault();
+            return MongoDbReader.GetMaxValue<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -676,7 +630,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await GetMinMongoQuery<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey).Project(minValueSelector).FirstOrDefaultAsync();
+            return await MongoDbReader.GetMinValueAsync<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -692,7 +646,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return GetMinMongoQuery<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey).Project(minValueSelector).FirstOrDefault();
+            return MongoDbReader.GetMinValue<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
         }
 
         #endregion
@@ -712,7 +666,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await GetQuery<TDocument, TKey>(filter, partitionKey).SumAsync(selector);
+            return await MongoDbReader.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
         }
 
         /// <summary>
@@ -728,7 +682,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return GetQuery<TDocument, TKey>(filter, partitionKey).Sum(selector);
+            return MongoDbReader.SumBy<TDocument, TKey>(filter, selector, partitionKey);
         }
 
         /// <summary>
@@ -744,7 +698,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await GetQuery<TDocument, TKey>(filter, partitionKey).SumAsync(selector);
+            return await MongoDbReader.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
         }
 
         /// <summary>
@@ -760,14 +714,14 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return GetQuery<TDocument, TKey>(filter, partitionKey).Sum(selector);
+            return MongoDbReader.SumBy<TDocument, TKey>(filter, selector, partitionKey);
         }
 
-        #endregion Sums TKey
+        #endregion Sum TKey
 
         #region Utility Methods
 
-        protected IMongoQueryable<TDocument> GetQuery<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        protected virtual IMongoQueryable<TDocument> GetQuery<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
@@ -830,7 +784,7 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TDocument">The document type.</typeparam>
         /// <typeparam name="TValue">The type of the value.</typeparam>
         /// <param name="expression">The expression to convert</param>
-        protected static Expression<Func<TDocument, object>> ConvertExpression<TDocument, TValue>(Expression<Func<TDocument, TValue>> expression)
+        protected virtual Expression<Func<TDocument, object>> ConvertExpression<TDocument, TValue>(Expression<Func<TDocument, TValue>> expression)
         {
             var param = expression.Parameters[0];
             Expression body = expression.Body;
@@ -838,6 +792,70 @@ namespace MongoDbGenericRepository
             return Expression.Lambda<Func<TDocument, object>>(convert, param);
         }
 
+        /// <summary>
+        /// Maps a IndexCreationOptions object to a MongoDB.Driver.CreateIndexOptions object
+        /// </summary>
+        /// <param name="indexCreationOptions">The options for creating an index.</param>
+        /// <returns></returns>
+        protected virtual CreateIndexOptions MapIndexOptions(IndexCreationOptions indexCreationOptions)
+        {
+            return new CreateIndexOptions
+            {
+                Unique = indexCreationOptions.Unique,
+                TextIndexVersion = indexCreationOptions.TextIndexVersion,
+                SphereIndexVersion = indexCreationOptions.SphereIndexVersion,
+                Sparse = indexCreationOptions.Sparse,
+                Name = indexCreationOptions.Name,
+                Min = indexCreationOptions.Min,
+                Max = indexCreationOptions.Max,
+                LanguageOverride = indexCreationOptions.LanguageOverride,
+                ExpireAfter = indexCreationOptions.ExpireAfter,
+                DefaultLanguage = indexCreationOptions.DefaultLanguage,
+                BucketSize = indexCreationOptions.BucketSize,
+                Bits = indexCreationOptions.Bits,
+                Background = indexCreationOptions.Background,
+                Version = indexCreationOptions.Version
+            };
+        }
+
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        protected virtual IFindFluent<TDocument, TDocument> GetMinMongoQuery<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
+                    where TDocument : IDocument<TKey>
+                    where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                               .SortBy(ConvertExpression(minValueSelector))
+                                                               .Limit(1);
+        }
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        protected virtual IFindFluent<TDocument, TDocument> GetMaxMongoQuery<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+                    where TDocument : IDocument<TKey>
+                    where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                               .SortByDescending(ConvertExpression(maxValueSelector))
+                                                               .Limit(1);
+        }
+
+
         #endregion
     }
 }
diff --git a/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs b/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs
new file mode 100644
index 0000000..d6de4c6
--- /dev/null
+++ b/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs
@@ -0,0 +1,158 @@
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace MongoDbGenericRepository.DataAccess.Base
+{
+    public class DataAccessBase
+    {
+        protected IMongoDbContext MongoDbContext;
+
+        public DataAccessBase(IMongoDbContext mongoDbContext)
+        {
+            MongoDbContext = mongoDbContext;
+        }
+
+        #region Utility Methods
+
+        protected virtual IMongoQueryable<TDocument> GetQuery<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).AsQueryable().Where(filter);
+        }
+
+        /// <summary>
+        /// Gets a collections for a potentially partitioned document type.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="document">The document.</param>
+        /// <returns></returns>
+        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (document is IPartitionedDocument)
+            {
+                return GetCollection<TDocument, TKey>(((IPartitionedDocument)document).PartitionKey);
+            }
+            return GetCollection<TDocument, TKey>();
+        }
+
+        /// <summary>
+        /// Gets a collections for the type TDocument with a partition key.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="partitionKey">The collection partition key.</param>
+        /// <returns></returns>
+        protected virtual IMongoCollection<TDocument> GetCollection<TDocument, TKey>(string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbContext.GetCollection<TDocument>(partitionKey);
+        }
+
+        /// <summary>
+        /// Gets a collections for a potentially partitioned document type.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="partitionKey">The collection partition key.</param>
+        /// <returns></returns>
+        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(string partitionKey)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (!string.IsNullOrEmpty(partitionKey))
+            {
+                return GetCollection<TDocument, TKey>(partitionKey);
+            }
+            return GetCollection<TDocument, TKey>();
+        }
+
+        /// <summary>
+        /// Converts a LINQ expression of TDocument, TValue to a LINQ expression of TDocument, object
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="expression">The expression to convert</param>
+        protected virtual Expression<Func<TDocument, object>> ConvertExpression<TDocument, TValue>(Expression<Func<TDocument, TValue>> expression)
+        {
+            var param = expression.Parameters[0];
+            Expression body = expression.Body;
+            var convert = Expression.Convert(body, typeof(object));
+            return Expression.Lambda<Func<TDocument, object>>(convert, param);
+        }
+
+        /// <summary>
+        /// Maps a IndexCreationOptions object to a MongoDB.Driver.CreateIndexOptions object
+        /// </summary>
+        /// <param name="indexCreationOptions">The options for creating an index.</param>
+        /// <returns></returns>
+        protected virtual CreateIndexOptions MapIndexOptions(IndexCreationOptions indexCreationOptions)
+        {
+            return new CreateIndexOptions
+            {
+                Unique = indexCreationOptions.Unique,
+                TextIndexVersion = indexCreationOptions.TextIndexVersion,
+                SphereIndexVersion = indexCreationOptions.SphereIndexVersion,
+                Sparse = indexCreationOptions.Sparse,
+                Name = indexCreationOptions.Name,
+                Min = indexCreationOptions.Min,
+                Max = indexCreationOptions.Max,
+                LanguageOverride = indexCreationOptions.LanguageOverride,
+                ExpireAfter = indexCreationOptions.ExpireAfter,
+                DefaultLanguage = indexCreationOptions.DefaultLanguage,
+                BucketSize = indexCreationOptions.BucketSize,
+                Bits = indexCreationOptions.Bits,
+                Background = indexCreationOptions.Background,
+                Version = indexCreationOptions.Version
+            };
+        }
+
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        protected virtual IFindFluent<TDocument, TDocument> GetMinMongoQuery<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
+                    where TDocument : IDocument<TKey>
+                    where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                               .SortBy(ConvertExpression(minValueSelector))
+                                                               .Limit(1);
+        }
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        protected virtual IFindFluent<TDocument, TDocument> GetMaxMongoQuery<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+                    where TDocument : IDocument<TKey>
+                    where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                               .SortByDescending(ConvertExpression(maxValueSelector))
+                                                               .Limit(1);
+        }
+
+
+        #endregion
+    }
+}
diff --git a/MongoDbGenericRepository/DataAccess/Create/MongoDbCreator.cs b/MongoDbGenericRepository/DataAccess/Create/MongoDbCreator.cs
new file mode 100644
index 0000000..bc490c7
--- /dev/null
+++ b/MongoDbGenericRepository/DataAccess/Create/MongoDbCreator.cs
@@ -0,0 +1,142 @@
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using MongoDbGenericRepository.DataAccess.Base;
+using MongoDbGenericRepository.Models;
+using MongoDbGenericRepository.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository.DataAccess.Create
+{
+    public class MongoDbCreator : DataAccessBase
+    {
+        public MongoDbCreator(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        {
+        }
+
+        #region Create TKey
+
+        /// <summary>
+        /// Asynchronously adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public virtual async Task AddOneAsync<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            FormatDocument<TDocument, TKey>(document);
+            await HandlePartitioned<TDocument, TKey>(document).InsertOneAsync(document);
+        }
+
+        /// <summary>
+        /// Adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public virtual void AddOne<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            FormatDocument<TDocument, TKey>(document);
+            HandlePartitioned<TDocument, TKey>(document).InsertOne(document);
+        }
+
+        /// <summary>
+        /// Asynchronously adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        public virtual async Task AddManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (!documents.Any())
+            {
+                return;
+            }
+            foreach (var document in documents)
+            {
+                FormatDocument<TDocument, TKey>(document);
+            }
+            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
+            if (documents.Any(e => e is IPartitionedDocument))
+            {
+                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
+                {
+                    await HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).InsertManyAsync(group.ToList());
+                }
+            }
+            else
+            {
+                await GetCollection<TDocument, TKey>().InsertManyAsync(documents.ToList());
+            }
+        }
+
+        /// <summary>
+        /// Adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        public virtual void AddMany<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (!documents.Any())
+            {
+                return;
+            }
+            foreach (var document in documents)
+            {
+                FormatDocument<TDocument, TKey>(document);
+            }
+            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
+            if (documents.Any(e => e is IPartitionedDocument))
+            {
+                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
+                {
+                    HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).InsertMany(group.ToList());
+                }
+            }
+            else
+            {
+                GetCollection<TDocument, TKey>().InsertMany(documents.ToList());
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Sets the value of the document Id if it is not set already.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="document">The document.</param>
+        protected void FormatDocument<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (document == null)
+            {
+                throw new ArgumentNullException(nameof(document));
+            }
+            var defaultTKey = default(TKey);
+            if (document.Id == null
+                || (defaultTKey != null
+                    && defaultTKey.Equals(document.Id)))
+            {
+                document.Id = IdGenerator.GetId<TKey>();
+            }
+        }
+    }
+}
diff --git a/MongoDbGenericRepository/DataAccess/Delete/MongoDbEraser.cs b/MongoDbGenericRepository/DataAccess/Delete/MongoDbEraser.cs
new file mode 100644
index 0000000..1daabac
--- /dev/null
+++ b/MongoDbGenericRepository/DataAccess/Delete/MongoDbEraser.cs
@@ -0,0 +1,180 @@
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using MongoDbGenericRepository.DataAccess.Base;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository.DataAccess.Delete
+{
+    public class MongoDbEraser : DataAccessBase
+    {
+        public MongoDbEraser(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        {
+        }
+
+        #region Delete TKey
+
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", document.Id);
+            return HandlePartitioned<TDocument, TKey>(document).DeleteOne(filter).DeletedCount;
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", document.Id);
+            return (await HandlePartitioned<TDocument, TKey>(document).DeleteOneAsync(filter)).DeletedCount;
+        }
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOne(filter).DeletedCount;
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return (await HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOneAsync(filter)).DeletedCount;
+        }
+
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return (await HandlePartitioned<TDocument, TKey>(partitionKey).DeleteManyAsync(filter)).DeletedCount;
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (!documents.Any())
+            {
+                return 0;
+            }
+            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
+            if (documents.Any(e => e is IPartitionedDocument))
+            {
+                long deleteCount = 0;
+                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
+                {
+                    var groupIdsTodelete = group.Select(e => e.Id).ToArray();
+                    deleteCount += (await HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).DeleteManyAsync(x => groupIdsTodelete.Contains(x.Id))).DeletedCount;
+                }
+                return deleteCount;
+            }
+            else
+            {
+                var idsTodelete = documents.Select(e => e.Id).ToArray();
+                return (await HandlePartitioned<TDocument, TKey>(documents.FirstOrDefault()).DeleteManyAsync(x => idsTodelete.Contains(x.Id))).DeletedCount;
+            }
+        }
+
+        /// <summary>
+        /// Deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (!documents.Any())
+            {
+                return 0;
+            }
+            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
+            if (documents.Any(e => e is IPartitionedDocument))
+            {
+                long deleteCount = 0;
+                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
+                {
+                    var groupIdsTodelete = group.Select(e => e.Id).ToArray();
+                    deleteCount += (HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).DeleteMany(x => groupIdsTodelete.Contains(x.Id))).DeletedCount;
+                }
+                return deleteCount;
+            }
+            else
+            {
+                var idsTodelete = documents.Select(e => e.Id).ToArray();
+                return (HandlePartitioned<TDocument, TKey>(documents.FirstOrDefault()).DeleteMany(x => idsTodelete.Contains(x.Id))).DeletedCount;
+            }
+        }
+
+        /// <summary>
+        /// Deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteMany<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteMany(filter).DeletedCount;
+        }
+
+        #endregion
+
+    }
+}
diff --git a/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.cs b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.cs
new file mode 100644
index 0000000..a23340a
--- /dev/null
+++ b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.cs
@@ -0,0 +1,393 @@
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using MongoDbGenericRepository.DataAccess.Base;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository.DataAccess.Read
+{
+    public class MongoDbReader : DataAccessBase
+    {
+        public MongoDbReader(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        {
+        }
+
+        #region Read TKey
+
+        /// <summary>
+        /// Asynchronously returns one document given its id.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="id">The Id of the document you want to get.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public async virtual Task<TDocument> GetByIdAsync<TDocument, TKey>(TKey id, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", id);
+            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Returns one document given its id.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="id">The Id of the document you want to get.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TDocument GetById<TDocument, TKey>(TKey id, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", id);
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Asynchronously returns one document given an expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public async virtual Task<TDocument> GetOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Returns one document given an expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Returns a collection cursor.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter);
+        }
+
+        /// <summary>
+        /// Returns true if any of the document of the collection matches the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public async virtual Task<bool> AnyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var count = await HandlePartitioned<TDocument, TKey>(partitionKey).CountDocumentsAsync(filter);
+            return (count > 0);
+        }
+
+        /// <summary>
+        /// Returns true if any of the document of the collection matches the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual bool Any<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var count = HandlePartitioned<TDocument, TKey>(partitionKey).CountDocuments(filter);
+            return (count > 0);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public async virtual Task<List<TDocument>> GetAllAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).ToListAsync();
+        }
+
+        /// <summary>
+        /// Returns a list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual List<TDocument> GetAll<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).ToList();
+        }
+
+        /// <summary>
+        /// Asynchronously counts how many documents match the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partitionKey</param>
+        public async virtual Task<long> CountAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await HandlePartitioned<TDocument, TKey>(partitionKey).CountDocumentsAsync(filter);
+        }
+
+        /// <summary>
+        /// Counts how many documents match the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partitionKey</param>
+        public virtual long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).CountDocuments();
+        }
+
+        #endregion
+
+        #region Min / Max
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async virtual Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                                     .SortByDescending(maxValueSelector)
+                                                                     .Limit(1)
+                                                                     .FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                               .SortByDescending(maxValueSelector)
+                                                               .Limit(1)
+                                                               .FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async virtual Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                                     .SortBy(minValueSelector)
+                                                                     .Limit(1)
+                                                                     .FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                               .SortBy(minValueSelector)
+                                                               .Limit(1)
+                                                               .FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async virtual Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetMaxMongoQuery<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey)
+                                .Project(maxValueSelector)
+                                .FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetMaxMongoQuery<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey)
+                      .Project(maxValueSelector)
+                      .FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetMinMongoQuery<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey).Project(minValueSelector).FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TValue GetMinValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetMinMongoQuery<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey).Project(minValueSelector).FirstOrDefault();
+        }
+
+
+        #endregion Min / Max
+
+        #region Sum TKey
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual async Task<int> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, int>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetQuery<TDocument, TKey>(filter, partitionKey).SumAsync(selector);
+        }
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual int SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, int>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetQuery<TDocument, TKey>(filter, partitionKey).Sum(selector);
+        }
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual async Task<decimal> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, decimal>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetQuery<TDocument, TKey>(filter, partitionKey).SumAsync(selector);
+        }
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual decimal SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, decimal>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetQuery<TDocument, TKey>(filter, partitionKey).Sum(selector);
+        }
+
+        #endregion Sum TKey
+    }
+}
diff --git a/MongoDbGenericRepository/DataAccess/Update/MongoDbUpdater.cs b/MongoDbGenericRepository/DataAccess/Update/MongoDbUpdater.cs
new file mode 100644
index 0000000..0657132
--- /dev/null
+++ b/MongoDbGenericRepository/DataAccess/Update/MongoDbUpdater.cs
@@ -0,0 +1,190 @@
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using MongoDbGenericRepository.DataAccess.Base;
+using MongoDbGenericRepository.Models;
+using MongoDbGenericRepository.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository.DataAccess.Update
+{
+    public class MongoDbUpdater : DataAccessBase
+    {
+        public MongoDbUpdater(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        {
+        }
+
+        /// <summary>
+        /// Asynchronously Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument modifiedDocument)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", modifiedDocument.Id);
+            var updateRes = await HandlePartitioned<TDocument, TKey>(modifiedDocument).ReplaceOneAsync(filter, modifiedDocument);
+            return updateRes.ModifiedCount == 1;
+        }
+
+        /// <summary>
+        /// Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        public virtual bool UpdateOne<TDocument, TKey>(TDocument modifiedDocument)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", modifiedDocument.Id);
+            var updateRes = HandlePartitioned<TDocument, TKey>(modifiedDocument).ReplaceOne(filter, modifiedDocument);
+            return updateRes.ModifiedCount == 1;
+        }
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
+            var updateRes = await HandlePartitioned<TDocument, TKey>(documentToModify).UpdateOneAsync(filter, update, new UpdateOptions { IsUpsert = true });
+            return updateRes.ModifiedCount == 1;
+        }
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        public virtual bool UpdateOne<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
+            var updateRes = HandlePartitioned<TDocument, TKey>(documentToModify).UpdateOne(filter, update, new UpdateOptions { IsUpsert = true });
+            return updateRes.ModifiedCount == 1;
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
+            var updateRes = await HandlePartitioned<TDocument, TKey>(documentToModify).UpdateOneAsync(filter, Builders<TDocument>.Update.Set(field, value));
+            return updateRes.ModifiedCount == 1;
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        public virtual bool UpdateOne<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", documentToModify.Id);
+            var updateRes = HandlePartitioned<TDocument, TKey>(documentToModify).UpdateOne(filter, Builders<TDocument>.Update.Set(field, value));
+            return updateRes.ModifiedCount == 1;
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument, TKey>() : GetCollection<TDocument, TKey>(partitionKey);
+            var updateRes = await collection.UpdateOneAsync(filter, Builders<TDocument>.Update.Set(field, value));
+            return updateRes.ModifiedCount == 1;
+        }
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await UpdateOneAsync<TDocument, TKey, TField>(Builders<TDocument>.Filter.Where(filter), field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        public virtual bool UpdateOne<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument, TKey>() : GetCollection<TDocument, TKey>(partitionKey);
+            var updateRes = collection.UpdateOne(filter, Builders<TDocument>.Update.Set(field, value));
+            return updateRes.ModifiedCount == 1;
+        }
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        public virtual bool UpdateOne<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return UpdateOne<TDocument, TKey, TField>(Builders<TDocument>.Filter.Where(filter), field, value, partitionKey);
+        }
+    }
+}
diff --git a/MongoDbGenericRepository/KeyTypedBaseMongoDbRepository.cs b/MongoDbGenericRepository/KeyTypedBaseMongoDbRepository.cs
index 88d6f25..89cf73d 100644
--- a/MongoDbGenericRepository/KeyTypedBaseMongoDbRepository.cs
+++ b/MongoDbGenericRepository/KeyTypedBaseMongoDbRepository.cs
@@ -1,9 +1,10 @@
 using MongoDB.Driver;
+using MongoDbGenericRepository.DataAccess.Create;
+using MongoDbGenericRepository.DataAccess.Update;
 using MongoDbGenericRepository.Models;
-using MongoDbGenericRepository.Utils;
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
@@ -15,6 +16,45 @@ namespace MongoDbGenericRepository
     /// <typeparam name="TKey"></typeparam>
     public abstract class KeyTypedBaseMongoDbRepository<TKey> : KeyTypedReadOnlyMongoRepository<TKey>, IKeyTypedReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
     {
+        protected object _initLock;
+        protected MongoDbCreator _mongoDbCreator;
+        protected MongoDbCreator MongoDbCreator
+        {
+            get
+            {
+                if(_mongoDbCreator == null)
+                {
+                    lock (_initLock)
+                    {
+                        if(_mongoDbCreator == null)
+                        {
+                            _mongoDbCreator = new MongoDbCreator(MongoDbContext);
+                        }
+                    }
+                }
+                return _mongoDbCreator;
+            }
+        }
+
+        private MongoDbUpdater _mongoDbUpdater;
+        protected MongoDbUpdater MongoDbUpdater
+        {
+            get
+            {
+                if (_mongoDbUpdater != null) { return _mongoDbUpdater; }
+
+                lock (_initLock)
+                {
+                    if (_mongoDbUpdater == null)
+                    {
+                        _mongoDbUpdater = new MongoDbUpdater(MongoDbContext);
+                    }
+                }
+
+                return _mongoDbUpdater;
+            }
+        }
+
         /// <summary>
         /// The constructor taking a connection string and a database name.
         /// </summary>
@@ -50,8 +90,7 @@ namespace MongoDbGenericRepository
         /// <param name="document">The document you want to add.</param>
         public virtual async Task AddOneAsync<TDocument>(TDocument document) where TDocument : IDocument<TKey>
         {
-            FormatDocument(document);
-            await HandlePartitioned(document).InsertOneAsync(document);
+            await MongoDbCreator.AddOneAsync<TDocument, TKey>(document);
         }
 
         /// <summary>
@@ -62,8 +101,7 @@ namespace MongoDbGenericRepository
         /// <param name="document">The document you want to add.</param>
         public virtual void AddOne<TDocument>(TDocument document) where TDocument : IDocument<TKey>
         {
-            FormatDocument(document);
-            HandlePartitioned(document).InsertOne(document);
+            MongoDbCreator.AddOne<TDocument, TKey>(document);
         }
 
         /// <summary>
@@ -74,26 +112,7 @@ namespace MongoDbGenericRepository
         /// <param name="documents">The documents you want to add.</param>
         public virtual async Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<TKey>
         {
-            if (!documents.Any())
-            {
-                return;
-            }
-            foreach (var document in documents)
-            {
-                FormatDocument(document);
-            }
-            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
-            if (documents.Any(e => e is IPartitionedDocument))
-            {
-                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
-                {
-                    await HandlePartitioned(group.FirstOrDefault()).InsertManyAsync(group.ToList());
-                }
-            }
-            else
-            {
-                await GetCollection<TDocument>().InsertManyAsync(documents.ToList());
-            }
+            await MongoDbCreator.AddManyAsync<TDocument, TKey>(documents);
         }
 
         /// <summary>
@@ -104,48 +123,146 @@ namespace MongoDbGenericRepository
         /// <param name="documents">The documents you want to add.</param>
         public virtual void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<TKey>
         {
-            if (!documents.Any())
-            {
-                return;
-            }
-            foreach (var document in documents)
-            {
-                FormatDocument(document);
-            }
-            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
-            if (documents.Any(e => e is IPartitionedDocument))
-            {
-                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
-                {
-                    HandlePartitioned(group.FirstOrDefault()).InsertMany(group.ToList());
-                }
-            }
-            else
-            {
-                GetCollection<TDocument>().InsertMany(documents.ToList());
-            }
+            MongoDbCreator.AddMany<TDocument, TKey>(documents);
         }
 
         #endregion Create
 
+        #region Update
+
         /// <summary>
-        /// Sets the value of the document Id if it is not set already.
+        /// Asynchronously Updates a document.
         /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <param name="document">The document.</param>
-        protected void FormatDocument<TDocument>(TDocument document) where TDocument : IDocument<TKey>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument>(TDocument modifiedDocument) where TDocument : IDocument<TKey>
         {
-            if (document == null)
-            {
-                throw new ArgumentNullException(nameof(document));
-            }
-            var defaultTKey = default(TKey);
-            if (document.Id == null
-                || (defaultTKey != null
-                    && defaultTKey.Equals(document.Id)))
-            {
-                document.Id = IdGenerator.GetId<TKey>();
-            }
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey>(modifiedDocument);
         }
+
+        /// <summary>
+        /// Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        public virtual bool UpdateOne<TDocument>(TDocument modifiedDocument) where TDocument : IDocument<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey>(modifiedDocument);
+        }
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey>(documentToModify, update);
+        }
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        public virtual bool UpdateOne<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey>(documentToModify, update);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        public virtual bool UpdateOne<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(documentToModify, field, value);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(documentToModify, field, value);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        public virtual bool UpdateOne<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        public virtual bool UpdateOne<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(filter, field, value, partitionKey);
+        }
+
+
+        #endregion Update
     }
 }
diff --git a/MongoDbGenericRepository/KeyTypedReadOnlyMongoRepository.cs b/MongoDbGenericRepository/KeyTypedReadOnlyMongoRepository.cs
index 3f3d37f..085c54a 100644
--- a/MongoDbGenericRepository/KeyTypedReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/KeyTypedReadOnlyMongoRepository.cs
@@ -1,9 +1,8 @@
 using MongoDB.Driver;
-using MongoDB.Driver.Linq;
+using MongoDbGenericRepository.DataAccess.Read;
 using MongoDbGenericRepository.Models;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 
@@ -13,14 +12,43 @@ namespace MongoDbGenericRepository
     /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
     /// Its constructor must be given a connection string and a database name.
     /// </summary>
-    public abstract class KeyTypedReadOnlyMongoRepository<TKey> : BaseReadOnlyRepository, IKeyTypedReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
+    public abstract class KeyTypedReadOnlyMongoRepository<TKey> : IKeyTypedReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
     {
+        /// <summary>
+        /// The connection string.
+        /// </summary>
+        public string ConnectionString { get; protected set; }
+
+        /// <summary>
+        /// The database name.
+        /// </summary>
+        public string DatabaseName { get; protected set; }
+
+        /// <summary>
+        /// The MongoDbContext
+        /// </summary>
+        protected IMongoDbContext MongoDbContext = null;
+
+        /// <summary>
+        /// A MongoDb Reader for read operations
+        /// </summary>
+        protected MongoDbReader MongoDbReader = null;
+
         /// <summary>
         /// The constructor taking a connection string and a database name.
         /// </summary>
         /// <param name="connectionString">The connection string of the MongoDb server.</param>
         /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
-        protected KeyTypedReadOnlyMongoRepository(string connectionString, string databaseName = null) : base(connectionString, databaseName)
+        protected KeyTypedReadOnlyMongoRepository(string connectionString, string databaseName = null)
+        {
+            SetupMongoDbContext(connectionString, databaseName);
+        }
+
+        /// <summary>
+        /// The contructor taking a <see cref="IMongoDatabase"/>.
+        /// </summary>
+        /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
+        protected KeyTypedReadOnlyMongoRepository(IMongoDatabase mongoDatabase) : this(new MongoDbContext(mongoDatabase))
         {
         }
 
@@ -28,16 +56,27 @@ namespace MongoDbGenericRepository
         /// The contructor taking a <see cref="IMongoDbContext"/>.
         /// </summary>
         /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
-        protected KeyTypedReadOnlyMongoRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        protected KeyTypedReadOnlyMongoRepository(IMongoDbContext mongoDbContext)
         {
+            SetupMongoDbContext(mongoDbContext);
         }
 
-        /// <summary>
-        /// The contructor taking a <see cref="IMongoDatabase"/>.
-        /// </summary>
-        /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
-        protected KeyTypedReadOnlyMongoRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
+        protected void SetupMongoDbContext(IMongoDbContext mongoDbContext)
         {
+            MongoDbContext = MongoDbContext ?? mongoDbContext;
+            MongoDbReader = MongoDbReader ?? new MongoDbReader(MongoDbContext);
+        }
+
+        protected void SetupMongoDbContext(string connectionString, string databaseName)
+        {
+            if (databaseName == null)
+            {
+                var mongoUrl = new MongoUrl(connectionString);
+                databaseName = databaseName ?? mongoUrl.DatabaseName;
+            }
+            ConnectionString = connectionString;
+            DatabaseName = databaseName;
+            SetupMongoDbContext(new MongoDbContext(connectionString, databaseName));
         }
 
         #region Read
@@ -50,7 +89,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public async Task<TDocument> GetByIdAsync<TDocument>(TKey id, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return await base.GetByIdAsync<TDocument, TKey>(id, partitionKey);
+            return await MongoDbReader.GetByIdAsync<TDocument, TKey>(id, partitionKey);
         }
 
         /// <summary>
@@ -61,7 +100,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public TDocument GetById<TDocument>(TKey id, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return base.GetById<TDocument, TKey>(id, partitionKey);
+            return MongoDbReader.GetById<TDocument, TKey>(id, partitionKey);
         }
 
         /// <summary>
@@ -72,7 +111,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public async Task<TDocument> GetOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return await base.GetOneAsync<TDocument, TKey>(filter, partitionKey);
+            return await MongoDbReader.GetOneAsync<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -83,7 +122,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public TDocument GetOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return base.GetOne<TDocument, TKey>(filter, partitionKey);
+            return MongoDbReader.GetOne<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -94,7 +133,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public IFindFluent<TDocument, TDocument> GetCursor<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return base.GetCursor<TDocument, TKey>(filter, partitionKey);
+            return MongoDbReader.GetCursor<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -105,7 +144,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public async Task<bool> AnyAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return await base.AnyAsync<TDocument, TKey>(filter, partitionKey);
+            return await MongoDbReader.AnyAsync<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -116,7 +155,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public bool Any<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return base.Any<TDocument, TKey>(filter, partitionKey);
+            return MongoDbReader.Any<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -127,7 +166,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public async Task<List<TDocument>> GetAllAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return await base.GetAllAsync<TDocument, TKey>(filter, partitionKey);
+            return await MongoDbReader.GetAllAsync<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -138,7 +177,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public List<TDocument> GetAll<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return base.GetAll<TDocument, TKey>(filter, partitionKey);
+            return MongoDbReader.GetAll<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -149,7 +188,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partitionKey</param>
         public async Task<long> CountAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return await base.CountAsync<TDocument, TKey>(filter, partitionKey);
+            return await MongoDbReader.CountAsync<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -160,7 +199,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partitionKey</param>
         public long Count<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>
         {
-            return base.Count<TDocument, TKey>(filter, partitionKey);
+            return MongoDbReader.Count<TDocument, TKey>(filter, partitionKey);
         }
 
         /// <summary>
@@ -173,7 +212,7 @@ namespace MongoDbGenericRepository
         public async Task<TDocument> GetByMaxAsync<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return await base.GetByMaxAsync<TDocument, TKey>(filter, maxValueSelector, partitionKey);
+            return await MongoDbReader.GetByMaxAsync<TDocument, TKey>(filter, maxValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -187,7 +226,7 @@ namespace MongoDbGenericRepository
         public TDocument GetByMax<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return base.GetByMax<TDocument, TKey>(filter, maxValueSelector, partitionKey);
+            return MongoDbReader.GetByMax<TDocument, TKey>(filter, maxValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -200,7 +239,7 @@ namespace MongoDbGenericRepository
         public async Task<TDocument> GetByMinAsync<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return await base.GetByMinAsync<TDocument, TKey>(filter, minValueSelector, partitionKey);
+            return await MongoDbReader.GetByMinAsync<TDocument, TKey>(filter, minValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -213,7 +252,7 @@ namespace MongoDbGenericRepository
         public TDocument GetByMin<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return base.GetByMin<TDocument, TKey>(filter, minValueSelector, partitionKey);
+            return MongoDbReader.GetByMin<TDocument, TKey>(filter, minValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -227,7 +266,7 @@ namespace MongoDbGenericRepository
         public async Task<TValue> GetMaxValueAsync<TDocument, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return await base.GetMaxValueAsync<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
+            return await MongoDbReader.GetMaxValueAsync<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -241,7 +280,7 @@ namespace MongoDbGenericRepository
         public TValue GetMaxValue<TDocument, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return base.GetMaxValue<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
+            return MongoDbReader.GetMaxValue<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -255,7 +294,7 @@ namespace MongoDbGenericRepository
         public virtual async Task<TValue> GetMinValueAsync<TDocument, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return await base.GetMinValueAsync<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
+            return await MongoDbReader.GetMinValueAsync<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
         }
 
         /// <summary>
@@ -269,7 +308,7 @@ namespace MongoDbGenericRepository
         public virtual TValue GetMinValue<TDocument, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return base.GetMinValue<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
+            return MongoDbReader.GetMinValue<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
         }
 
         #endregion
@@ -288,7 +327,7 @@ namespace MongoDbGenericRepository
                                                        string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return await base.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
+            return await MongoDbReader.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
         }
 
         /// <summary>
@@ -303,7 +342,7 @@ namespace MongoDbGenericRepository
                                                        string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return await base.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
+            return await MongoDbReader.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
         }
 
         /// <summary>
@@ -318,7 +357,7 @@ namespace MongoDbGenericRepository
                                                        string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return base.SumBy<TDocument, TKey>(filter, selector, partitionKey);
+            return MongoDbReader.SumBy<TDocument, TKey>(filter, selector, partitionKey);
         }
 
         /// <summary>
@@ -333,58 +372,9 @@ namespace MongoDbGenericRepository
                                                        string partitionKey = null)
             where TDocument : IDocument<TKey>
         {
-            return base.SumBy<TDocument, TKey>(filter, selector, partitionKey);
+            return MongoDbReader.SumBy<TDocument, TKey>(filter, selector, partitionKey);
         }
 
         #endregion Maths
-
-        #region Utility Methods
-
-        /// <summary>
-        /// Gets a collections for the type TDocument with the matching partition key (if any).
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>An <see cref="IMongoCollection{TDocument}"/></returns>
-        protected virtual IMongoCollection<TDocument> GetCollection<TDocument>(string partitionKey = null) where TDocument : IDocument<TKey>
-        {
-            return MongoDbContext.GetCollection<TDocument>(partitionKey);
-        }
-
-        /// <summary>
-        /// Gets a collections for a potentially partitioned document type.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="document">The document.</param>
-        /// <returns></returns>
-        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument>(TDocument document)
-            where TDocument : IDocument<TKey>
-        {
-            if (document is IPartitionedDocument)
-            {
-                return GetCollection<TDocument>(((IPartitionedDocument)document).PartitionKey);
-            }
-            return GetCollection<TDocument>();
-        }
-
-        /// <summary>
-        /// Gets a collections for a potentially partitioned document type.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="partitionKey">The collection partition key.</param>
-        /// <returns></returns>
-        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument>(string partitionKey)
-            where TDocument : IDocument<TKey>
-        {
-            if (!string.IsNullOrEmpty(partitionKey))
-            {
-                return GetCollection<TDocument>(partitionKey);
-            }
-            return GetCollection<TDocument>();
-        }
-
-        #endregion
     }
 }
\ No newline at end of file
diff --git a/MongoDbGenericRepository/MongoDbContext.cs b/MongoDbGenericRepository/MongoDbContext.cs
index c5921b9..a7a5520 100644
--- a/MongoDbGenericRepository/MongoDbContext.cs
+++ b/MongoDbGenericRepository/MongoDbContext.cs
@@ -21,24 +21,6 @@ namespace MongoDbGenericRepository
         /// </summary>
         public IMongoDatabase Database { get; }
 
-        /// <summary>
-        /// Sets the Guid representation of the MongoDB Driver.
-        /// </summary>
-        /// <param name="guidRepresentation">The new value of the GuidRepresentation</param>
-        public virtual void SetGuidRepresentation(MongoDB.Bson.GuidRepresentation guidRepresentation)
-        {
-            MongoDefaults.GuidRepresentation = guidRepresentation;
-        }
-
-        /// <summary>
-        /// Initialize the Guid representation of the MongoDB Driver.
-        /// Override this method to change the default GuidRepresentation.
-        /// </summary>
-        protected virtual void InitializeGuidRepresentation()
-        {
-            // by default, avoid legacy UUID representation: use Binary 0x04 subtype.
-            MongoDefaults.GuidRepresentation = MongoDB.Bson.GuidRepresentation.Standard;
-        }
 
         /// <summary>
         /// The constructor of the MongoDbContext, it needs an object implementing <see cref="IMongoDatabase"/>.
@@ -76,24 +58,12 @@ namespace MongoDbGenericRepository
             Database = client.GetDatabase(databaseName);
         }
 
-        /// <summary>
-        /// Extracts the CollectionName attribute from the entity type, if any.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <returns>The name of the collection in which the TDocument is stored.</returns>
-        private string GetAttributeCollectionName<TDocument>()
-        {
-            return (typeof(TDocument).GetTypeInfo()
-                                     .GetCustomAttributes(typeof(CollectionNameAttribute))
-                                     .FirstOrDefault() as CollectionNameAttribute)?.Name;
-        }
-
         /// <summary>
         /// Returns a collection for a document type. Also handles document types with a partition key.
         /// </summary>
         /// <typeparam name="TDocument">The type representing a Document.</typeparam>
         /// <param name="partitionKey">The optional value of the partition key.</param>
-        public IMongoCollection<TDocument> GetCollection<TDocument>(string partitionKey = null)
+        public virtual IMongoCollection<TDocument> GetCollection<TDocument>(string partitionKey = null)
         {
             return Database.GetCollection<TDocument>(GetCollectionName<TDocument>(partitionKey));
         }
@@ -102,18 +72,49 @@ namespace MongoDbGenericRepository
         /// Drops a collection, use very carefully.
         /// </summary>
         /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        public void DropCollection<TDocument>(string partitionKey = null)
+        public virtual void DropCollection<TDocument>(string partitionKey = null)
         {
             Database.DropCollection(GetCollectionName<TDocument>(partitionKey));
         }
 
+        /// <summary>
+        /// Sets the Guid representation of the MongoDB Driver.
+        /// </summary>
+        /// <param name="guidRepresentation">The new value of the GuidRepresentation</param>
+        public virtual void SetGuidRepresentation(MongoDB.Bson.GuidRepresentation guidRepresentation)
+        {
+            MongoDefaults.GuidRepresentation = guidRepresentation;
+        }
+
+        /// <summary>
+        /// Extracts the CollectionName attribute from the entity type, if any.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <returns>The name of the collection in which the TDocument is stored.</returns>
+        protected virtual string GetAttributeCollectionName<TDocument>()
+        {
+            return (typeof(TDocument).GetTypeInfo()
+                                     .GetCustomAttributes(typeof(CollectionNameAttribute))
+                                     .FirstOrDefault() as CollectionNameAttribute)?.Name;
+        }
+
+        /// <summary>
+        /// Initialize the Guid representation of the MongoDB Driver.
+        /// Override this method to change the default GuidRepresentation.
+        /// </summary>
+        protected virtual void InitializeGuidRepresentation()
+        {
+            // by default, avoid legacy UUID representation: use Binary 0x04 subtype.
+            MongoDefaults.GuidRepresentation = MongoDB.Bson.GuidRepresentation.Standard;
+        }
+
         /// <summary>
         /// Given the document type and the partition key, returns the name of the collection it belongs to.
         /// </summary>
         /// <typeparam name="TDocument">The type representing a Document.</typeparam>
 	    /// <param name="partitionKey">The value of the partition key.</param>
         /// <returns>The name of the collection.</returns>
-        private string GetCollectionName<TDocument>(string partitionKey)
+        protected virtual string GetCollectionName<TDocument>(string partitionKey)
         {
             var collectionName = GetAttributeCollectionName<TDocument>() ?? Pluralize<TDocument>();
             if (string.IsNullOrEmpty(partitionKey))
@@ -128,7 +129,7 @@ namespace MongoDbGenericRepository
         /// </summary>
         /// <typeparam name="TDocument">The type representing a Document.</typeparam>
         /// <returns>The pluralized document name.</returns>
-        private string Pluralize<TDocument>()
+        protected virtual string Pluralize<TDocument>()
         {
             return (typeof(TDocument).Name.Pluralize()).Camelize();
         }
diff --git a/MongoDbGenericRepository/ReadOnlyMongoRepository.cs b/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
index fe995a9..4dfaf7e 100644
--- a/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
@@ -1,5 +1,10 @@
 using MongoDB.Driver;
+using MongoDbGenericRepository.DataAccess.Read;
+using MongoDbGenericRepository.Models;
 using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
@@ -33,5 +38,356 @@ namespace MongoDbGenericRepository
         protected ReadOnlyMongoRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
         {
         }
+
+
+        #region Read TKey
+
+        /// <summary>
+        /// Asynchronously returns one document given its id.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="id">The Id of the document you want to get.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public async virtual Task<TDocument> GetByIdAsync<TDocument, TKey>(TKey id, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.GetByIdAsync<TDocument, TKey>(id, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns one document given its id.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="id">The Id of the document you want to get.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TDocument GetById<TDocument, TKey>(TKey id, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetById<TDocument, TKey>(id, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously returns one document given an expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public async virtual Task<TDocument> GetOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.GetOneAsync<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns one document given an expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetOne<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns a collection cursor.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetCursor<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns true if any of the document of the collection matches the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public async virtual Task<bool> AnyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.AnyAsync<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns true if any of the document of the collection matches the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual bool Any<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.Any<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public async virtual Task<List<TDocument>> GetAllAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.GetAllAsync<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns a list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual List<TDocument> GetAll<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetAll<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously counts how many documents match the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partitionKey</param>
+        public async virtual Task<long> CountAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.CountAsync<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Counts how many documents match the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partitionKey</param>
+        public virtual long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.Count<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async virtual Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.GetByMaxAsync<TDocument, TKey>(filter, maxValueSelector, partitionKey);
+        }
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetByMax<TDocument, TKey>(filter, maxValueSelector, partitionKey);
+        }
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async virtual Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.GetByMinAsync<TDocument, TKey>(filter, minValueSelector, partitionKey);
+        }
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetByMin<TDocument, TKey>(filter, minValueSelector, partitionKey);
+        }
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async virtual Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.GetMaxValueAsync<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
+        }
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetMaxValue<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
+        }
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.GetMinValueAsync<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
+        }
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TValue GetMinValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetMinValue<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
+        }
+
+        #endregion
+
+        #region Sum TKey
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual async Task<int> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, int>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
+        }
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual int SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, int>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.SumBy<TDocument, TKey>(filter, selector, partitionKey);
+        }
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual async Task<decimal> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, decimal>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbReader.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
+        }
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual decimal SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, decimal>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.SumBy<TDocument, TKey>(filter, selector, partitionKey);
+        }
+
+        #endregion Sum TKey
+
     }
 }
\ No newline at end of file

From 29f01d2dab168a9233b418c9d7e0f6183407115d Mon Sep 17 00:00:00 2001
From: Alexandre SPIESER <a.spieser@gmail.com>
Date: Sun, 14 Apr 2019 17:58:31 +0100
Subject: [PATCH 2/4] better segregation of concern and interfaces.

---
 .../Abstractions/IBaseMongoRepository.cs      |  633 +---------
 .../Abstractions/IBaseReadOnlyRepository.cs   |  410 +++++++
 .../IKeyTypedReadOnlyMongoRepository.cs       |   94 ++
 .../IMongoDbCollectionIndexRepository.cs      |   96 --
 .../Abstractions/IReadOnlyMongoRepository.cs  |    7 +-
 .../BaseMongoDbRepository.IndexManagement.cs  |   72 --
 .../BaseMongoDbRepository.cs                  | 1037 -----------------
 .../BaseMongoRepository.Create.cs             |  186 +++
 .../BaseMongoRepository.Delete.cs             |  343 ++++++
 .../BaseMongoRepository.Index.cs              |  319 +++++
 .../BaseMongoRepository.Main.cs               |  211 ++++
 .../BaseMongoRepository.Update.cs             |  457 ++++++++
 .../BaseReadOnlyRepository.cs                 |  861 --------------
 .../DataAccess/Base/DataAccessBase.cs         |    8 +-
 .../Index/MongoDbIndexHandler.cs}             |  213 ++--
 ...MongoDbReader.cs => MongoDbReader.Main.cs} |   57 +-
 .../DataAccess/Read/MongoDbReader.Project.cs  |   90 ++
 .../KeyTypedBaseMongoDbRepository.Create.cs   |  114 ++
 .../KeyTypedBaseMongoDbRepository.Delete.cs   |  226 ++++
 .../KeyTypedBaseMongoDbRepository.Index.cs    |  226 ++++
 .../KeyTypedBaseMongoDbRepository.Main.cs     |   82 ++
 .../KeyTypedBaseMongoDbRepository.Update.cs}  |  211 ++--
 .../KeyTypedReadOnlyMongoRepository.cs        |  111 +-
 .../ReadOnlyMongoRepository.cs                |  181 ++-
 24 files changed, 3296 insertions(+), 2949 deletions(-)
 create mode 100644 MongoDbGenericRepository/Abstractions/IBaseReadOnlyRepository.cs
 delete mode 100644 MongoDbGenericRepository/Abstractions/IMongoDbCollectionIndexRepository.cs
 delete mode 100644 MongoDbGenericRepository/BaseMongoDbRepository.IndexManagement.cs
 delete mode 100644 MongoDbGenericRepository/BaseMongoDbRepository.cs
 create mode 100644 MongoDbGenericRepository/BaseMongoRepository.Create.cs
 create mode 100644 MongoDbGenericRepository/BaseMongoRepository.Delete.cs
 create mode 100644 MongoDbGenericRepository/BaseMongoRepository.Index.cs
 create mode 100644 MongoDbGenericRepository/BaseMongoRepository.Main.cs
 create mode 100644 MongoDbGenericRepository/BaseMongoRepository.Update.cs
 delete mode 100644 MongoDbGenericRepository/BaseReadOnlyRepository.cs
 rename MongoDbGenericRepository/{BaseMongoDbIndexRepository.cs => DataAccess/Index/MongoDbIndexHandler.cs} (73%)
 rename MongoDbGenericRepository/DataAccess/Read/{MongoDbReader.cs => MongoDbReader.Main.cs} (87%)
 create mode 100644 MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Project.cs
 create mode 100644 MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Create.cs
 create mode 100644 MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Delete.cs
 create mode 100644 MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Index.cs
 create mode 100644 MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Main.cs
 rename MongoDbGenericRepository/{KeyTypedBaseMongoDbRepository.cs => KeyTypedRepository/KeyTypedBaseMongoDbRepository.Update.cs} (60%)
 rename MongoDbGenericRepository/{ => KeyTypedRepository}/KeyTypedReadOnlyMongoRepository.cs (74%)

diff --git a/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs b/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs
index 64d9e99..9f7b39f 100644
--- a/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs
@@ -8,604 +8,12 @@ using System.Linq;
 
 namespace MongoDbGenericRepository
 {
-
     /// <summary>
     /// The IBaseMongoRepository exposes the CRUD functionality of the BaseMongoRepository.
     /// </summary>
-    public interface IBaseMongoRepository : IReadOnlyMongoRepository, IMongoDbCollectionIndexRepository
+    public interface IBaseMongoRepository : IReadOnlyMongoRepository, IBaseMongoRepository_Create, IBaseMongoRepository_Update, IBaseMongoRepository_Delete, IBaseMongoRepository_Index
     {
-        #region Create
 
-        /// <summary>
-        /// Asynchronously adds a document to the collection.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        Task AddOneAsync<TDocument>(TDocument document) where TDocument : IDocument;
-
-        /// <summary>
-        /// Adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        void AddOne<TDocument>(TDocument document) where TDocument : IDocument;
-
-        /// <summary>
-        /// Asynchronously adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The document you want to add.</param>
-        Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument;
-
-        /// <summary>
-        /// Adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The document you want to add.</param>
-        void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument;
-
-        #endregion
-
-        #region Create TKey
-
-        /// <summary>
-        /// Asynchronously adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        Task AddOneAsync<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        void AddOne<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Asynchronously adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documents">The documents you want to add.</param>
-        Task AddManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documents">The documents you want to add.</param>
-        void AddMany<TDocument, TKey>(IEnumerable<TDocument> documents)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        #endregion
-
-        #region Update
-
-        /// <summary>
-        /// Asynchronously Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        Task<bool> UpdateOneAsync<TDocument>(TDocument modifiedDocument) where TDocument : IDocument;
-
-        /// <summary>
-        /// Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        bool UpdateOne<TDocument>(TDocument modifiedDocument) where TDocument : IDocument;
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The value of the partition key.</param>
-        bool UpdateOne<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The value of the partition key.</param>
-        Task<bool> UpdateOneAsync<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        bool UpdateOne<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        Task<bool> UpdateOneAsync<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// For the entity selected by the filter, updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The partition key for the document.</param>
-        bool UpdateOne<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="update">The update definition for the document.</param>
-        Task<bool> UpdateOneAsync<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// For the entity selected by the filter, updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The partition key for the document.</param>
-        Task<bool> UpdateOneAsync<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="update">The update definition for the document.</param>
-        bool UpdateOne<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
-            where TDocument : IDocument;
-
-        #endregion
-
-        #region Update TKey
-
-        /// <summary>
-        /// Asynchronously Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument modifiedDocument)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        bool UpdateOne<TDocument, TKey>(TDocument modifiedDocument)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="update">The update definition for the document.</param>
-        Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="update">The update definition for the document.</param>
-        bool UpdateOne<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// For the entity selected by the filter, updates the property field with the given value..
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The partition key for the document.</param>
-        bool UpdateOne<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        Task<bool> UpdateOneAsync<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// For the entity selected by the filter, updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The partition key for the document.</param>
-        Task<bool> UpdateOneAsync<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        bool UpdateOne<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The value of the partition key.</param>
-        Task<bool> UpdateOneAsync<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The value of the partition key.</param>
-        bool UpdateOne<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        #endregion
-
-        #region Delete
-
-        /// <summary>
-        /// Asynchronously deletes a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        Task<long> DeleteOneAsync<TDocument>(TDocument document) where TDocument : IDocument;
-
-        /// <summary>
-        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Deletes a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteOne<TDocument>(TDocument document) where TDocument : IDocument;
-
-        /// <summary>
-        /// Deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        Task<long> DeleteManyAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Asynchronously deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        Task<long> DeleteManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument;
-
-        /// <summary>
-        /// Deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument;
-
-        /// <summary>
-        /// Deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteMany<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        #endregion
-
-        #region Delete TKey
-
-        /// <summary>
-        /// Deletes a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteOne<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        Task<long> DeleteOneAsync<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        Task<long> DeleteManyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Asynchronously deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        Task<long> DeleteManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        long DeleteMany<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        #endregion
-
-        #region Project
-
-        /// <summary>
-        /// Asynchronously returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<TProjection> ProjectOneAsync<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-                                        where TDocument : IDocument
-                                        where TProjection : class;
-
-        /// <summary>
-        /// Asynchronously returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-            where TProjection : class;
-
-        /// <summary>
-        /// Returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        TProjection ProjectOne<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-                                        where TDocument : IDocument
-                                        where TProjection : class;
-
-        /// <summary>
-        /// Returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        TProjection ProjectOne<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-                                        where TDocument : IDocument<TKey>
-                                        where TKey : IEquatable<TKey>
-                                        where TProjection : class;
-
-        /// <summary>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-                                        where TDocument : IDocument
-                                        where TProjection : class;
-
-        /// <summary>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-                                        where TDocument : IDocument<TKey>
-                                        where TKey : IEquatable<TKey>
-                                        where TProjection : class;
-
-        /// <summary>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        List<TProjection> ProjectMany<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-                                        where TDocument : IDocument
-                                        where TProjection : class;
-
-        /// <summary>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        List<TProjection> ProjectMany<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-            where TProjection : class;
-
-        #endregion
 
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
@@ -654,45 +62,6 @@ namespace MongoDbGenericRepository
         Task<TDocument> GetAndUpdateOne<TDocument, TKey>(FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TDocument> options)
                                         where TDocument : IDocument<TKey>
                                         where TKey : IEquatable<TKey>;
-
-        #region Grouping
-
-        /// <summary>
-        /// Groups a collection of documents given a grouping criteria, 
-        /// and returns a list of projected documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
-        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
-        /// <param name="groupingCriteria">The grouping criteria.</param>
-        /// <param name="groupProjection">The projected group result.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        List<TProjection> GroupBy<TDocument, TGroupKey, TProjection>(
-            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
-            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
-            string partitionKey = null)
-            where TDocument : IDocument
-            where TProjection : class, new();
-
-        /// <summary>
-        /// Groups filtered a collection of documents given a grouping criteria, 
-        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
-        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
-        /// <param name="filter"></param>
-        /// <param name="selector">The grouping criteria.</param>
-        /// <param name="projection">The projected group result.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        List<TProjection> GroupBy<TDocument, TGroupKey, TProjection>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, TGroupKey>> selector,
-                                                       Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> projection,
-                                                       string partitionKey = null)
-                                                       where TDocument : IDocument
-                                                       where TProjection : class, new();
-
-        #endregion
     }
 
 }
diff --git a/MongoDbGenericRepository/Abstractions/IBaseReadOnlyRepository.cs b/MongoDbGenericRepository/Abstractions/IBaseReadOnlyRepository.cs
new file mode 100644
index 0000000..32d5c92
--- /dev/null
+++ b/MongoDbGenericRepository/Abstractions/IBaseReadOnlyRepository.cs
@@ -0,0 +1,410 @@
+using MongoDB.Driver;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository
+{
+    public interface IBaseReadOnlyRepository
+    {
+        /// <summary>
+        /// The connection string.
+        /// </summary>
+        string ConnectionString { get; }
+
+        /// <summary>
+        /// The database name.
+        /// </summary>
+        string DatabaseName { get; }
+
+        #region Read TKey
+
+        /// <summary>
+        /// Asynchronously returns one document given its id.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="id">The Id of the document you want to get.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<TDocument> GetByIdAsync<TDocument, TKey>(TKey id, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns one document given its id.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="id">The Id of the document you want to get.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TDocument GetById<TDocument, TKey>(TKey id, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously returns one document given an expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<TDocument> GetOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns one document given an expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns a collection cursor.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+
+        /// <summary>
+        /// Returns true if any of the document of the collection matches the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<bool> AnyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns true if any of the document of the collection matches the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        bool Any<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously returns a list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<List<TDocument>> GetAllAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns a list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        List<TDocument> GetAll<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously counts how many documents match the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partitionKey</param>
+        Task<long> CountAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Counts how many documents match the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partitionKey</param>
+        long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        #endregion
+
+        #region Min / Max
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TValue GetMinValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        #endregion
+
+        #region Sum
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        Task<int> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, int>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        int SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, int>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        Task<decimal> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, decimal>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Sums the values of a selected field for a given filtered collection of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The field you want to sum.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        decimal SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
+                                                       Expression<Func<TDocument, decimal>> selector,
+                                                       string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        #endregion Sum
+
+        #region Project TKey
+
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter"></param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter"></param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TProjection ProjectOne<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+                                        where TDocument : IDocument<TKey>
+                                        where TKey : IEquatable<TKey>
+                                        where TProjection : class;
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter"></param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+                                        where TDocument : IDocument<TKey>
+                                        where TKey : IEquatable<TKey>
+                                        where TProjection : class;
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter"></param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        List<TProjection> ProjectMany<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+
+        #endregion
+
+        #region Group By
+
+        /// <summary>
+        /// Groups filtered a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The grouping criteria.</param>
+        /// <param name="projection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        List<TProjection> GroupBy<TDocument, TGroupKey, TProjection, TKey>(
+            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class, new();
+
+        /// <summary>
+        /// Groups filtered a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="groupingCriteria">The grouping criteria.</param>
+        /// <param name="groupProjection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        List<TProjection> GroupBy<TDocument, TGroupKey, TProjection, TKey>(
+            Expression<Func<TDocument, bool>> filter,
+            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
+            string partitionKey = null)
+                where TDocument : IDocument<TKey>
+                where TKey : IEquatable<TKey>
+                where TProjection : class, new();
+
+        #endregion Group By
+    }
+}
diff --git a/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs b/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs
index 2b73f76..847a2a4 100644
--- a/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 using MongoDB.Driver;
@@ -241,5 +242,98 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>;
 
         #endregion Maths
+
+        #region Project
+
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<TProjection> ProjectOneAsync<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TProjection ProjectOne<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        List<TProjection> ProjectMany<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
+        #endregion Project
+
+        #region Group By
+
+        /// <summary>
+        /// Groups a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="groupingCriteria">The grouping criteria.</param>
+        /// <param name="groupProjection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        List<TProjection> GroupBy<TDocument, TGroupKey, TProjection>(
+            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class, new();
+
+        /// <summary>
+        /// Groups filtered a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="groupingCriteria">The grouping criteria.</param>
+        /// <param name="groupProjection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        List<TProjection> GroupBy<TDocument, TGroupKey, TProjection>(
+            Expression<Func<TDocument, bool>> filter,
+            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
+            string partitionKey = null)
+                where TDocument : IDocument<TKey>
+                where TProjection : class, new();
+
+        #endregion Group By
     }
 }
\ No newline at end of file
diff --git a/MongoDbGenericRepository/Abstractions/IMongoDbCollectionIndexRepository.cs b/MongoDbGenericRepository/Abstractions/IMongoDbCollectionIndexRepository.cs
deleted file mode 100644
index 3fa09b9..0000000
--- a/MongoDbGenericRepository/Abstractions/IMongoDbCollectionIndexRepository.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-using MongoDbGenericRepository.Models;
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using System.Threading.Tasks;
-
-namespace MongoDbGenericRepository
-{
-    /// <summary>
-    /// The repository interface for managing indexes
-    /// </summary>
-    public interface IMongoDbCollectionIndexRepository : IBaseMongoDbIndexRepository
-    {
-        /// <summary>
-        /// Create a text index on the given field.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateTextIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Creates an index on the given field in ascending order.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateAscendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Creates an index on the given field in descending order.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>A string containing the result of the operation.</returns>
-        Task<string> CreateDescendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Creates a hashed index on the given field.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>A string containing the result of the operation.</returns>
-        Task<string> CreateHashedIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Creates a combined text index.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="fields">The fields we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateCombinedTextIndexAsync<TDocument>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Drops the index given a field name
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="indexName">The name of the index</param>
-        /// <param name="partitionKey">An optional partition key</param>
-        Task DropIndexAsync<TDocument>(string indexName, string partitionKey = null)
-            where TDocument : IDocument;
-
-        /// <summary>
-        /// Returns the names of the indexes present on a collection.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="partitionKey">An optional partition key</param>
-        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
-        Task<List<string>> GetIndexesNamesAsync<TDocument>(string partitionKey = null)
-            where TDocument : IDocument;
-    }
-}
diff --git a/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.cs b/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.cs
index a5e295e..61d6a44 100644
--- a/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.cs
@@ -1,4 +1,8 @@
-using System;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
@@ -7,5 +11,6 @@ namespace MongoDbGenericRepository
     /// </summary>
     public interface IReadOnlyMongoRepository : IBaseReadOnlyRepository, IKeyTypedReadOnlyMongoRepository<Guid>
     {
+
     }
 }
diff --git a/MongoDbGenericRepository/BaseMongoDbRepository.IndexManagement.cs b/MongoDbGenericRepository/BaseMongoDbRepository.IndexManagement.cs
deleted file mode 100644
index b82294f..0000000
--- a/MongoDbGenericRepository/BaseMongoDbRepository.IndexManagement.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using System.Linq.Expressions;
-using MongoDbGenericRepository.Models;
-using System.Linq;
-
-namespace MongoDbGenericRepository
-{
-    /// <summary>
-    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
-    /// Its constructor must be given a connection string and a database name.
-    /// </summary>
-    public abstract partial class BaseMongoRepository : ReadOnlyMongoRepository, IBaseMongoRepository
-    {
-        #region Index Management
-
-        /// <inheritdoc />
-        public async Task<string> CreateTextIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument
-        {
-            return await CreateTextIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
-        }
-
-        /// <inheritdoc />
-        public async Task<string> CreateAscendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null) where TDocument : IDocument
-        {
-            return await CreateAscendingIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
-        }
-
-        /// <inheritdoc />
-        public async Task<string> CreateDescendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument
-        {
-            return await CreateDescendingIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
-        }
-
-
-        /// <inheritdoc />
-        public async Task<string> CreateHashedIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument
-        {
-            return await CreateHashedIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
-        }
-
-        /// <inheritdoc />
-        public async Task<string> CreateCombinedTextIndexAsync<TDocument>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null) where TDocument : IDocument
-        {
-            return await CreateCombinedTextIndexAsync<TDocument, Guid>(fields, indexCreationOptions, partitionKey);
-        }
-
-
-        /// <inheritdoc />
-        public async Task DropIndexAsync<TDocument>(string indexName, string partitionKey = null)
-            where TDocument : IDocument
-        {
-            await DropIndexAsync<TDocument, Guid>(indexName, partitionKey);
-        }
-
-        /// <inheritdoc />
-        public async Task<List<string>> GetIndexesNamesAsync<TDocument>(string partitionKey = null)
-            where TDocument : IDocument
-        {
-            return await GetIndexesNamesAsync<TDocument, Guid>(partitionKey);
-        }
-
-        #endregion Index Management
-
-
-    }
-}
\ No newline at end of file
diff --git a/MongoDbGenericRepository/BaseMongoDbRepository.cs b/MongoDbGenericRepository/BaseMongoDbRepository.cs
deleted file mode 100644
index 2fd1ad2..0000000
--- a/MongoDbGenericRepository/BaseMongoDbRepository.cs
+++ /dev/null
@@ -1,1037 +0,0 @@
-using MongoDB.Driver;
-using MongoDbGenericRepository.DataAccess.Create;
-using MongoDbGenericRepository.DataAccess.Update;
-using MongoDbGenericRepository.Models;
-using MongoDbGenericRepository.Utils;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading.Tasks;
-
-namespace MongoDbGenericRepository
-{
-    /// <summary>
-    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
-    /// Its constructor must be given a connection string and a database name.
-    /// </summary>
-    public abstract partial class BaseMongoRepository : ReadOnlyMongoRepository, IBaseMongoRepository
-    {
-        private object _initLock;
-        private MongoDbCreator _mongoDbCreator;
-        protected MongoDbCreator MongoDbCreator
-        {
-            get
-            {
-                if (_mongoDbCreator != null) { return _mongoDbCreator; }
-
-                lock (_initLock)
-                {
-                    if (_mongoDbCreator == null)
-                    {
-                        _mongoDbCreator = new MongoDbCreator(MongoDbContext);
-                    }
-                }
-
-                return _mongoDbCreator;
-            }
-        }
-
-        private MongoDbUpdater _mongoDbUpdater;
-        protected MongoDbUpdater MongoDbUpdater
-        {
-            get
-            {
-                if (_mongoDbUpdater != null) { return _mongoDbUpdater; }
-
-                lock (_initLock)
-                {
-                    if (_mongoDbUpdater == null)
-                    {
-                        _mongoDbUpdater = new MongoDbUpdater(MongoDbContext);
-                    }
-                }
-
-                return _mongoDbUpdater;
-            }
-        }
-
-        /// <summary>
-        /// The constructor taking a connection string and a database name.
-        /// </summary>
-        /// <param name="connectionString">The connection string of the MongoDb server.</param>
-        /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
-        protected BaseMongoRepository(string connectionString, string databaseName = null) : base(connectionString, databaseName)
-        {
-        }
-
-        /// <summary>
-        /// The contructor taking a <see cref="IMongoDbContext"/>.
-        /// </summary>
-        /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
-        protected BaseMongoRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
-        {
-        }
-
-        /// <summary>
-        /// The contructor taking a <see cref="IMongoDatabase"/>.
-        /// </summary>
-        /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
-        protected BaseMongoRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
-        {
-        }
-
-        #region Create TKey
-
-        /// <summary>
-        /// Asynchronously adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public virtual async Task AddOneAsync<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            await MongoDbCreator.AddOneAsync<TDocument, TKey>(document);
-        }
-
-        /// <summary>
-        /// Adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public virtual void AddOne<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            MongoDbCreator.AddOne<TDocument, TKey>(document);
-        }
-
-        /// <summary>
-        /// Asynchronously adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documents">The documents you want to add.</param>
-        public virtual async Task AddManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            await MongoDbCreator.AddManyAsync<TDocument, TKey>(documents);
-        }
-
-        /// <summary>
-        /// Adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documents">The documents you want to add.</param>
-        public virtual void AddMany<TDocument, TKey>(IEnumerable<TDocument> documents)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            MongoDbCreator.AddMany<TDocument, TKey>(documents);
-        }
-
-        #endregion 
-
-        #region Update
-
-        /// <summary>
-        /// Asynchronously Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument>(TDocument modifiedDocument) where TDocument : IDocument
-        {
-            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid>(modifiedDocument);
-        }
-
-        /// <summary>
-        /// Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        public virtual bool UpdateOne<TDocument>(TDocument modifiedDocument) where TDocument : IDocument
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, Guid>(modifiedDocument);
-        }
-
-        /// <summary>
-        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="update">The update definition for the document.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
-            where TDocument : IDocument
-        {
-            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid>(documentToModify, update);
-
-        }
-
-        /// <summary>
-        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="update">The update definition for the document.</param>
-        public virtual bool UpdateOne<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
-            where TDocument : IDocument
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, Guid>(documentToModify, update);
-        }
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        public virtual bool UpdateOne<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
-            where TDocument : IDocument
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, Guid, TField>(documentToModify, field, value);
-        }
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
-            where TDocument : IDocument
-        {
-            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid, TField>(documentToModify, field, value);
-        }
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The value of the partition key.</param>
-        public virtual bool UpdateOne<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, Guid, TField>(filter, field, value, partitionKey);
-        }
-
-        /// <summary>
-        /// For the entity selected by the filter, updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The partition key for the document.</param>
-        public virtual bool UpdateOne<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, Guid, TField>(filter, field, value, partitionKey);
-        }
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The value of the partition key.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument
-        {
-            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid, TField>(filter, field, value, partitionKey);
-        }
-
-        /// <summary>
-        /// For the entity selected by the filter, updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The partition key for the document.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument
-        {
-            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid, TField>(filter, field, value, partitionKey);
-        }
-
-
-        #endregion Update
-
-        #region Update TKey
-
-        /// <summary>
-        /// Asynchronously Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument modifiedDocument)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey>(modifiedDocument);
-        }
-
-        /// <summary>
-        /// Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        public virtual bool UpdateOne<TDocument, TKey>(TDocument modifiedDocument)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, TKey>(modifiedDocument);
-        }
-
-        /// <summary>
-        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="update">The update definition for the document.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey>(documentToModify, update);
-        }
-
-        /// <summary>
-        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="update">The update definition for the document.</param>
-        public virtual bool UpdateOne<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, TKey>(documentToModify, update);
-        }
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        public virtual bool UpdateOne<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(documentToModify, field, value);
-        }
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="documentToModify">The document you want to modify.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(documentToModify, field, value);
-        }
-
-        /// <summary>
-        /// Updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The value of the partition key.</param>
-        public virtual bool UpdateOne<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(filter, field, value, partitionKey);
-        }
-
-        /// <summary>
-        /// For the entity selected by the filter, updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The partition key for the document.</param>
-        public virtual bool UpdateOne<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(filter, field, value, partitionKey);
-        }
-
-        /// <summary>
-        /// Updates the property field with the given value update a property field in entities.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The value of the partition key.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(filter, field, value, partitionKey);
-        }
-
-        /// <summary>
-        /// For the entity selected by the filter, updates the property field with the given value.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TField">The type of the field.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="field">The field selector.</param>
-        /// <param name="value">The new value of the property field.</param>
-        /// <param name="partitionKey">The partition key for the document.</param>
-        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await UpdateOneAsync<TDocument, TKey, TField>(Builders<TDocument>.Filter.Where(filter), field, value, partitionKey);
-        }
-
-        #endregion Update
-
-        #region Delete
-
-        /// <summary>
-        /// Asynchronously deletes a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual async Task<long> DeleteOneAsync<TDocument>(TDocument document) where TDocument : IDocument
-        {
-            return await DeleteOneAsync<TDocument, Guid>(document);
-        }
-
-        /// <summary>
-        /// Deletes a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual long DeleteOne<TDocument>(TDocument document) where TDocument : IDocument
-        {
-            return DeleteOne<TDocument, Guid>(document);
-        }
-
-        /// <summary>
-        /// Deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return DeleteOne<TDocument, Guid>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual async Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return await DeleteOneAsync<TDocument, Guid>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual async Task<long> DeleteManyAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return (await HandlePartitioned<TDocument>(partitionKey).DeleteManyAsync(filter)).DeletedCount;
-        }
-
-        /// <summary>
-        /// Asynchronously deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual async Task<long> DeleteManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument
-        {
-            return await DeleteManyAsync<TDocument, Guid>(documents);
-        }
-
-        /// <summary>
-        /// Deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual long DeleteMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument
-        {
-            return DeleteMany<TDocument, Guid>(documents);
-        }
-
-        /// <summary>
-        /// Deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual long DeleteMany<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return HandlePartitioned<TDocument>(partitionKey).DeleteMany(filter).DeletedCount;
-        }
-
-        #endregion Delete
-
-        #region Delete TKey
-
-        /// <summary>
-        /// Deletes a document.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual long DeleteOne<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var filter = Builders<TDocument>.Filter.Eq("Id", document.Id);
-            return HandlePartitioned<TDocument, TKey>(document).DeleteOne(filter).DeletedCount;
-        }
-
-        /// <summary>
-        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var filter = Builders<TDocument>.Filter.Eq("Id", document.Id);
-            return (await HandlePartitioned<TDocument, TKey>(document).DeleteOneAsync(filter)).DeletedCount;
-        }
-
-        /// <summary>
-        /// Deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOne(filter).DeletedCount;
-        }
-
-        /// <summary>
-        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return (await HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOneAsync(filter)).DeletedCount;
-        }
-
-        /// <summary>
-        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual async Task<long> DeleteManyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return (await HandlePartitioned<TDocument, TKey>(partitionKey).DeleteManyAsync(filter)).DeletedCount;
-        }
-
-        /// <summary>
-        /// Asynchronously deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual async Task<long> DeleteManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            if (!documents.Any())
-            {
-                return 0;
-            }
-            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
-            if (documents.Any(e => e is IPartitionedDocument))
-            {
-                long deleteCount = 0;
-                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
-                {
-                    var groupIdsTodelete = group.Select(e => e.Id).ToArray();
-                    deleteCount += (await HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).DeleteManyAsync(x => groupIdsTodelete.Contains(x.Id))).DeletedCount;
-                }
-                return deleteCount;
-            }
-            else
-            {
-                var idsTodelete = documents.Select(e => e.Id).ToArray();
-                return (await HandlePartitioned<TDocument, TKey>(documents.FirstOrDefault()).DeleteManyAsync(x => idsTodelete.Contains(x.Id))).DeletedCount;
-            }
-        }
-
-        /// <summary>
-        /// Deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            if (!documents.Any())
-            {
-                return 0;
-            }
-            // cannot use typeof(IPartitionedDocument).IsAssignableFrom(typeof(TDocument)), not available in netstandard 1.5
-            if (documents.Any(e => e is IPartitionedDocument))
-            {
-                long deleteCount = 0;
-                foreach (var group in documents.GroupBy(e => ((IPartitionedDocument)e).PartitionKey))
-                {
-                    var groupIdsTodelete = group.Select(e => e.Id).ToArray();
-                    deleteCount += (HandlePartitioned<TDocument, TKey>(group.FirstOrDefault()).DeleteMany(x => groupIdsTodelete.Contains(x.Id))).DeletedCount;
-                }
-                return deleteCount;
-            }
-            else
-            {
-                var idsTodelete = documents.Select(e => e.Id).ToArray();
-                return (HandlePartitioned<TDocument, TKey>(documents.FirstOrDefault()).DeleteMany(x => idsTodelete.Contains(x.Id))).DeletedCount;
-            }
-        }
-
-        /// <summary>
-        /// Deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public virtual long DeleteMany<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteMany(filter).DeletedCount;
-        }
-
-        #endregion
-
-        #region Project
-
-        /// <summary>
-        /// Asynchronously returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual async Task<TProjection> ProjectOneAsync<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument
-            where TProjection : class
-        {
-            return await HandlePartitioned<TDocument>(partitionKey).Find(filter)
-                                                                   .Project(projection)
-                                                                   .FirstOrDefaultAsync();
-        }
-
-        /// <summary>
-        /// Asynchronously returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual async Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-            where TProjection : class
-        {
-            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter)
-                                                                         .Project(projection)
-                                                                         .FirstOrDefaultAsync();
-        }
-
-        /// <summary>
-        /// Returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual TProjection ProjectOne<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument
-            where TProjection : class
-        {
-            return HandlePartitioned<TDocument>(partitionKey).Find(filter)
-                                                             .Project(projection)
-                                                             .FirstOrDefault();
-        }
-
-        /// <summary>
-        /// Returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual TProjection ProjectOne<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-            where TProjection : class
-        {
-            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter)
-                                                                   .Project(projection)
-                                                                   .FirstOrDefault();
-        }
-
-        /// <summary>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual async Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument
-            where TProjection : class
-        {
-            return await HandlePartitioned<TDocument>(partitionKey).Find(filter)
-                                                                   .Project(projection)
-                                                                   .ToListAsync();
-        }
-
-        /// <summary>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual async Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-            where TProjection : class
-        {
-            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter)
-                                                                   .Project(projection)
-                                                                   .ToListAsync();
-        }
-
-        /// <summary>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual List<TProjection> ProjectMany<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument
-            where TProjection : class
-        {
-            return HandlePartitioned<TDocument>(partitionKey).Find(filter)
-                                                             .Project(projection)
-                                                             .ToList();
-        }
-
-        /// <summary>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
-        /// <param name="filter">The document filter.</param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual List<TProjection> ProjectMany<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-            where TProjection : class
-        {
-            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter)
-                                                             .Project(projection)
-                                                             .ToList();
-        }
-
-        #endregion
-
-        #region Grouping
-
-        /// <summary>
-        /// Groups a collection of documents given a grouping criteria, 
-        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
-        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
-        /// <param name="groupingCriteria">The grouping criteria.</param>
-        /// <param name="groupProjection">The projected group result.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        public virtual List<TProjection> GroupBy<TDocument, TGroupKey, TProjection>(
-            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
-            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
-            string partitionKey = null)
-            where TDocument : IDocument
-            where TProjection : class, new()
-        {
-            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument>() : GetCollection<TDocument>(partitionKey);
-            return collection.Aggregate()
-                             .Group(groupingCriteria, groupProjection)
-                             .ToList();
-
-        }
-
-        /// <summary>
-        /// Groups filtered a collection of documents given a grouping criteria, 
-        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
-        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="selector">The grouping criteria.</param>
-        /// <param name="projection">The projected group result.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        public virtual List<TProjection> GroupBy<TDocument, TGroupKey, TProjection>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, TGroupKey>> selector,
-                                                       Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> projection,
-                                                       string partitionKey = null)
-                                                       where TDocument : IDocument
-                                                       where TProjection : class, new()
-        {
-            var collection = string.IsNullOrEmpty(partitionKey) ? GetCollection<TDocument>() : GetCollection<TDocument>(partitionKey);
-            return collection.Aggregate()
-                             .Match(Builders<TDocument>.Filter.Where(filter))
-                             .Group(selector, projection)
-                             .ToList();
-        }
-
-
-        #endregion
-
-        /// <summary>
-        /// Asynchronously returns a paginated list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="sortSelector">The property selector.</param>
-        /// <param name="ascending">Order of the sorting.</param>
-        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
-        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual async Task<List<TDocument>> GetSortedPaginatedAsync<TDocument>(
-            Expression<Func<TDocument, bool>> filter,
-            Expression<Func<TDocument, object>> sortSelector,
-            bool ascending = true,
-            int skipNumber = 0,
-            int takeNumber = 50,
-            string partitionKey = null)
-            where TDocument : IDocument
-        {
-            var sorting = ascending
-                ? Builders<TDocument>.Sort.Ascending(sortSelector)
-                : Builders<TDocument>.Sort.Descending(sortSelector);
-
-            return await HandlePartitioned<TDocument>(partitionKey)
-                    .Find(filter)
-                    .Sort(sorting)
-                    .Skip(skipNumber)
-                    .Limit(takeNumber)
-                    .ToListAsync();
-        }
-
-
-        /// <summary>
-        /// Asynchronously returns a paginated list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
-        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual async Task<List<TDocument>> GetPaginatedAsync<TDocument>(
-            Expression<Func<TDocument, bool>> filter,
-            int skipNumber = 0,
-            int takeNumber = 50,
-            string partitionKey = null)
-            where TDocument : IDocument
-        {
-            return await HandlePartitioned<TDocument>(partitionKey).Find(filter).Skip(skipNumber).Limit(takeNumber).ToListAsync();
-        }
-
-        /// <summary>
-        /// Asynchronously returns a paginated list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
-        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual async Task<List<TDocument>> GetPaginatedAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, int skipNumber = 0, int takeNumber = 50, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).Skip(skipNumber).Limit(takeNumber).ToListAsync();
-        }
-
-        #region Find And Update
-
-        /// <summary>
-        /// GetAndUpdateOne with filter
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="update"></param>
-        /// <param name="options"></param>
-        /// <returns></returns>
-        public virtual async Task<TDocument> GetAndUpdateOne<TDocument>(FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TDocument> options) where TDocument : IDocument
-        {
-            return await GetCollection<TDocument>().FindOneAndUpdateAsync(filter, update, options);
-        }
-
-        /// <summary>
-        /// GetAndUpdateOne with filter
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="update"></param>
-        /// <param name="options"></param>
-        /// <returns></returns>
-        public virtual async Task<TDocument> GetAndUpdateOne<TDocument, TKey>(FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TDocument> options)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await GetCollection<TDocument, TKey>().FindOneAndUpdateAsync(filter, update, options);
-        }
-
-        #endregion Find And Update
-
-        /// <summary>
-        /// Sets the value of the document Id if it is not set already.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="document">The document.</param>
-        protected void FormatDocument<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            if (document == null)
-            {
-                throw new ArgumentNullException(nameof(document));
-            }
-            var defaultTKey = default(TKey);
-            if (document.Id == null
-                || (defaultTKey != null
-                    && defaultTKey.Equals(document.Id)))
-            {
-                document.Id = IdGenerator.GetId<TKey>();
-            }
-        }
-
-        /// <summary>
-        /// Sets the value of the document Id if it is not set already.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <param name="document">The document.</param>
-        protected void FormatDocument<TDocument>(TDocument document) where TDocument : IDocument
-        {
-            if (document == null)
-            {
-                throw new ArgumentNullException(nameof(document));
-            }
-            if (document.Id == default(Guid))
-            {
-                document.Id = Guid.NewGuid();
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Create.cs b/MongoDbGenericRepository/BaseMongoRepository.Create.cs
new file mode 100644
index 0000000..5e772de
--- /dev/null
+++ b/MongoDbGenericRepository/BaseMongoRepository.Create.cs
@@ -0,0 +1,186 @@
+using MongoDbGenericRepository.DataAccess.Create;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository
+{
+    public interface IBaseMongoRepository_Create : IKeyTypedBaseMongoDbRepository_Create<Guid>
+    {
+        /// <summary>
+        /// Asynchronously adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        Task AddOneAsync<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        void AddOne<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        Task AddManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        void AddMany<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+    }
+
+    /// <summary>
+    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
+    /// Its constructor must be given a connection string and a database name.
+    /// </summary>
+    public abstract partial class BaseMongoRepository : IBaseMongoRepository_Create
+    {
+        private readonly object _initLock = new object();
+        private MongoDbCreator _mongoDbCreator;
+        protected MongoDbCreator MongoDbCreator
+        {
+            get
+            {
+                if (_mongoDbCreator != null) { return _mongoDbCreator; }
+
+                lock (_initLock)
+                {
+                    if (_mongoDbCreator == null)
+                    {
+                        _mongoDbCreator = new MongoDbCreator(MongoDbContext);
+                    }
+                }
+
+                return _mongoDbCreator;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public virtual async Task AddOneAsync<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            await MongoDbCreator.AddOneAsync<TDocument, TKey>(document);
+        }
+
+        /// <summary>
+        /// Asynchronously adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public virtual async Task AddOneAsync<TDocument>(TDocument document) 
+            where TDocument : IDocument<Guid>
+        {
+            await MongoDbCreator.AddOneAsync<TDocument, Guid>(document);
+        }
+
+        /// <summary>
+        /// Adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public virtual void AddOne<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            MongoDbCreator.AddOne<TDocument, TKey>(document);
+        }
+
+        /// <summary>
+        /// Adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public virtual void AddOne<TDocument>(TDocument document) where TDocument : IDocument<Guid>
+        {
+            MongoDbCreator.AddOne<TDocument, Guid>(document);
+        }
+
+        /// <summary>
+        /// Asynchronously adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        public virtual async Task AddManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            await MongoDbCreator.AddManyAsync<TDocument, TKey>(documents);
+        }
+
+        /// <summary>
+        /// Asynchronously adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        public virtual async Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) 
+            where TDocument : IDocument<Guid>
+        {
+            await MongoDbCreator.AddManyAsync<TDocument, Guid>(documents);
+        }
+
+        /// <summary>
+        /// Adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        public virtual void AddMany<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            MongoDbCreator.AddMany<TDocument, TKey>(documents);
+        }
+
+        /// <summary>
+        /// Adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        public virtual void AddMany<TDocument>(IEnumerable<TDocument> documents) 
+            where TDocument : IDocument<Guid>
+        {
+            MongoDbCreator.AddMany<TDocument, Guid>(documents);
+        }
+    }
+
+}
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Delete.cs b/MongoDbGenericRepository/BaseMongoRepository.Delete.cs
new file mode 100644
index 0000000..5c74794
--- /dev/null
+++ b/MongoDbGenericRepository/BaseMongoRepository.Delete.cs
@@ -0,0 +1,343 @@
+using MongoDbGenericRepository.DataAccess.Delete;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository
+{
+    public interface IBaseMongoRepository_Delete : IKeyTypedBaseMongoDbRepository_Delete<Guid>
+    {
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteOneAsync<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteManyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteMany<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+    }
+
+    public abstract partial class BaseMongoRepository : IBaseMongoRepository_Delete
+    {
+        private MongoDbEraser _mongoDbEraser;
+        protected MongoDbEraser MongoDbEraser
+        {
+            get
+            {
+                if (_mongoDbEraser != null) { return _mongoDbEraser; }
+
+                lock (_initLock)
+                {
+                    if (_mongoDbEraser == null)
+                    {
+                        _mongoDbEraser = new MongoDbEraser(MongoDbContext);
+                    }
+                }
+
+                return _mongoDbEraser;
+            }
+        }
+
+        #region Delete
+
+        /// <summary>
+        /// Asynchronously deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument>(TDocument document) where TDocument : IDocument<Guid>
+        {
+            return await MongoDbEraser.DeleteOneAsync<TDocument, Guid>(document);
+        }
+
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument>(TDocument document) where TDocument : IDocument<Guid>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, Guid>(document);
+        }
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<Guid>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, Guid>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<Guid>
+        {
+            return await MongoDbEraser.DeleteOneAsync<TDocument, Guid>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<Guid>
+        {
+            return await MongoDbEraser.DeleteManyAsync<TDocument, Guid>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<Guid>
+        {
+            return await DeleteManyAsync<TDocument, Guid>(documents);
+        }
+
+        /// <summary>
+        /// Deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<Guid>
+        {
+            return DeleteMany<TDocument, Guid>(documents);
+        }
+
+        /// <summary>
+        /// Deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteMany<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<Guid>
+        {
+            return MongoDbEraser.DeleteMany<TDocument, Guid>(filter, partitionKey);
+        }
+
+        #endregion Delete
+
+        #region Delete TKey
+
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(document);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(document);
+        }
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbEraser.DeleteManyAsync<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbEraser.DeleteManyAsync<TDocument, TKey>(documents);
+        }
+
+        /// <summary>
+        /// Deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbEraser.DeleteMany<TDocument, TKey>(documents);
+        }
+
+        /// <summary>
+        /// Deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteMany<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbEraser.DeleteMany<TDocument, TKey>(filter, partitionKey);
+        }
+
+        #endregion
+
+    }
+}
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Index.cs b/MongoDbGenericRepository/BaseMongoRepository.Index.cs
new file mode 100644
index 0000000..d973a16
--- /dev/null
+++ b/MongoDbGenericRepository/BaseMongoRepository.Index.cs
@@ -0,0 +1,319 @@
+using MongoDbGenericRepository.DataAccess.Index;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Linq.Expressions;
+using MongoDbGenericRepository.Models;
+
+namespace MongoDbGenericRepository
+{
+    public interface IBaseMongoRepository_Index : IKeyTypedBaseMongoDbRepository_Index<Guid>
+    {
+        /// <summary>
+        /// Returns the names of the indexes present on a collection.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="partitionKey">An optional partition key</param>
+        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
+        Task<List<string>> GetIndexesNamesAsync<TDocument, TKey>(string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Create a text index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateTextIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Creates an index on the given field in ascending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateAscendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Creates an index on the given field in descending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateDescendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+        where TDocument : IDocument<TKey>
+        where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Creates a hashed index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateHashedIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Creates a combined text index.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="fields">The fields we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateCombinedTextIndexAsync<TDocument, TKey>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Drops the index given a field name
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="indexName">The name of the index</param>
+        /// <param name="partitionKey">An optional partition key</param>
+        Task DropIndexAsync<TDocument, TKey>(string indexName, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+    }
+    /// <summary>
+    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
+    /// Its constructor must be given a connection string and a database name.
+    /// </summary>
+    public abstract partial class BaseMongoRepository : IBaseMongoRepository_Index
+    {
+        private MongoDbIndexHandler _mongoDbIndexHandler;
+        protected MongoDbIndexHandler MongoDbIndexHandler
+        {
+            get
+            {
+                if (_mongoDbIndexHandler != null) { return _mongoDbIndexHandler; }
+
+                lock (_initLock)
+                {
+                    if (_mongoDbIndexHandler == null)
+                    {
+                        _mongoDbIndexHandler = new MongoDbIndexHandler(MongoDbContext);
+                    }
+                }
+                return _mongoDbIndexHandler;
+            }
+        }
+
+        /// <summary>
+        /// Returns the names of the indexes present on a collection.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="partitionKey">An optional partition key</param>
+        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
+        public async Task<List<string>> GetIndexesNamesAsync<TDocument>(string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbIndexHandler.GetIndexesNamesAsync<TDocument, Guid>(partitionKey);
+        }
+
+        /// <summary>
+        /// Returns the names of the indexes present on a collection.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="partitionKey">An optional partition key</param>
+        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
+        public async virtual Task<List<string>> GetIndexesNamesAsync<TDocument, TKey>(string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbIndexHandler.GetIndexesNamesAsync<TDocument, TKey>(partitionKey);
+        }
+
+        /// <summary>
+        /// Create a text index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async Task<string> CreateTextIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbIndexHandler.CreateTextIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Create a text index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async virtual Task<string> CreateTextIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbIndexHandler.CreateTextIndexAsync<TDocument, TKey>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Creates an index on the given field in ascending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async Task<string> CreateAscendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null) 
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbIndexHandler.CreateAscendingIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Creates an index on the given field in ascending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async virtual Task<string> CreateAscendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbIndexHandler.CreateAscendingIndexAsync<TDocument, TKey>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Creates an index on the given field in descending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async Task<string> CreateDescendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbIndexHandler.CreateDescendingIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <inheritdoc />
+        public async virtual Task<string> CreateDescendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbIndexHandler.CreateDescendingIndexAsync<TDocument, TKey>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Creates a hashed index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async Task<string> CreateHashedIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbIndexHandler.CreateHashedIndexAsync<TDocument, Guid>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <inheritdoc />
+        public async virtual Task<string> CreateHashedIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbIndexHandler.CreateHashedIndexAsync<TDocument, TKey>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Creates a combined text index.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="fields">The fields we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async Task<string> CreateCombinedTextIndexAsync<TDocument>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null) 
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbIndexHandler.CreateCombinedTextIndexAsync<TDocument, Guid>(fields, indexCreationOptions, partitionKey);
+        }
+
+        /// <inheritdoc />
+        public async virtual Task<string> CreateCombinedTextIndexAsync<TDocument, TKey>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbIndexHandler.CreateCombinedTextIndexAsync<TDocument, TKey>(fields, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Drops the index given a field name
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="indexName">The name of the index</param>
+        /// <param name="partitionKey">An optional partition key</param>
+        public async Task DropIndexAsync<TDocument>(string indexName, string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            await MongoDbIndexHandler.DropIndexAsync<TDocument, Guid>(partitionKey);
+        }
+
+        /// <inheritdoc />
+        public async virtual Task DropIndexAsync<TDocument, TKey>(string indexName, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            await MongoDbIndexHandler.DropIndexAsync<TDocument, TKey>(partitionKey);
+        }
+    }
+}
\ No newline at end of file
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Main.cs b/MongoDbGenericRepository/BaseMongoRepository.Main.cs
new file mode 100644
index 0000000..b7df9cc
--- /dev/null
+++ b/MongoDbGenericRepository/BaseMongoRepository.Main.cs
@@ -0,0 +1,211 @@
+using MongoDB.Driver;
+using MongoDbGenericRepository.Models;
+using MongoDbGenericRepository.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository
+{
+    /// <summary>
+    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
+    /// Its constructor must be given a connection string and a database name.
+    /// </summary>
+    public abstract partial class BaseMongoRepository : ReadOnlyMongoRepository, IBaseMongoRepository
+    {
+        /// <summary>
+        /// The constructor taking a connection string and a database name.
+        /// </summary>
+        /// <param name="connectionString">The connection string of the MongoDb server.</param>
+        /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
+        protected BaseMongoRepository(string connectionString, string databaseName = null) : base(connectionString, databaseName)
+        {
+        }
+
+        /// <summary>
+        /// The contructor taking a <see cref="IMongoDbContext"/>.
+        /// </summary>
+        /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
+        protected BaseMongoRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        {
+        }
+
+        /// <summary>
+        /// The contructor taking a <see cref="IMongoDatabase"/>.
+        /// </summary>
+        /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
+        protected BaseMongoRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
+        {
+        }
+
+
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="sortSelector">The property selector.</param>
+        /// <param name="ascending">Order of the sorting.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<List<TDocument>> GetSortedPaginatedAsync<TDocument>(
+            Expression<Func<TDocument, bool>> filter,
+            Expression<Func<TDocument, object>> sortSelector,
+            bool ascending = true,
+            int skipNumber = 0,
+            int takeNumber = 50,
+            string partitionKey = null)
+            where TDocument : IDocument
+        {
+            var sorting = ascending
+                ? Builders<TDocument>.Sort.Ascending(sortSelector)
+                : Builders<TDocument>.Sort.Descending(sortSelector);
+
+            return await HandlePartitioned<TDocument>(partitionKey)
+                    .Find(filter)
+                    .Sort(sorting)
+                    .Skip(skipNumber)
+                    .Limit(takeNumber)
+                    .ToListAsync();
+        }
+
+
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<List<TDocument>> GetPaginatedAsync<TDocument>(
+            Expression<Func<TDocument, bool>> filter,
+            int skipNumber = 0,
+            int takeNumber = 50,
+            string partitionKey = null)
+            where TDocument : IDocument
+        {
+            return await HandlePartitioned<TDocument>(partitionKey).Find(filter).Skip(skipNumber).Limit(takeNumber).ToListAsync();
+        }
+
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<List<TDocument>> GetPaginatedAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, int skipNumber = 0, int takeNumber = 50, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).Skip(skipNumber).Limit(takeNumber).ToListAsync();
+        }
+
+        #region Find And Update
+
+        /// <summary>
+        /// GetAndUpdateOne with filter
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="update"></param>
+        /// <param name="options"></param>
+        /// <returns></returns>
+        public virtual async Task<TDocument> GetAndUpdateOne<TDocument>(FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TDocument> options) where TDocument : IDocument
+        {
+            return await GetCollection<TDocument>().FindOneAndUpdateAsync(filter, update, options);
+        }
+
+        /// <summary>
+        /// GetAndUpdateOne with filter
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="update"></param>
+        /// <param name="options"></param>
+        /// <returns></returns>
+        public virtual async Task<TDocument> GetAndUpdateOne<TDocument, TKey>(FilterDefinition<TDocument> filter, UpdateDefinition<TDocument> update, FindOneAndUpdateOptions<TDocument, TDocument> options)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetCollection<TDocument, TKey>().FindOneAndUpdateAsync(filter, update, options);
+        }
+
+        #endregion Find And Update
+
+        /// <summary>
+        /// Sets the value of the document Id if it is not set already.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="document">The document.</param>
+        protected void FormatDocument<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (document == null)
+            {
+                throw new ArgumentNullException(nameof(document));
+            }
+            var defaultTKey = default(TKey);
+            if (document.Id == null
+                || (defaultTKey != null
+                    && defaultTKey.Equals(document.Id)))
+            {
+                document.Id = IdGenerator.GetId<TKey>();
+            }
+        }
+
+        /// <summary>
+        /// Sets the value of the document Id if it is not set already.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="document">The document.</param>
+        protected void FormatDocument<TDocument>(TDocument document) where TDocument : IDocument
+        {
+            if (document == null)
+            {
+                throw new ArgumentNullException(nameof(document));
+            }
+            if (document.Id == default(Guid))
+            {
+                document.Id = Guid.NewGuid();
+            }
+        }
+
+        /// <summary>
+        /// Gets a collections for a potentially partitioned document type.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="partitionKey">The collection partition key.</param>
+        /// <returns></returns>
+        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument>(string partitionKey)
+            where TDocument : IDocument<Guid>
+        {
+            if (!string.IsNullOrEmpty(partitionKey))
+            {
+                return GetCollection<TDocument>(partitionKey);
+            }
+            return GetCollection<TDocument>();
+        }
+
+        /// <summary>
+        /// Gets a collections for the type TDocument with a partition key.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="partitionKey">The collection partition key.</param>
+        /// <returns></returns>
+        protected virtual IMongoCollection<TDocument> GetCollection<TDocument>(string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            return MongoDbContext.GetCollection<TDocument>(partitionKey);
+        }
+    }
+}
\ No newline at end of file
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Update.cs b/MongoDbGenericRepository/BaseMongoRepository.Update.cs
new file mode 100644
index 0000000..beea2e1
--- /dev/null
+++ b/MongoDbGenericRepository/BaseMongoRepository.Update.cs
@@ -0,0 +1,457 @@
+using MongoDB.Driver;
+using MongoDbGenericRepository.DataAccess.Update;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository
+{
+    public interface IBaseMongoRepository_Update : IKeyTypedBaseMongoDbRepository_Update<Guid>
+    {
+        /// <summary>
+        /// Asynchronously Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument modifiedDocument)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        bool UpdateOne<TDocument, TKey>(TDocument modifiedDocument)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        bool UpdateOne<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value..
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        bool UpdateOne<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        Task<bool> UpdateOneAsync<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        Task<bool> UpdateOneAsync<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        bool UpdateOne<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        Task<bool> UpdateOneAsync<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        bool UpdateOne<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+    }
+    /// <summary>
+    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
+    /// Its constructor must be given a connection string and a database name.
+    /// </summary>
+    public abstract partial class BaseMongoRepository : IBaseMongoRepository_Update
+    {
+        private MongoDbUpdater _mongoDbUpdater;
+        protected MongoDbUpdater MongoDbUpdater
+        {
+            get
+            {
+                if (_mongoDbUpdater != null) { return _mongoDbUpdater; }
+
+                lock (_initLock)
+                {
+                    if (_mongoDbUpdater == null)
+                    {
+                        _mongoDbUpdater = new MongoDbUpdater(MongoDbContext);
+                    }
+                }
+
+                return _mongoDbUpdater;
+            }
+        }
+
+        #region Update
+
+        /// <summary>
+        /// Asynchronously Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument>(TDocument modifiedDocument) where TDocument : IDocument<Guid>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid>(modifiedDocument);
+        }
+
+        /// <summary>
+        /// Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        public virtual bool UpdateOne<TDocument>(TDocument modifiedDocument) where TDocument : IDocument<Guid>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, Guid>(modifiedDocument);
+        }
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid>(documentToModify, update);
+
+        }
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        public virtual bool UpdateOne<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<Guid>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, Guid>(documentToModify, update);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        public virtual bool UpdateOne<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<Guid>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, Guid, TField>(documentToModify, field, value);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid, TField>(documentToModify, field, value);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        public virtual bool UpdateOne<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, Guid, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        public virtual bool UpdateOne<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, Guid, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<Guid>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, Guid, TField>(filter, field, value, partitionKey);
+        }
+
+        #endregion Update
+
+        #region Update TKey
+
+        /// <summary>
+        /// Asynchronously Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument modifiedDocument)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey>(modifiedDocument);
+        }
+
+        /// <summary>
+        /// Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        public virtual bool UpdateOne<TDocument, TKey>(TDocument modifiedDocument)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey>(modifiedDocument);
+        }
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey>(documentToModify, update);
+        }
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        public virtual bool UpdateOne<TDocument, TKey>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey>(documentToModify, update);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        public virtual bool UpdateOne<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(documentToModify, field, value);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(documentToModify, field, value);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        public virtual bool UpdateOne<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        public virtual bool UpdateOne<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbUpdater.UpdateOne<TDocument, TKey, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(filter, field, value, partitionKey);
+        }
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        public virtual async Task<bool> UpdateOneAsync<TDocument, TKey, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(Builders<TDocument>.Filter.Where(filter), field, value, partitionKey);
+        }
+
+        #endregion Update
+    }
+
+}
diff --git a/MongoDbGenericRepository/BaseReadOnlyRepository.cs b/MongoDbGenericRepository/BaseReadOnlyRepository.cs
deleted file mode 100644
index 57ac920..0000000
--- a/MongoDbGenericRepository/BaseReadOnlyRepository.cs
+++ /dev/null
@@ -1,861 +0,0 @@
-using MongoDB.Driver;
-using MongoDB.Driver.Linq;
-using MongoDbGenericRepository.DataAccess.Read;
-using MongoDbGenericRepository.Models;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading.Tasks;
-
-namespace MongoDbGenericRepository
-{
-    public interface IBaseReadOnlyRepository
-    {
-        /// <summary>
-        /// The connection string.
-        /// </summary>
-        string ConnectionString { get; }
-
-        /// <summary>
-        /// The database name.
-        /// </summary>
-        string DatabaseName { get; }
-
-        #region Read TKey
-
-        /// <summary>
-        /// Asynchronously returns one document given its id.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="id">The Id of the document you want to get.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<TDocument> GetByIdAsync<TDocument, TKey>(TKey id, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Returns one document given its id.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="id">The Id of the document you want to get.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        TDocument GetById<TDocument, TKey>(TKey id, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Asynchronously returns one document given an expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<TDocument> GetOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Returns one document given an expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Returns a collection cursor.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-
-        /// <summary>
-        /// Returns true if any of the document of the collection matches the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<bool> AnyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Returns true if any of the document of the collection matches the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        bool Any<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Asynchronously returns a list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<List<TDocument>> GetAllAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Returns a list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        List<TDocument> GetAll<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Asynchronously counts how many documents match the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partitionKey</param>
-        Task<long> CountAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Counts how many documents match the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partitionKey</param>
-        long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        #endregion
-
-        #region Min / Max
-
-        /// <summary>
-        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="orderByAscending">A property selector to order by descending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="orderByAscending">A property selector to order by descending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="orderByAscending">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="orderByAscending">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="orderByAscending">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="orderByAscending">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> orderByDescending, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="minValueSelector">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="minValueSelector">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        TValue GetMinValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        #endregion
-
-        #region Sum
-
-        /// <summary>
-        /// Sums the values of a selected field for a given filtered collection of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="selector">The field you want to sum.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        Task<int> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, int>> selector,
-                                                       string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Sums the values of a selected field for a given filtered collection of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="selector">The field you want to sum.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        int SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, int>> selector,
-                                                       string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Sums the values of a selected field for a given filtered collection of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="selector">The field you want to sum.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        Task<decimal> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, decimal>> selector,
-                                                       string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Sums the values of a selected field for a given filtered collection of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="selector">The field you want to sum.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        decimal SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, decimal>> selector,
-                                                       string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        #endregion Sum
-    }
-
-    public class BaseReadOnlyRepository : IBaseReadOnlyRepository
-    {
-        /// <summary>
-        /// The connection string.
-        /// </summary>
-        public string ConnectionString { get; }
-
-        /// <summary>
-        /// The database name.
-        /// </summary>
-        public string DatabaseName { get; }
-
-        /// <summary>
-        /// The MongoDbContext
-        /// </summary>
-        protected IMongoDbContext MongoDbContext = null;
-
-        /// <summary>
-        /// A MongoDb Reader for read operations
-        /// </summary>
-        protected MongoDbReader MongoDbReader = null;
-
-        /// <summary>
-        /// The constructor taking a connection string and a database name.
-        /// </summary>
-        /// <param name="connectionString">The connection string of the MongoDb server.</param>
-        /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
-        protected BaseReadOnlyRepository(string connectionString, string databaseName = null)
-        {
-            if (databaseName == null)
-            {
-                var mongoUrl = new MongoUrl(connectionString);
-                databaseName = databaseName ?? mongoUrl.DatabaseName;
-            }
-            ConnectionString = connectionString;
-            DatabaseName = databaseName;
-            SetupMongoDbContext(new MongoDbContext(connectionString, databaseName));
-        }
-
-        /// <summary>
-        /// The contructor taking a <see cref="IMongoDbContext"/>.
-        /// </summary>
-        /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
-        protected BaseReadOnlyRepository(IMongoDbContext mongoDbContext)
-        {
-            SetupMongoDbContext(mongoDbContext);
-        }
-
-        /// <summary>
-        /// The contructor taking a <see cref="IMongoDatabase"/>.
-        /// </summary>
-        /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
-        protected BaseReadOnlyRepository(IMongoDatabase mongoDatabase)
-        {
-            SetupMongoDbContext(new MongoDbContext(mongoDatabase));
-        }
-
-        protected void SetupMongoDbContext(IMongoDbContext mongoDbContext)
-        {
-            MongoDbContext = mongoDbContext;
-            MongoDbReader = new MongoDbReader(MongoDbContext);
-        }
-
-        #region Read TKey
-
-        /// <summary>
-        /// Asynchronously returns one document given its id.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="id">The Id of the document you want to get.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public async virtual Task<TDocument> GetByIdAsync<TDocument, TKey>(TKey id, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.GetByIdAsync<TDocument, TKey>(id, partitionKey);
-        }
-
-        /// <summary>
-        /// Returns one document given its id.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="id">The Id of the document you want to get.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual TDocument GetById<TDocument, TKey>(TKey id, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.GetById<TDocument, TKey>(id, partitionKey);
-        }
-
-        /// <summary>
-        /// Asynchronously returns one document given an expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public async virtual Task<TDocument> GetOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.GetOneAsync<TDocument, TKey>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Returns one document given an expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.GetOne<TDocument, TKey>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Returns a collection cursor.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.GetCursor<TDocument, TKey>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Returns true if any of the document of the collection matches the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public async virtual Task<bool> AnyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.AnyAsync<TDocument, TKey>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Returns true if any of the document of the collection matches the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual bool Any<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.Any<TDocument, TKey>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Asynchronously returns a list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public async virtual Task<List<TDocument>> GetAllAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.GetAllAsync<TDocument, TKey>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Returns a list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual List<TDocument> GetAll<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.GetAll<TDocument, TKey>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Asynchronously counts how many documents match the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partitionKey</param>
-        public async virtual Task<long> CountAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.CountAsync<TDocument, TKey>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Counts how many documents match the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partitionKey</param>
-        public virtual long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.Count<TDocument, TKey>(filter, partitionKey);
-        }
-
-        /// <summary>
-        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="maxValueSelector">A property selector to order by descending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        public async virtual Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.GetByMaxAsync<TDocument, TKey>(filter, maxValueSelector, partitionKey);
-        }
-
-        /// <summary>
-        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="maxValueSelector">A property selector to order by descending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        public virtual TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> maxValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.GetByMax<TDocument, TKey>(filter, maxValueSelector, partitionKey);
-        }
-
-        /// <summary>
-        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="minValueSelector">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        public async virtual Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.GetByMinAsync<TDocument, TKey>(filter, minValueSelector, partitionKey);
-        }
-
-        /// <summary>
-        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="minValueSelector">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        public virtual TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> minValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.GetByMin<TDocument, TKey>(filter, minValueSelector, partitionKey);
-        }
-
-        /// <summary>
-        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="orderByAscending">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        public async virtual Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.GetMaxValueAsync<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
-        }
-
-        /// <summary>
-        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partitionKey.</param>
-        public virtual TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.GetMaxValue<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
-        }
-
-        /// <summary>
-        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="minValueSelector">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual async Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.GetMinValueAsync<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
-        }
-
-        /// <summary>
-        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="minValueSelector">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public virtual TValue GetMinValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.GetMinValue<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
-        }
-
-        #endregion
-
-        #region Sum TKey
-
-        /// <summary>
-        /// Sums the values of a selected field for a given filtered collection of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="selector">The field you want to sum.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        public virtual async Task<int> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, int>> selector,
-                                                       string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
-        }
-
-        /// <summary>
-        /// Sums the values of a selected field for a given filtered collection of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="selector">The field you want to sum.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        public virtual int SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, int>> selector,
-                                                       string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.SumBy<TDocument, TKey>(filter, selector, partitionKey);
-        }
-
-        /// <summary>
-        /// Sums the values of a selected field for a given filtered collection of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="selector">The field you want to sum.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        public virtual async Task<decimal> SumByAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, decimal>> selector,
-                                                       string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return await MongoDbReader.SumByAsync<TDocument, TKey>(filter, selector, partitionKey);
-        }
-
-        /// <summary>
-        /// Sums the values of a selected field for a given filtered collection of documents.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="selector">The field you want to sum.</param>
-        /// <param name="partitionKey">The partition key of your document, if any.</param>
-        public virtual decimal SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
-                                                       Expression<Func<TDocument, decimal>> selector,
-                                                       string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbReader.SumBy<TDocument, TKey>(filter, selector, partitionKey);
-        }
-
-        #endregion Sum TKey
-
-        #region Utility Methods
-
-        protected virtual IMongoQueryable<TDocument> GetQuery<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return GetCollection<TDocument, TKey>(partitionKey).AsQueryable().Where(filter);
-        }
-
-        /// <summary>
-        /// Gets a collections for a potentially partitioned document type.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="document">The document.</param>
-        /// <returns></returns>
-        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            if (document is IPartitionedDocument)
-            {
-                return GetCollection<TDocument, TKey>(((IPartitionedDocument)document).PartitionKey);
-            }
-            return GetCollection<TDocument, TKey>();
-        }
-
-        /// <summary>
-        /// Gets a collections for the type TDocument with a partition key.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="partitionKey">The collection partition key.</param>
-        /// <returns></returns>
-        protected virtual IMongoCollection<TDocument> GetCollection<TDocument, TKey>(string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            return MongoDbContext.GetCollection<TDocument>(partitionKey);
-        }
-
-        /// <summary>
-        /// Gets a collections for a potentially partitioned document type.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <param name="partitionKey">The collection partition key.</param>
-        /// <returns></returns>
-        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(string partitionKey)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            if (!string.IsNullOrEmpty(partitionKey))
-            {
-                return GetCollection<TDocument, TKey>(partitionKey);
-            }
-            return GetCollection<TDocument, TKey>();
-        }
-
-        /// <summary>
-        /// Converts a LINQ expression of TDocument, TValue to a LINQ expression of TDocument, object
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TValue">The type of the value.</typeparam>
-        /// <param name="expression">The expression to convert</param>
-        protected virtual Expression<Func<TDocument, object>> ConvertExpression<TDocument, TValue>(Expression<Func<TDocument, TValue>> expression)
-        {
-            var param = expression.Parameters[0];
-            Expression body = expression.Body;
-            var convert = Expression.Convert(body, typeof(object));
-            return Expression.Lambda<Func<TDocument, object>>(convert, param);
-        }
-
-        /// <summary>
-        /// Maps a IndexCreationOptions object to a MongoDB.Driver.CreateIndexOptions object
-        /// </summary>
-        /// <param name="indexCreationOptions">The options for creating an index.</param>
-        /// <returns></returns>
-        protected virtual CreateIndexOptions MapIndexOptions(IndexCreationOptions indexCreationOptions)
-        {
-            return new CreateIndexOptions
-            {
-                Unique = indexCreationOptions.Unique,
-                TextIndexVersion = indexCreationOptions.TextIndexVersion,
-                SphereIndexVersion = indexCreationOptions.SphereIndexVersion,
-                Sparse = indexCreationOptions.Sparse,
-                Name = indexCreationOptions.Name,
-                Min = indexCreationOptions.Min,
-                Max = indexCreationOptions.Max,
-                LanguageOverride = indexCreationOptions.LanguageOverride,
-                ExpireAfter = indexCreationOptions.ExpireAfter,
-                DefaultLanguage = indexCreationOptions.DefaultLanguage,
-                BucketSize = indexCreationOptions.BucketSize,
-                Bits = indexCreationOptions.Bits,
-                Background = indexCreationOptions.Background,
-                Version = indexCreationOptions.Version
-            };
-        }
-
-
-        /// <summary>
-        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="minValueSelector">A property selector to order by ascending.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        protected virtual IFindFluent<TDocument, TDocument> GetMinMongoQuery<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
-                    where TDocument : IDocument<TKey>
-                    where TKey : IEquatable<TKey>
-        {
-            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
-                                                               .SortBy(ConvertExpression(minValueSelector))
-                                                               .Limit(1);
-        }
-
-        /// <summary>
-        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
-        /// </summary>
-        /// <typeparam name="TDocument">The document type.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key.</typeparam>
-        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="maxValueSelector">A property selector to order by descending.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        protected virtual IFindFluent<TDocument, TDocument> GetMaxMongoQuery<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
-                    where TDocument : IDocument<TKey>
-                    where TKey : IEquatable<TKey>
-        {
-            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
-                                                               .SortByDescending(ConvertExpression(maxValueSelector))
-                                                               .Limit(1);
-        }
-
-
-        #endregion
-    }
-}
diff --git a/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs b/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs
index d6de4c6..f7a4949 100644
--- a/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs
+++ b/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs
@@ -18,7 +18,7 @@ namespace MongoDbGenericRepository.DataAccess.Base
 
         #region Utility Methods
 
-        protected virtual IMongoQueryable<TDocument> GetQuery<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+        public virtual IMongoQueryable<TDocument> GetQuery<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
@@ -32,7 +32,7 @@ namespace MongoDbGenericRepository.DataAccess.Base
         /// <typeparam name="TKey">The type of the primary key.</typeparam>
         /// <param name="document">The document.</param>
         /// <returns></returns>
-        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(TDocument document)
+        public virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(TDocument document)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
@@ -50,7 +50,7 @@ namespace MongoDbGenericRepository.DataAccess.Base
         /// <typeparam name="TKey">The type of the primary key.</typeparam>
         /// <param name="partitionKey">The collection partition key.</param>
         /// <returns></returns>
-        protected virtual IMongoCollection<TDocument> GetCollection<TDocument, TKey>(string partitionKey = null)
+        public virtual IMongoCollection<TDocument> GetCollection<TDocument, TKey>(string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
@@ -64,7 +64,7 @@ namespace MongoDbGenericRepository.DataAccess.Base
         /// <typeparam name="TKey">The type of the primary key.</typeparam>
         /// <param name="partitionKey">The collection partition key.</param>
         /// <returns></returns>
-        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(string partitionKey)
+        public virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(string partitionKey)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
diff --git a/MongoDbGenericRepository/BaseMongoDbIndexRepository.cs b/MongoDbGenericRepository/DataAccess/Index/MongoDbIndexHandler.cs
similarity index 73%
rename from MongoDbGenericRepository/BaseMongoDbIndexRepository.cs
rename to MongoDbGenericRepository/DataAccess/Index/MongoDbIndexHandler.cs
index 8edd0a7..6662670 100644
--- a/MongoDbGenericRepository/BaseMongoDbIndexRepository.cs
+++ b/MongoDbGenericRepository/DataAccess/Index/MongoDbIndexHandler.cs
@@ -1,4 +1,6 @@
 using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using MongoDbGenericRepository.DataAccess.Base;
 using MongoDbGenericRepository.Models;
 using System;
 using System.Collections.Generic;
@@ -6,10 +8,30 @@ using System.Linq;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 
-namespace MongoDbGenericRepository
+namespace MongoDbGenericRepository.DataAccess.Index
 {
-    public interface IBaseMongoDbIndexRepository
+    public class MongoDbIndexHandler : DataAccessBase
     {
+        public MongoDbIndexHandler(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        {
+        }
+
+        /// <summary>
+        /// Returns the names of the indexes present on a collection.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="partitionKey">An optional partition key</param>
+        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
+        public async virtual Task<List<string>> GetIndexesNamesAsync<TDocument, TKey>(string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var indexCursor = await HandlePartitioned<TDocument, TKey>(partitionKey).Indexes.ListAsync();
+            var indexes = await indexCursor.ToListAsync();
+            return indexes.Select(e => e["name"].ToString()).ToList();
+        }
+
         /// <summary>
         /// Create a text index on the given field.
         /// IndexCreationOptions can be supplied to further specify 
@@ -21,133 +43,6 @@ namespace MongoDbGenericRepository
         /// <param name="indexCreationOptions">Options for creating an index.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateTextIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Creates an index on the given field in ascending order.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateAscendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Creates an index on the given field in descending order.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateDescendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Creates a hashed index on the given field.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="field">The field we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateHashedIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Creates a combined text index.
-        /// IndexCreationOptions can be supplied to further specify 
-        /// how the creation should be done.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="fields">The fields we want to index.</param>
-        /// <param name="indexCreationOptions">Options for creating an index.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        /// <returns>The result of the create index operation.</returns>
-        Task<string> CreateCombinedTextIndexAsync<TDocument, TKey>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Drops the index given a field name
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="indexName">The name of the index</param>
-        /// <param name="partitionKey">An optional partition key</param>
-        Task DropIndexAsync<TDocument, TKey>(string indexName, string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-
-        /// <summary>
-        /// Returns the names of the indexes present on a collection.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="partitionKey">An optional partition key</param>
-        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
-        Task<List<string>> GetIndexesNamesAsync<TDocument, TKey>(string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>;
-    }
-
-    public class BaseMongoDbIndexRepository : BaseReadOnlyRepository, IBaseMongoDbIndexRepository
-    {
-        /// <summary>
-        /// The constructor taking a connection string and a database name.
-        /// </summary>
-        /// <param name="connectionString">The connection string of the MongoDb server.</param>
-        /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
-        protected BaseMongoDbIndexRepository(string connectionString, string databaseName = null) : base(connectionString, databaseName)
-        {
-        }
-
-        /// <summary>
-        /// The contructor taking a <see cref="IMongoDbContext"/>.
-        /// </summary>
-        /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
-        protected BaseMongoDbIndexRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
-        {
-        }
-
-        /// <summary>
-        /// The contructor taking a <see cref="IMongoDatabase"/>.
-        /// </summary>
-        /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
-        protected BaseMongoDbIndexRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
-        {
-        }
-
-        #region Index Management TKey
-
-        /// <inheritdoc />
-        public async virtual Task<List<string>> GetIndexesNamesAsync<TDocument, TKey>(string partitionKey = null)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            var indexCursor = await HandlePartitioned<TDocument, TKey>(partitionKey).Indexes.ListAsync();
-            var indexes = await indexCursor.ToListAsync();
-            return indexes.Select(e => e["name"].ToString()).ToList();
-        }
-
-        /// <inheritdoc />
         public async virtual Task<string> CreateTextIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
@@ -160,7 +55,17 @@ namespace MongoDbGenericRepository
                                                                    ));
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// Creates an index on the given field in ascending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
         public async virtual Task<string> CreateAscendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
@@ -173,7 +78,17 @@ namespace MongoDbGenericRepository
                 new CreateIndexModel<TDocument>(indexKey.Ascending(field), createOptions));
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// Creates an index on the given field in descending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
         public async virtual Task<string> CreateDescendingIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
@@ -186,8 +101,17 @@ namespace MongoDbGenericRepository
                 new CreateIndexModel<TDocument>(indexKey.Descending(field), createOptions));
         }
 
-
-        /// <inheritdoc />
+        /// <summary>
+        /// Creates a hashed index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
         public async virtual Task<string> CreateHashedIndexAsync<TDocument, TKey>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
@@ -200,7 +124,17 @@ namespace MongoDbGenericRepository
                 new CreateIndexModel<TDocument>(indexKey.Hashed(field), createOptions));
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// Creates a combined text index.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="fields">The fields we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
         public async virtual Task<string> CreateCombinedTextIndexAsync<TDocument, TKey>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
@@ -216,15 +150,18 @@ namespace MongoDbGenericRepository
                                    .CreateOneAsync(new CreateIndexModel<TDocument>(Builders<TDocument>.IndexKeys.Combine(listOfDefs), createOptions));
         }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// Drops the index given a field name
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="indexName">The name of the index</param>
+        /// <param name="partitionKey">An optional partition key</param>
         public async virtual Task DropIndexAsync<TDocument, TKey>(string indexName, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
             await HandlePartitioned<TDocument, TKey>(partitionKey).Indexes.DropOneAsync(indexName);
         }
-
-        #endregion Index Management TKey
-
     }
 }
diff --git a/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.cs b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Main.cs
similarity index 87%
rename from MongoDbGenericRepository/DataAccess/Read/MongoDbReader.cs
rename to MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Main.cs
index a23340a..1282efd 100644
--- a/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.cs
+++ b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Main.cs
@@ -10,7 +10,7 @@ using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository.DataAccess.Read
 {
-    public class MongoDbReader : DataAccessBase
+    public partial class MongoDbReader : DataAccessBase
     {
         public MongoDbReader(IMongoDbContext mongoDbContext) : base(mongoDbContext)
         {
@@ -390,4 +390,59 @@ namespace MongoDbGenericRepository.DataAccess.Read
 
         #endregion Sum TKey
     }
+
+    public partial class MongoDbReader
+    {
+        /// <summary>
+        /// Groups a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="groupingCriteria">The grouping criteria.</param>
+        /// <param name="groupProjection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual List<TProjection> GroupBy<TDocument, TGroupKey, TProjection, TKey>(
+            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class, new()
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey)
+                             .Aggregate()
+                             .Group(groupingCriteria, groupProjection)
+                             .ToList();
+
+        }
+
+        /// <summary>
+        /// Groups filtered a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The grouping criteria.</param>
+        /// <param name="projection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual List<TProjection> GroupBy<TDocument, TGroupKey, TProjection, TKey>(
+            Expression<Func<TDocument, bool>> filter,
+            Expression<Func<TDocument, TGroupKey>> selector,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> projection,
+            string partitionKey = null)
+                where TDocument : IDocument<TKey>
+                where TKey : IEquatable<TKey>
+                where TProjection : class, new()
+        {
+            var collection = HandlePartitioned<TDocument, TKey>(partitionKey);
+            return collection.Aggregate()
+                             .Match(Builders<TDocument>.Filter.Where(filter))
+                             .Group(selector, projection)
+                             .ToList();
+        }
+    }
 }
diff --git a/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Project.cs b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Project.cs
new file mode 100644
index 0000000..3499a66
--- /dev/null
+++ b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Project.cs
@@ -0,0 +1,90 @@
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository.DataAccess.Read
+{
+    public partial class MongoDbReader
+    {
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter)
+                                                                         .Project(projection)
+                                                                         .FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TProjection ProjectOne<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter)
+                                                                   .Project(projection)
+                                                                   .FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter)
+                                                                   .Project(projection)
+                                                                   .ToListAsync();
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual List<TProjection> ProjectMany<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter)
+                                                                   .Project(projection)
+                                                                   .ToList();
+        }
+    }
+}
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Create.cs b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Create.cs
new file mode 100644
index 0000000..7d3271b
--- /dev/null
+++ b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Create.cs
@@ -0,0 +1,114 @@
+using MongoDbGenericRepository.DataAccess.Create;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository
+{
+    public interface IKeyTypedBaseMongoDbRepository_Create<TKey> where TKey : IEquatable<TKey>
+    {
+        /// <summary>
+        /// Asynchronously adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        Task AddOneAsync<TDocument>(TDocument document) where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        void AddOne<TDocument>(TDocument document) where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Asynchronously adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<TKey>;
+    }
+
+    /// <summary>
+    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
+    /// Its constructor must be given a connection string and a database name.
+    /// </summary>
+    /// <typeparam name="TKey"></typeparam>
+    public abstract partial class KeyTypedBaseMongoDbRepository<TKey> : IKeyTypedBaseMongoDbRepository_Create<TKey> where TKey : IEquatable<TKey>
+    {
+        protected MongoDbCreator _mongoDbCreator;
+        protected MongoDbCreator MongoDbCreator
+        {
+            get
+            {
+                if(_mongoDbCreator == null)
+                {
+                    lock (_initLock)
+                    {
+                        if(_mongoDbCreator == null)
+                        {
+                            _mongoDbCreator = new MongoDbCreator(MongoDbContext);
+                        }
+                    }
+                }
+                return _mongoDbCreator;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public virtual async Task AddOneAsync<TDocument>(TDocument document) where TDocument : IDocument<TKey>
+        {
+            await MongoDbCreator.AddOneAsync<TDocument, TKey>(document);
+        }
+
+        /// <summary>
+        /// Adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public virtual void AddOne<TDocument>(TDocument document) where TDocument : IDocument<TKey>
+        {
+            MongoDbCreator.AddOne<TDocument, TKey>(document);
+        }
+
+        /// <summary>
+        /// Asynchronously adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        public virtual async Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<TKey>
+        {
+            await MongoDbCreator.AddManyAsync<TDocument, TKey>(documents);
+        }
+
+        /// <summary>
+        /// Adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        public virtual void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<TKey>
+        {
+            MongoDbCreator.AddMany<TDocument, TKey>(documents);
+        }
+    }
+}
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Delete.cs b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Delete.cs
new file mode 100644
index 0000000..c1d4d43
--- /dev/null
+++ b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Delete.cs
@@ -0,0 +1,226 @@
+using MongoDbGenericRepository.DataAccess.Delete;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository
+{
+    public interface IKeyTypedBaseMongoDbRepository_Delete<TKey> where TKey : IEquatable<TKey>
+    {
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument>(TDocument document)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteOneAsync<TDocument>(TDocument document)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteManyAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteManyAsync<TDocument>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteMany<TDocument>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteMany<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+    }
+
+    public abstract partial class KeyTypedBaseMongoDbRepository<TKey>: IKeyTypedBaseMongoDbRepository_Delete<TKey> 
+        where TKey : IEquatable<TKey>
+    {
+        private MongoDbEraser _mongoDbEraser;
+        protected MongoDbEraser MongoDbEraser
+        {
+            get
+            {
+                if (_mongoDbEraser != null) { return _mongoDbEraser; }
+
+                lock (_initLock)
+                {
+                    if (_mongoDbEraser == null)
+                    {
+                        _mongoDbEraser = new MongoDbEraser(MongoDbContext);
+                    }
+                }
+                return _mongoDbEraser;
+            }
+        }
+
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument>(TDocument document)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(document);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument>(TDocument document)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(document);
+        }
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbEraser.DeleteManyAsync<TDocument, TKey>(filter, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbEraser.DeleteManyAsync<TDocument, TKey>(documents);
+        }
+
+        /// <summary>
+        /// Deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteMany<TDocument>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbEraser.DeleteMany<TDocument, TKey>(documents);
+        }
+
+        /// <summary>
+        /// Deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteMany<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbEraser.DeleteMany<TDocument, TKey>(filter, partitionKey);
+        }
+    }
+}
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Index.cs b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Index.cs
new file mode 100644
index 0000000..8dc9850
--- /dev/null
+++ b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Index.cs
@@ -0,0 +1,226 @@
+using MongoDbGenericRepository.DataAccess.Index;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MongoDbGenericRepository
+{
+    public interface IKeyTypedBaseMongoDbRepository_Index<TKey> where TKey : IEquatable<TKey>
+    {
+        /// <summary>
+        /// Returns the names of the indexes present on a collection.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="partitionKey">An optional partition key</param>
+        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
+        Task<List<string>> GetIndexesNamesAsync<TDocument>(string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Create a text index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateTextIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Creates an index on the given field in ascending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateAscendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Creates an index on the given field in descending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateDescendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Creates a hashed index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateHashedIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Creates a combined text index.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="fields">The fields we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        Task<string> CreateCombinedTextIndexAsync<TDocument>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Drops the index given a field name
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="indexName">The name of the index</param>
+        /// <param name="partitionKey">An optional partition key</param>
+        Task DropIndexAsync<TDocument>(string indexName, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+    }
+
+    /// <summary>
+    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
+    /// Its constructor must be given a connection string and a database name.
+    /// </summary>
+    /// <typeparam name="TKey"></typeparam>
+    public abstract partial class KeyTypedBaseMongoDbRepository<TKey> : IKeyTypedBaseMongoDbRepository_Index<TKey>
+        where TKey : IEquatable<TKey>
+    {
+        private MongoDbIndexHandler _mongoDbIndexHandler;
+        protected MongoDbIndexHandler MongoDbIndexHandler
+        {
+            get
+            {
+                if (_mongoDbIndexHandler != null) { return _mongoDbIndexHandler; }
+
+                lock (_initLock)
+                {
+                    if (_mongoDbIndexHandler == null)
+                    {
+                        _mongoDbIndexHandler = new MongoDbIndexHandler(MongoDbContext);
+                    }
+                }
+                return _mongoDbIndexHandler;
+            }
+        }
+
+        /// <summary>
+        /// Returns the names of the indexes present on a collection.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="partitionKey">An optional partition key</param>
+        /// <returns>A list containing the names of the indexes on on the concerned collection.</returns>
+        public async virtual Task<List<string>> GetIndexesNamesAsync<TDocument>(string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbIndexHandler.GetIndexesNamesAsync<TDocument, TKey>(partitionKey);
+        }
+
+        /// <summary>
+        /// Create a text index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async virtual Task<string> CreateTextIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbIndexHandler.CreateTextIndexAsync<TDocument, TKey>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Creates an index on the given field in ascending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async virtual Task<string> CreateAscendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbIndexHandler.CreateAscendingIndexAsync<TDocument, TKey>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Creates an index on the given field in descending order.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async virtual Task<string> CreateDescendingIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbIndexHandler.CreateDescendingIndexAsync<TDocument, TKey>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Creates a hashed index on the given field.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="field">The field we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async virtual Task<string> CreateHashedIndexAsync<TDocument>(Expression<Func<TDocument, object>> field, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbIndexHandler.CreateHashedIndexAsync<TDocument, TKey>(field, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Creates a combined text index.
+        /// IndexCreationOptions can be supplied to further specify 
+        /// how the creation should be done.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="fields">The fields we want to index.</param>
+        /// <param name="indexCreationOptions">Options for creating an index.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The result of the create index operation.</returns>
+        public async virtual Task<string> CreateCombinedTextIndexAsync<TDocument>(IEnumerable<Expression<Func<TDocument, object>>> fields, IndexCreationOptions indexCreationOptions = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return await MongoDbIndexHandler.CreateCombinedTextIndexAsync<TDocument, TKey>(fields, indexCreationOptions, partitionKey);
+        }
+
+        /// <summary>
+        /// Drops the index given a field name
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="indexName">The name of the index</param>
+        /// <param name="partitionKey">An optional partition key</param>
+        public async virtual Task DropIndexAsync<TDocument>(string indexName, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            await MongoDbIndexHandler.DropIndexAsync<TDocument, TKey>(indexName, partitionKey);
+        }
+    }
+}
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Main.cs b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Main.cs
new file mode 100644
index 0000000..265b7c7
--- /dev/null
+++ b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Main.cs
@@ -0,0 +1,82 @@
+using MongoDB.Driver;
+using MongoDbGenericRepository.Models;
+using System;
+
+namespace MongoDbGenericRepository
+{
+    public interface IKeyTypedBaseMongoDbRepository<TKey> :
+        IKeyTypedReadOnlyMongoRepository<TKey>,
+        IKeyTypedBaseMongoDbRepository_Create<TKey>,
+        IKeyTypedBaseMongoDbRepository_Delete<TKey>,
+        IKeyTypedBaseMongoDbRepository_Index<TKey>,
+        IKeyTypedBaseMongoDbRepository_Update<TKey>
+        where TKey : IEquatable<TKey>
+    {
+    }
+
+    /// <summary>
+    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
+    /// Its constructor must be given a connection string and a database name.
+    /// </summary>
+    /// <typeparam name="TKey"></typeparam>
+    public abstract partial class KeyTypedBaseMongoDbRepository<TKey> : 
+        KeyTypedReadOnlyMongoRepository<TKey>, 
+        IKeyTypedBaseMongoDbRepository<TKey>
+        where TKey : IEquatable<TKey>
+    {
+        protected readonly object _initLock = new object();
+
+        /// <summary>
+        /// The constructor taking a connection string and a database name.
+        /// </summary>
+        /// <param name="connectionString">The connection string of the MongoDb server.</param>
+        /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
+        protected KeyTypedBaseMongoDbRepository(string connectionString, string databaseName = null) : base(connectionString, databaseName)
+        {
+        }
+
+        /// <summary>
+        /// The contructor taking a <see cref="IMongoDbContext"/>.
+        /// </summary>
+        /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
+        protected KeyTypedBaseMongoDbRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        {
+        }
+
+        /// <summary>
+        /// The contructor taking a <see cref="IMongoDatabase"/>.
+        /// </summary>
+        /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
+        protected KeyTypedBaseMongoDbRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
+        {
+        }
+
+        /// <summary>
+        /// Gets a collections for a potentially partitioned document type.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="partitionKey">The collection partition key.</param>
+        /// <returns></returns>
+        protected virtual IMongoCollection<TDocument> HandlePartitioned<TDocument>(string partitionKey)
+            where TDocument : IDocument<TKey>
+        {
+            if (!string.IsNullOrEmpty(partitionKey))
+            {
+                return GetCollection<TDocument>(partitionKey);
+            }
+            return GetCollection<TDocument>();
+        }
+
+        /// <summary>
+        /// Gets a collections for the type TDocument with a partition key.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="partitionKey">The collection partition key.</param>
+        /// <returns></returns>
+        protected virtual IMongoCollection<TDocument> GetCollection<TDocument>(string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbContext.GetCollection<TDocument>(partitionKey);
+        }
+    }
+}
diff --git a/MongoDbGenericRepository/KeyTypedBaseMongoDbRepository.cs b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Update.cs
similarity index 60%
rename from MongoDbGenericRepository/KeyTypedBaseMongoDbRepository.cs
rename to MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Update.cs
index 89cf73d..1be2d34 100644
--- a/MongoDbGenericRepository/KeyTypedBaseMongoDbRepository.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Update.cs
@@ -1,41 +1,120 @@
 using MongoDB.Driver;
-using MongoDbGenericRepository.DataAccess.Create;
 using MongoDbGenericRepository.DataAccess.Update;
 using MongoDbGenericRepository.Models;
 using System;
-using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
-    /// <summary>
-    /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
-    /// Its constructor must be given a connection string and a database name.
-    /// </summary>
-    /// <typeparam name="TKey"></typeparam>
-    public abstract class KeyTypedBaseMongoDbRepository<TKey> : KeyTypedReadOnlyMongoRepository<TKey>, IKeyTypedReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
+    public interface IKeyTypedBaseMongoDbRepository_Update<TKey> where TKey : IEquatable<TKey>
     {
-        protected object _initLock;
-        protected MongoDbCreator _mongoDbCreator;
-        protected MongoDbCreator MongoDbCreator
-        {
-            get
-            {
-                if(_mongoDbCreator == null)
-                {
-                    lock (_initLock)
-                    {
-                        if(_mongoDbCreator == null)
-                        {
-                            _mongoDbCreator = new MongoDbCreator(MongoDbContext);
-                        }
-                    }
-                }
-                return _mongoDbCreator;
-            }
-        }
+        /// <summary>
+        /// Asynchronously Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        Task<bool> UpdateOneAsync<TDocument>(TDocument modifiedDocument) where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        bool UpdateOne<TDocument>(TDocument modifiedDocument) where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        Task<bool> UpdateOneAsync<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Takes a document you want to modify and applies the update you have defined in MongoDb.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="update">The update definition for the document.</param>
+        bool UpdateOne<TDocument>(TDocument documentToModify, UpdateDefinition<TDocument> update)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        bool UpdateOne<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="documentToModify">The document you want to modify.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        Task<bool> UpdateOneAsync<TDocument, TField>(TDocument documentToModify, Expression<Func<TDocument, TField>> field, TField value)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        bool UpdateOne<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        bool UpdateOne<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// Updates the property field with the given value update a property field in entities.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The value of the partition key.</param>
+        Task<bool> UpdateOneAsync<TDocument, TField>(FilterDefinition<TDocument> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
+        /// <summary>
+        /// For the entity selected by the filter, updates the property field with the given value.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="field">The field selector.</param>
+        /// <param name="value">The new value of the property field.</param>
+        /// <param name="partitionKey">The partition key for the document.</param>
+        Task<bool> UpdateOneAsync<TDocument, TField>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TField>> field, TField value, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+    }
+
+    public abstract partial class KeyTypedBaseMongoDbRepository<TKey> : IKeyTypedBaseMongoDbRepository_Update<TKey>
+        where TKey : IEquatable<TKey>
+    {
         private MongoDbUpdater _mongoDbUpdater;
         protected MongoDbUpdater MongoDbUpdater
         {
@@ -55,81 +134,6 @@ namespace MongoDbGenericRepository
             }
         }
 
-        /// <summary>
-        /// The constructor taking a connection string and a database name.
-        /// </summary>
-        /// <param name="connectionString">The connection string of the MongoDb server.</param>
-        /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
-        protected KeyTypedBaseMongoDbRepository(string connectionString, string databaseName = null) : base(connectionString, databaseName)
-        {
-        }
-
-        /// <summary>
-        /// The contructor taking a <see cref="IMongoDbContext"/>.
-        /// </summary>
-        /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
-        protected KeyTypedBaseMongoDbRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
-        {
-        }
-
-        /// <summary>
-        /// The contructor taking a <see cref="IMongoDatabase"/>.
-        /// </summary>
-        /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
-        protected KeyTypedBaseMongoDbRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
-        {
-        }
-
-        #region Create
-
-        /// <summary>
-        /// Asynchronously adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public virtual async Task AddOneAsync<TDocument>(TDocument document) where TDocument : IDocument<TKey>
-        {
-            await MongoDbCreator.AddOneAsync<TDocument, TKey>(document);
-        }
-
-        /// <summary>
-        /// Adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public virtual void AddOne<TDocument>(TDocument document) where TDocument : IDocument<TKey>
-        {
-            MongoDbCreator.AddOne<TDocument, TKey>(document);
-        }
-
-        /// <summary>
-        /// Asynchronously adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The documents you want to add.</param>
-        public virtual async Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<TKey>
-        {
-            await MongoDbCreator.AddManyAsync<TDocument, TKey>(documents);
-        }
-
-        /// <summary>
-        /// Adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The documents you want to add.</param>
-        public virtual void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument<TKey>
-        {
-            MongoDbCreator.AddMany<TDocument, TKey>(documents);
-        }
-
-        #endregion Create
-
-        #region Update
-
         /// <summary>
         /// Asynchronously Updates a document.
         /// </summary>
@@ -261,8 +265,5 @@ namespace MongoDbGenericRepository
         {
             return await MongoDbUpdater.UpdateOneAsync<TDocument, TKey, TField>(filter, field, value, partitionKey);
         }
-
-
-        #endregion Update
     }
 }
diff --git a/MongoDbGenericRepository/KeyTypedReadOnlyMongoRepository.cs b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedReadOnlyMongoRepository.cs
similarity index 74%
rename from MongoDbGenericRepository/KeyTypedReadOnlyMongoRepository.cs
rename to MongoDbGenericRepository/KeyTypedRepository/KeyTypedReadOnlyMongoRepository.cs
index 085c54a..44a1af4 100644
--- a/MongoDbGenericRepository/KeyTypedReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/KeyTypedReadOnlyMongoRepository.cs
@@ -3,6 +3,7 @@ using MongoDbGenericRepository.DataAccess.Read;
 using MongoDbGenericRepository.Models;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 
@@ -12,7 +13,7 @@ namespace MongoDbGenericRepository
     /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
     /// Its constructor must be given a connection string and a database name.
     /// </summary>
-    public abstract class KeyTypedReadOnlyMongoRepository<TKey> : IKeyTypedReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
+    public abstract partial class KeyTypedReadOnlyMongoRepository<TKey> : IKeyTypedReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// The connection string.
@@ -376,5 +377,113 @@ namespace MongoDbGenericRepository
         }
 
         #endregion Maths
+
+        #region Project
+
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<TProjection> ProjectOneAsync<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class
+        {
+            return await MongoDbReader.ProjectOneAsync<TDocument, TProjection, TKey>(filter, projection, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TProjection ProjectOne<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectOne<TDocument, TProjection, TKey>(filter, projection, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class
+        {
+            return await MongoDbReader.ProjectManyAsync<TDocument, TProjection, TKey>(filter, projection, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual List<TProjection> ProjectMany<TDocument, TProjection>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectMany<TDocument, TProjection, TKey>(filter, projection, partitionKey);
+        }
+
+
+        #endregion Project
+
+        /// <summary>
+        /// Groups a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="groupingCriteria">The grouping criteria.</param>
+        /// <param name="groupProjection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual List<TProjection> GroupBy<TDocument, TGroupKey, TProjection>(
+            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class, new()
+        {
+            return MongoDbReader.GroupBy<TDocument, TGroupKey, TProjection, TKey>(groupingCriteria, groupProjection, partitionKey);
+        }
+
+        /// <summary>
+        /// Groups filtered a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="groupingCriteria">The grouping criteria.</param>
+        /// <param name="groupProjection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual List<TProjection> GroupBy<TDocument, TGroupKey, TProjection>(
+            Expression<Func<TDocument, bool>> filter,
+            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
+            string partitionKey = null)
+                where TDocument : IDocument<TKey>
+                where TProjection : class, new()
+        {
+            return MongoDbReader.GroupBy<TDocument, TGroupKey, TProjection, TKey>(filter, groupingCriteria, groupProjection, partitionKey);
+        }
     }
 }
\ No newline at end of file
diff --git a/MongoDbGenericRepository/ReadOnlyMongoRepository.cs b/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
index 4dfaf7e..02484e2 100644
--- a/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
@@ -3,6 +3,7 @@ using MongoDbGenericRepository.DataAccess.Read;
 using MongoDbGenericRepository.Models;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 
@@ -39,7 +40,6 @@ namespace MongoDbGenericRepository
         {
         }
 
-
         #region Read TKey
 
         /// <summary>
@@ -389,5 +389,184 @@ namespace MongoDbGenericRepository
 
         #endregion Sum TKey
 
+        #region Project TKey
+
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return await MongoDbReader.ProjectOneAsync<TDocument, TProjection, TKey>(filter, projection, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TProjection ProjectOne<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectOne<TDocument, TProjection, TKey>(filter, projection, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual async Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return await MongoDbReader.ProjectManyAsync<TDocument, TProjection, TKey>(filter, projection, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="filter">The document filter.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual List<TProjection> ProjectMany<TDocument, TProjection, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TProjection>> projection, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectMany<TDocument, TProjection, TKey>(filter, projection, partitionKey);
+        }
+
+        #endregion Project TKey
+
+        #region Group By TKey
+
+        /// <summary>
+        /// Groups filtered a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="selector">The grouping criteria.</param>
+        /// <param name="projection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual List<TProjection> GroupBy<TDocument, TGroupKey, TProjection, TKey>(
+            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class, new()
+        {
+            return MongoDbReader.GroupBy<TDocument, TGroupKey, TProjection, TKey>(groupingCriteria, groupProjection, partitionKey);
+        }
+
+        /// <summary>
+        /// Groups filtered a collection of documents given a grouping criteria, 
+        /// and returns a dictionary of listed document groups with keys having the different values of the grouping criteria.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TGroupKey">The type of the grouping criteria.</typeparam>
+        /// <typeparam name="TProjection">The type of the projected group.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="groupingCriteria">The grouping criteria.</param>
+        /// <param name="groupProjection">The projected group result.</param>
+        /// <param name="partitionKey">The partition key of your document, if any.</param>
+        public virtual List<TProjection> GroupBy<TDocument, TGroupKey, TProjection, TKey>(
+            Expression<Func<TDocument, bool>> filter,
+            Expression<Func<TDocument, TGroupKey>> groupingCriteria,
+            Expression<Func<IGrouping<TGroupKey, TDocument>, TProjection>> groupProjection,
+            string partitionKey = null)
+                where TDocument : IDocument<TKey>
+                where TKey : IEquatable<TKey>
+                where TProjection : class, new()
+        {
+            return MongoDbReader.GroupBy<TDocument, TGroupKey, TProjection, TKey>(filter, groupingCriteria, groupProjection, partitionKey);
+        }
+
+        #endregion Group By TKey
+
+        /// <summary>
+        /// Gets a collections for a potentially partitioned document type.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="document">The document.</param>
+        /// <returns></returns>
+        public virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.HandlePartitioned<TDocument, TKey>(document);
+        }
+
+        /// <summary>
+        /// Gets a collections for a potentially partitioned document type.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="partitionKey">The collection partition key.</param>
+        /// <returns></returns>
+        public virtual IMongoCollection<TDocument> HandlePartitioned<TDocument, TKey>(string partitionKey)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (!string.IsNullOrEmpty(partitionKey))
+            {
+                return GetCollection<TDocument, TKey>(partitionKey);
+            }
+            return GetCollection<TDocument, TKey>();
+        }
+
+        /// <summary>
+        /// Gets a collections for a potentially partitioned document type.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="document">The document.</param>
+        /// <returns></returns>
+        public virtual IMongoCollection<TDocument> HandlePartitioned<TDocument>(TDocument document)
+            where TDocument : IDocument<Guid>
+        {
+            return MongoDbReader.HandlePartitioned<TDocument, Guid>(document);
+        }
+
+        /// <summary>
+        /// Gets a collections for the type TDocument with a partition key.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="partitionKey">The collection partition key.</param>
+        /// <returns></returns>
+        public virtual IMongoCollection<TDocument> GetCollection<TDocument, TKey>(string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetCollection<TDocument, TKey>(partitionKey);
+        }
     }
 }
\ No newline at end of file

From 0626292d09d725cdc45f271eb55a88cdfb40a964 Mon Sep 17 00:00:00 2001
From: Alexandre SPIESER <a.spieser@gmail.com>
Date: Sun, 14 Apr 2019 18:10:45 +0100
Subject: [PATCH 3/4] fixed some tests

---
 .../MongoDbTKeyDocumentTestBase.cs            | 61 +++++++++++--------
 .../BaseMongoRepository.Index.cs              |  4 +-
 2 files changed, 37 insertions(+), 28 deletions(-)

diff --git a/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.cs b/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.cs
index e048f14..a6e38d3 100644
--- a/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.cs
+++ b/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.cs
@@ -11,11 +11,11 @@ using Xunit;
 
 namespace CoreIntegrationTests.Infrastructure
 {
-    public abstract class MongoDbTKeyDocumentTestBase<T, TKey> : 
+    public abstract class MongoDbTKeyDocumentTestBase<T, TKey> :
         IClassFixture<MongoDbTestFixture<T, TKey>>
-        where T: TestDoc<TKey>, new()
+        where T : TestDoc<TKey>, new()
         where TKey : IEquatable<TKey>
-        
+
     {
         private readonly MongoDbTestFixture<T, TKey> _fixture;
 
@@ -76,7 +76,7 @@ namespace CoreIntegrationTests.Infrastructure
             // Act
             SUT.AddOne<T, TKey>(document);
             // Assert
-            long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T, TKey>(e => e.Id.Equals(document.Id)) 
+            long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T, TKey>(e => e.Id.Equals(document.Id))
                                                             : SUT.Count<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey);
             Assert.True(1 == count, GetTestName());
         }
@@ -91,7 +91,7 @@ namespace CoreIntegrationTests.Infrastructure
             // Assert
             long count = string.IsNullOrEmpty(PartitionKey) ? SUT.Count<T, TKey>(e => e.Id.Equals(document.Id))
                                                             : SUT.Count<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey);
-            Assert.True (1 == count, GetTestName());
+            Assert.True(1 == count, GetTestName());
         }
 
         [Fact]
@@ -106,7 +106,7 @@ namespace CoreIntegrationTests.Infrastructure
                                                                                    || e.Id.Equals(documents[1].Id))
                                                             : SUT.Count<T, TKey>(e => e.Id.Equals(documents[0].Id)
                                                                                   || e.Id.Equals(documents[1].Id), PartitionKey);
-            Assert.True (2 == count, GetTestName());
+            Assert.True(2 == count, GetTestName());
         }
 
         [Fact]
@@ -147,7 +147,7 @@ namespace CoreIntegrationTests.Infrastructure
                                                                                    || e.Id.Equals(documents[1].Id))
                                                             : SUT.Count<T, TKey>(e => e.Id.Equals(documents[0].Id)
                                                                                   || e.Id.Equals(documents[1].Id), PartitionKey);
-            Assert.True (2 == count, GetTestName());
+            Assert.True(2 == count, GetTestName());
         }
 
         [Fact]
@@ -238,7 +238,7 @@ namespace CoreIntegrationTests.Infrastructure
             var cursor = SUT.GetCursor<T, TKey>(x => x.Id.Equals(document.Id), PartitionKey);
             var count = cursor.CountDocuments();
             // Assert
-            Assert.True (1 == count, GetTestName());
+            Assert.True(1 == count, GetTestName());
         }
 
         [Fact]
@@ -493,10 +493,10 @@ namespace CoreIntegrationTests.Infrastructure
             Assert.True(result);
             var updatedDocument = SUT.GetById<T, TKey>(document.Id, PartitionKey);
             Assert.True(null != updatedDocument);
-            Assert.True(childrenToAdd[0].Type== updatedDocument.Children[0].Type, GetTestName());
-            Assert.True(childrenToAdd[0].Value== updatedDocument.Children[0].Value, GetTestName());
-            Assert.True(childrenToAdd[1].Type== updatedDocument.Children[1].Type, GetTestName());
-            Assert.True(childrenToAdd[1].Value== updatedDocument.Children[1].Value, GetTestName());
+            Assert.True(childrenToAdd[0].Type == updatedDocument.Children[0].Type, GetTestName());
+            Assert.True(childrenToAdd[0].Value == updatedDocument.Children[0].Value, GetTestName());
+            Assert.True(childrenToAdd[1].Type == updatedDocument.Children[1].Type, GetTestName());
+            Assert.True(childrenToAdd[1].Value == updatedDocument.Children[1].Value, GetTestName());
         }
 
         #endregion Update
@@ -512,7 +512,7 @@ namespace CoreIntegrationTests.Infrastructure
             // Act
             var result = SUT.DeleteOne<T, TKey>(document);
             // Assert
-            Assert.True (1 == result);
+            Assert.True(1 == result);
             Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
         }
 
@@ -525,7 +525,7 @@ namespace CoreIntegrationTests.Infrastructure
             // Act
             var result = SUT.DeleteOne<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey);
             // Assert
-            Assert.True (1 == result);
+            Assert.True(1 == result);
             Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
         }
 
@@ -538,7 +538,7 @@ namespace CoreIntegrationTests.Infrastructure
             // Act
             var result = await SUT.DeleteOneAsync<T, TKey>(document);
             // Assert
-            Assert.True (1 == result);
+            Assert.True(1 == result);
             Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
         }
 
@@ -551,7 +551,7 @@ namespace CoreIntegrationTests.Infrastructure
             // Act
             var result = await SUT.DeleteOneAsync<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey);
             // Assert
-            Assert.True (1 == result);
+            Assert.True(1 == result);
             Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
         }
 
@@ -768,7 +768,8 @@ namespace CoreIntegrationTests.Infrastructure
             var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
             var documents = CreateTestDocuments(5);
             var i = 1;
-            documents.ForEach(e => {
+            documents.ForEach(e =>
+            {
                 e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
                 e.SomeContent = criteria;
             });
@@ -790,7 +791,8 @@ namespace CoreIntegrationTests.Infrastructure
             var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
             var documents = CreateTestDocuments(5);
             var i = 1;
-            documents.ForEach(e => {
+            documents.ForEach(e =>
+            {
                 e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
                 e.SomeContent = criteria;
             });
@@ -812,7 +814,8 @@ namespace CoreIntegrationTests.Infrastructure
             var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
             var documents = CreateTestDocuments(5);
             var i = 1;
-            documents.ForEach(e => {
+            documents.ForEach(e =>
+            {
                 e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
                 e.SomeContent = criteria;
             });
@@ -834,7 +837,8 @@ namespace CoreIntegrationTests.Infrastructure
             var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
             var documents = CreateTestDocuments(5);
             var i = 1;
-            documents.ForEach(e => {
+            documents.ForEach(e =>
+            {
                 e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
                 e.SomeContent = criteria;
             });
@@ -856,7 +860,8 @@ namespace CoreIntegrationTests.Infrastructure
             var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
             var documents = CreateTestDocuments(5);
             var i = 1;
-            documents.ForEach(e => {
+            documents.ForEach(e =>
+            {
                 e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
                 e.SomeContent = criteria;
             });
@@ -878,7 +883,8 @@ namespace CoreIntegrationTests.Infrastructure
             var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
             var documents = CreateTestDocuments(5);
             var i = 1;
-            documents.ForEach(e => {
+            documents.ForEach(e =>
+            {
                 e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
                 e.SomeContent = criteria;
             });
@@ -900,7 +906,8 @@ namespace CoreIntegrationTests.Infrastructure
             var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
             var documents = CreateTestDocuments(5);
             var i = 1;
-            documents.ForEach(e => {
+            documents.ForEach(e =>
+            {
                 e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
                 e.SomeContent = criteria;
             });
@@ -908,7 +915,7 @@ namespace CoreIntegrationTests.Infrastructure
             var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
 
             // Act
-            var result = SUT.GetMinValue< T, TKey, DateTime >(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+            var result = SUT.GetMinValue<T, TKey, DateTime>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
 
             // Assert
             Assert.True(result != default(DateTime));
@@ -922,7 +929,8 @@ namespace CoreIntegrationTests.Infrastructure
             var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
             var documents = CreateTestDocuments(5);
             var i = 1;
-            documents.ForEach(e => {
+            documents.ForEach(e =>
+            {
                 e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
                 e.SomeContent = criteria;
             });
@@ -930,7 +938,7 @@ namespace CoreIntegrationTests.Infrastructure
             var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
 
             // Act
-            var result = await SUT.GetMinValueAsync< T, TKey, DateTime >(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+            var result = await SUT.GetMinValueAsync<T, TKey, DateTime>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
 
             // Assert
             Assert.True(result != default(DateTime));
@@ -1056,6 +1064,7 @@ namespace CoreIntegrationTests.Infrastructure
             // Act
             Expression<Func<T, object>> ex = x => x.SomeContent4;
             Expression<Func<T, object>> ex2 = x => x.SomeContent5;
+
             var result = await SUT.CreateCombinedTextIndexAsync<T, TKey>(new[] { ex, ex2 }, null, PartitionKey);
 
             // Assert
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Index.cs b/MongoDbGenericRepository/BaseMongoRepository.Index.cs
index d973a16..2596224 100644
--- a/MongoDbGenericRepository/BaseMongoRepository.Index.cs
+++ b/MongoDbGenericRepository/BaseMongoRepository.Index.cs
@@ -305,7 +305,7 @@ namespace MongoDbGenericRepository
         public async Task DropIndexAsync<TDocument>(string indexName, string partitionKey = null)
             where TDocument : IDocument<Guid>
         {
-            await MongoDbIndexHandler.DropIndexAsync<TDocument, Guid>(partitionKey);
+            await MongoDbIndexHandler.DropIndexAsync<TDocument, Guid>(indexName, partitionKey);
         }
 
         /// <inheritdoc />
@@ -313,7 +313,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            await MongoDbIndexHandler.DropIndexAsync<TDocument, TKey>(partitionKey);
+            await MongoDbIndexHandler.DropIndexAsync<TDocument, TKey>(indexName, partitionKey);
         }
     }
 }
\ No newline at end of file

From 2207f2f1a142efad6576f29f68fbe85e6b68912a Mon Sep 17 00:00:00 2001
From: Alexandre SPIESER <a.spieser@gmail.com>
Date: Sun, 14 Apr 2019 19:31:28 +0100
Subject: [PATCH 4/4] rename after full refactor

---
 .../Abstractions/IBaseMongoRepository.cs      |  9 ++++---
 ...ry.cs => IReadOnlyMongoRepository.TKey.cs} |  2 +-
 .../Abstractions/IReadOnlyMongoRepository.cs  |  2 +-
 .../BaseMongoRepository.Create.cs             |  2 +-
 .../BaseMongoRepository.Delete.cs             |  2 +-
 .../BaseMongoRepository.Index.cs              |  2 +-
 .../BaseMongoRepository.Update.cs             |  2 +-
 ....cs => BaseMongoRepository.TKey.Create.cs} |  4 ++--
 ....cs => BaseMongoRepository.TKey.Delete.cs} |  4 ++--
 ...x.cs => BaseMongoRepository.TKey.Index.cs} |  4 ++--
 ...in.cs => BaseMongoRepository.TKey.Main.cs} | 24 +++++++++----------
 ...s => BaseMongoRepository.TKey.ReadOnly.cs} |  8 +++----
 ....cs => BaseMongoRepository.TKey.Update.cs} |  4 ++--
 .../ReadOnlyMongoRepository.cs                |  2 +-
 14 files changed, 37 insertions(+), 34 deletions(-)
 rename MongoDbGenericRepository/Abstractions/{IKeyTypedReadOnlyMongoRepository.cs => IReadOnlyMongoRepository.TKey.cs} (99%)
 rename MongoDbGenericRepository/KeyTypedRepository/{KeyTypedBaseMongoDbRepository.Create.cs => BaseMongoRepository.TKey.Create.cs} (95%)
 rename MongoDbGenericRepository/KeyTypedRepository/{KeyTypedBaseMongoDbRepository.Delete.cs => BaseMongoRepository.TKey.Delete.cs} (98%)
 rename MongoDbGenericRepository/KeyTypedRepository/{KeyTypedBaseMongoDbRepository.Index.cs => BaseMongoRepository.TKey.Index.cs} (98%)
 rename MongoDbGenericRepository/KeyTypedRepository/{KeyTypedBaseMongoDbRepository.Main.cs => BaseMongoRepository.TKey.Main.cs} (75%)
 rename MongoDbGenericRepository/KeyTypedRepository/{KeyTypedReadOnlyMongoRepository.cs => BaseMongoRepository.TKey.ReadOnly.cs} (98%)
 rename MongoDbGenericRepository/KeyTypedRepository/{KeyTypedBaseMongoDbRepository.Update.cs => BaseMongoRepository.TKey.Update.cs} (98%)

diff --git a/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs b/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs
index 9f7b39f..adfe39e 100644
--- a/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs
@@ -11,10 +11,13 @@ namespace MongoDbGenericRepository
     /// <summary>
     /// The IBaseMongoRepository exposes the CRUD functionality of the BaseMongoRepository.
     /// </summary>
-    public interface IBaseMongoRepository : IReadOnlyMongoRepository, IBaseMongoRepository_Create, IBaseMongoRepository_Update, IBaseMongoRepository_Delete, IBaseMongoRepository_Index
+    public interface IBaseMongoRepository : 
+        IReadOnlyMongoRepository, 
+        IBaseMongoRepository_Create, 
+        IBaseMongoRepository_Update, 
+        IBaseMongoRepository_Delete, 
+        IBaseMongoRepository_Index
     {
-
-
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
         /// </summary>
diff --git a/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs b/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.TKey.cs
similarity index 99%
rename from MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs
rename to MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.TKey.cs
index 847a2a4..7790fc8 100644
--- a/MongoDbGenericRepository/Abstractions/IKeyTypedReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.TKey.cs
@@ -8,7 +8,7 @@ using MongoDbGenericRepository.Models;
 
 namespace MongoDbGenericRepository
 {
-    public interface IKeyTypedReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
+    public interface IReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
     {
         #region Read
 
diff --git a/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.cs b/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.cs
index 61d6a44..e36e8bd 100644
--- a/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.cs
@@ -9,7 +9,7 @@ namespace MongoDbGenericRepository
     /// <summary>
     /// The IReadOnlyMongoRepository exposes the readonly functionality of the BaseMongoRepository.
     /// </summary>
-    public interface IReadOnlyMongoRepository : IBaseReadOnlyRepository, IKeyTypedReadOnlyMongoRepository<Guid>
+    public interface IReadOnlyMongoRepository : IBaseReadOnlyRepository, IReadOnlyMongoRepository<Guid>
     {
 
     }
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Create.cs b/MongoDbGenericRepository/BaseMongoRepository.Create.cs
index 5e772de..5d9db5a 100644
--- a/MongoDbGenericRepository/BaseMongoRepository.Create.cs
+++ b/MongoDbGenericRepository/BaseMongoRepository.Create.cs
@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
-    public interface IBaseMongoRepository_Create : IKeyTypedBaseMongoDbRepository_Create<Guid>
+    public interface IBaseMongoRepository_Create : IBaseMongoRepository_Create<Guid>
     {
         /// <summary>
         /// Asynchronously adds a document to the collection.
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Delete.cs b/MongoDbGenericRepository/BaseMongoRepository.Delete.cs
index 5c74794..0c0491a 100644
--- a/MongoDbGenericRepository/BaseMongoRepository.Delete.cs
+++ b/MongoDbGenericRepository/BaseMongoRepository.Delete.cs
@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
-    public interface IBaseMongoRepository_Delete : IKeyTypedBaseMongoDbRepository_Delete<Guid>
+    public interface IBaseMongoRepository_Delete : IBaseMongoRepository_Delete<Guid>
     {
         /// <summary>
         /// Deletes a document.
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Index.cs b/MongoDbGenericRepository/BaseMongoRepository.Index.cs
index 2596224..9cdb64b 100644
--- a/MongoDbGenericRepository/BaseMongoRepository.Index.cs
+++ b/MongoDbGenericRepository/BaseMongoRepository.Index.cs
@@ -7,7 +7,7 @@ using MongoDbGenericRepository.Models;
 
 namespace MongoDbGenericRepository
 {
-    public interface IBaseMongoRepository_Index : IKeyTypedBaseMongoDbRepository_Index<Guid>
+    public interface IBaseMongoRepository_Index : IBaseMongoRepository_Index<Guid>
     {
         /// <summary>
         /// Returns the names of the indexes present on a collection.
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Update.cs b/MongoDbGenericRepository/BaseMongoRepository.Update.cs
index beea2e1..4a89323 100644
--- a/MongoDbGenericRepository/BaseMongoRepository.Update.cs
+++ b/MongoDbGenericRepository/BaseMongoRepository.Update.cs
@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
-    public interface IBaseMongoRepository_Update : IKeyTypedBaseMongoDbRepository_Update<Guid>
+    public interface IBaseMongoRepository_Update : IBaseMongoRepository_Update<Guid>
     {
         /// <summary>
         /// Asynchronously Updates a document.
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Create.cs b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Create.cs
similarity index 95%
rename from MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Create.cs
rename to MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Create.cs
index 7d3271b..216f47f 100644
--- a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Create.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Create.cs
@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
-    public interface IKeyTypedBaseMongoDbRepository_Create<TKey> where TKey : IEquatable<TKey>
+    public interface IBaseMongoRepository_Create<TKey> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Asynchronously adds a document to the collection.
@@ -46,7 +46,7 @@ namespace MongoDbGenericRepository
     /// Its constructor must be given a connection string and a database name.
     /// </summary>
     /// <typeparam name="TKey"></typeparam>
-    public abstract partial class KeyTypedBaseMongoDbRepository<TKey> : IKeyTypedBaseMongoDbRepository_Create<TKey> where TKey : IEquatable<TKey>
+    public abstract partial class BaseMongoRepository<TKey> : IBaseMongoRepository_Create<TKey> where TKey : IEquatable<TKey>
     {
         protected MongoDbCreator _mongoDbCreator;
         protected MongoDbCreator MongoDbCreator
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Delete.cs b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Delete.cs
similarity index 98%
rename from MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Delete.cs
rename to MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Delete.cs
index c1d4d43..d6d3097 100644
--- a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Delete.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Delete.cs
@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
-    public interface IKeyTypedBaseMongoDbRepository_Delete<TKey> where TKey : IEquatable<TKey>
+    public interface IBaseMongoRepository_Delete<TKey> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Deletes a document.
@@ -94,7 +94,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>;
     }
 
-    public abstract partial class KeyTypedBaseMongoDbRepository<TKey>: IKeyTypedBaseMongoDbRepository_Delete<TKey> 
+    public abstract partial class BaseMongoRepository<TKey>: IBaseMongoRepository_Delete<TKey> 
         where TKey : IEquatable<TKey>
     {
         private MongoDbEraser _mongoDbEraser;
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Index.cs b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Index.cs
similarity index 98%
rename from MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Index.cs
rename to MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Index.cs
index 8dc9850..1807ab2 100644
--- a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Index.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Index.cs
@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
-    public interface IKeyTypedBaseMongoDbRepository_Index<TKey> where TKey : IEquatable<TKey>
+    public interface IBaseMongoRepository_Index<TKey> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Returns the names of the indexes present on a collection.
@@ -98,7 +98,7 @@ namespace MongoDbGenericRepository
     /// Its constructor must be given a connection string and a database name.
     /// </summary>
     /// <typeparam name="TKey"></typeparam>
-    public abstract partial class KeyTypedBaseMongoDbRepository<TKey> : IKeyTypedBaseMongoDbRepository_Index<TKey>
+    public abstract partial class BaseMongoRepository<TKey> : IBaseMongoRepository_Index<TKey>
         where TKey : IEquatable<TKey>
     {
         private MongoDbIndexHandler _mongoDbIndexHandler;
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Main.cs b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Main.cs
similarity index 75%
rename from MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Main.cs
rename to MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Main.cs
index 265b7c7..ef79b46 100644
--- a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Main.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Main.cs
@@ -4,12 +4,12 @@ using System;
 
 namespace MongoDbGenericRepository
 {
-    public interface IKeyTypedBaseMongoDbRepository<TKey> :
-        IKeyTypedReadOnlyMongoRepository<TKey>,
-        IKeyTypedBaseMongoDbRepository_Create<TKey>,
-        IKeyTypedBaseMongoDbRepository_Delete<TKey>,
-        IKeyTypedBaseMongoDbRepository_Index<TKey>,
-        IKeyTypedBaseMongoDbRepository_Update<TKey>
+    public interface IBaseMongoDbRepository<TKey> :
+        IReadOnlyMongoRepository<TKey>,
+        IBaseMongoRepository_Create<TKey>,
+        IBaseMongoRepository_Delete<TKey>,
+        IBaseMongoRepository_Index<TKey>,
+        IBaseMongoRepository_Update<TKey>
         where TKey : IEquatable<TKey>
     {
     }
@@ -19,9 +19,9 @@ namespace MongoDbGenericRepository
     /// Its constructor must be given a connection string and a database name.
     /// </summary>
     /// <typeparam name="TKey"></typeparam>
-    public abstract partial class KeyTypedBaseMongoDbRepository<TKey> : 
-        KeyTypedReadOnlyMongoRepository<TKey>, 
-        IKeyTypedBaseMongoDbRepository<TKey>
+    public abstract partial class BaseMongoRepository<TKey> : 
+        ReadOnlyMongoRepository<TKey>, 
+        IBaseMongoDbRepository<TKey>
         where TKey : IEquatable<TKey>
     {
         protected readonly object _initLock = new object();
@@ -31,7 +31,7 @@ namespace MongoDbGenericRepository
         /// </summary>
         /// <param name="connectionString">The connection string of the MongoDb server.</param>
         /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
-        protected KeyTypedBaseMongoDbRepository(string connectionString, string databaseName = null) : base(connectionString, databaseName)
+        protected BaseMongoRepository(string connectionString, string databaseName = null) : base(connectionString, databaseName)
         {
         }
 
@@ -39,7 +39,7 @@ namespace MongoDbGenericRepository
         /// The contructor taking a <see cref="IMongoDbContext"/>.
         /// </summary>
         /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
-        protected KeyTypedBaseMongoDbRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
+        protected BaseMongoRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
         {
         }
 
@@ -47,7 +47,7 @@ namespace MongoDbGenericRepository
         /// The contructor taking a <see cref="IMongoDatabase"/>.
         /// </summary>
         /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
-        protected KeyTypedBaseMongoDbRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
+        protected BaseMongoRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
         {
         }
 
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedReadOnlyMongoRepository.cs b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs
similarity index 98%
rename from MongoDbGenericRepository/KeyTypedRepository/KeyTypedReadOnlyMongoRepository.cs
rename to MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs
index 44a1af4..a103005 100644
--- a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs
@@ -13,7 +13,7 @@ namespace MongoDbGenericRepository
     /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
     /// Its constructor must be given a connection string and a database name.
     /// </summary>
-    public abstract partial class KeyTypedReadOnlyMongoRepository<TKey> : IKeyTypedReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
+    public abstract partial class ReadOnlyMongoRepository<TKey> : IReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// The connection string.
@@ -40,7 +40,7 @@ namespace MongoDbGenericRepository
         /// </summary>
         /// <param name="connectionString">The connection string of the MongoDb server.</param>
         /// <param name="databaseName">The name of the database against which you want to perform operations.</param>
-        protected KeyTypedReadOnlyMongoRepository(string connectionString, string databaseName = null)
+        protected ReadOnlyMongoRepository(string connectionString, string databaseName = null)
         {
             SetupMongoDbContext(connectionString, databaseName);
         }
@@ -49,7 +49,7 @@ namespace MongoDbGenericRepository
         /// The contructor taking a <see cref="IMongoDatabase"/>.
         /// </summary>
         /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
-        protected KeyTypedReadOnlyMongoRepository(IMongoDatabase mongoDatabase) : this(new MongoDbContext(mongoDatabase))
+        protected ReadOnlyMongoRepository(IMongoDatabase mongoDatabase) : this(new MongoDbContext(mongoDatabase))
         {
         }
 
@@ -57,7 +57,7 @@ namespace MongoDbGenericRepository
         /// The contructor taking a <see cref="IMongoDbContext"/>.
         /// </summary>
         /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
-        protected KeyTypedReadOnlyMongoRepository(IMongoDbContext mongoDbContext)
+        protected ReadOnlyMongoRepository(IMongoDbContext mongoDbContext)
         {
             SetupMongoDbContext(mongoDbContext);
         }
diff --git a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Update.cs b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Update.cs
similarity index 98%
rename from MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Update.cs
rename to MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Update.cs
index 1be2d34..8e22067 100644
--- a/MongoDbGenericRepository/KeyTypedRepository/KeyTypedBaseMongoDbRepository.Update.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Update.cs
@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace MongoDbGenericRepository
 {
-    public interface IKeyTypedBaseMongoDbRepository_Update<TKey> where TKey : IEquatable<TKey>
+    public interface IBaseMongoRepository_Update<TKey> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Asynchronously Updates a document.
@@ -112,7 +112,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>;
     }
 
-    public abstract partial class KeyTypedBaseMongoDbRepository<TKey> : IKeyTypedBaseMongoDbRepository_Update<TKey>
+    public abstract partial class BaseMongoRepository<TKey> : IBaseMongoRepository_Update<TKey>
         where TKey : IEquatable<TKey>
     {
         private MongoDbUpdater _mongoDbUpdater;
diff --git a/MongoDbGenericRepository/ReadOnlyMongoRepository.cs b/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
index 02484e2..c8bcb99 100644
--- a/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
@@ -13,7 +13,7 @@ namespace MongoDbGenericRepository
     /// The base Repository, it is meant to be inherited from by your custom custom MongoRepository implementation.
     /// Its constructor must be given a connection string and a database name.
     /// </summary>
-    public abstract class ReadOnlyMongoRepository : KeyTypedReadOnlyMongoRepository<Guid>, IReadOnlyMongoRepository
+    public abstract class ReadOnlyMongoRepository : ReadOnlyMongoRepository<Guid>, IReadOnlyMongoRepository
     {
         /// <summary>
         /// The constructor taking a connection string and a database name.