Update README.md

CoreIntegrationTests/App.config

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  For more information on how to configure your ASP.NET application, please visit
+  http://go.microsoft.com/fwlink/?LinkId=169433
+  -->
+<configuration>
+  <connectionStrings>
+    <add name="MongoDbTests" connectionString="mongodb://localhost:27017" />
+  </connectionStrings>
+</configuration>

CoreIntegrationTests/CoreIntegrationTests.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Identity" Version="2.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Identity.Stores" Version="2.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0-preview-20170810-02" />
+    <PackageReference Include="MongoDB.Driver" Version="2.4.4" />
+    <PackageReference Include="xunit" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.console" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0-beta4-build3742" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MongoDbGenericRepository\MongoDbGenericRepository.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="App.config">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>

CoreIntegrationTests/CreatePartitionedTests.cs

@@ -0,0 +1,67 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class CreateTestsPartitionedDocument : PartitionedDocument
+    {
+        public CreateTestsPartitionedDocument() : base("TestPartitionKey")
+        {
+            Version = 1;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class CreatePartitionedTests : BaseMongoDbRepositoryTests<CreateTestsPartitionedDocument>
+    {
+        private void PartitionedAddOne()
+        {
+            // Arrange
+            var document = new CreateTestsPartitionedDocument();
+            // Act
+            SUT.AddOne(document);
+            // Assert
+            long count = SUT.Count<CreateTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey);
+            Xunit.Assert.Equal(1, count);
+        }
+
+        [Fact]
+        public async Task PartitionedAddOneAsync()
+        {
+            // Arrange
+            var document = new CreateTestsPartitionedDocument();
+            // Act
+            await SUT.AddOneAsync(document);
+            // Assert
+            long count = SUT.Count<CreateTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey);
+            Assert.Equal(1, count);
+        }
+
+        [Fact]
+        public void PartitionedAddMany()
+        {
+            // Arrange
+            var documents = new List<CreateTestsPartitionedDocument> { new CreateTestsPartitionedDocument(), new CreateTestsPartitionedDocument() };
+            // Act
+            SUT.AddMany(documents);
+            // Assert
+            long count = SUT.Count<CreateTestsPartitionedDocument>(e => e.Id == documents[0].Id || e.Id == documents[1].Id, PartitionKey);
+            Assert.Equal(2, count);
+        }
+
+        [Fact]
+        public async Task PartitionedAddManyAsync()
+        {
+            // Arrange
+            var documents = new List<CreateTestsPartitionedDocument> { new CreateTestsPartitionedDocument(), new CreateTestsPartitionedDocument() };
+            // Act
+            await SUT.AddManyAsync(documents);
+            // Assert
+            long count = SUT.Count<CreateTestsPartitionedDocument>(e => e.Id == documents[0].Id || e.Id == documents[1].Id, PartitionKey);
+            Assert.Equal(2, count);
+        }
+    }
+}

CoreIntegrationTests/CreateTests.cs

@@ -0,0 +1,68 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class CreateTestsDocument : Document
+    {
+        public CreateTestsDocument()
+        {
+            Version = 2;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class CreateTests : BaseMongoDbRepositoryTests<CreateTestsDocument>
+    {
+        [Fact]
+        public void AddOne()
+        {
+            // Arrange
+            var document = new CreateTestsDocument();
+            // Act
+            SUT.AddOne(document);
+            // Assert
+            long count = SUT.Count<CreateTestsDocument>(e => e.Id == document.Id);
+            Assert.Equal(1, count);
+        }
+
+        [Fact]
+        public async Task AddOneAsync()
+        {
+            // Arrange
+            var document = new CreateTestsDocument();
+            // Act
+            await SUT.AddOneAsync(document);
+            // Assert
+            long count = SUT.Count<CreateTestsDocument>(e => e.Id == document.Id);
+            Assert.Equal(1, count);
+        }
+
+        [Fact]
+        public void AddMany()
+        {
+            // Arrange
+            var documents = new List<CreateTestsDocument> { new CreateTestsDocument(), new CreateTestsDocument() };
+            // Act
+            SUT.AddMany(documents);
+            // Assert
+            long count = SUT.Count<CreateTestsDocument>(e => e.Id == documents[0].Id || e.Id == documents[1].Id);
+            Assert.Equal(2, count);
+        }
+
+        [Fact]
+        public async Task AddManyAsync()
+        {
+            // Arrange
+            var documents = new List<CreateTestsDocument> { new CreateTestsDocument(), new CreateTestsDocument() };
+            // Act
+            await SUT.AddManyAsync(documents);
+            // Assert
+            long count = SUT.Count<CreateTestsDocument>(e => e.Id == documents[0].Id || e.Id == documents[1].Id);
+            Assert.Equal(2, count);
+        }
+    }
+}

CoreIntegrationTests/DeletePartitionedTests.cs

@@ -0,0 +1,129 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class DeleteTestsPartitionedDocument : PartitionedDocument
+    {
+        public DeleteTestsPartitionedDocument() : base("TestPartitionKey")
+        {
+            Version = 1;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class DeletePartitionedTests : BaseMongoDbRepositoryTests<DeleteTestsPartitionedDocument>
+    {
+        [Fact]
+        public void PartitionedDeleteOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.DeleteOne(document);
+            // Assert
+            Assert.Equal(1, result);
+            Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey));
+        }
+
+        [Fact]
+        public void PartitionedDeleteOneLinq()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.DeleteOne<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.Equal(1, result);
+            Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey));
+        }
+
+        [Fact]
+        public async Task PartitionedDeleteOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.DeleteOneAsync(document);
+            // Assert
+            Assert.Equal(1, result);
+            Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey));
+        }
+
+        [Fact]
+        public async Task PartitionedDeleteOneAsyncLinq()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.DeleteOneAsync<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.Equal(1, result);
+            Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.Id == document.Id, PartitionKey));
+        }
+
+        [Fact]
+        public async Task PartitionedDeleteManyAsyncLinq()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync<DeleteTestsPartitionedDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent", PartitionKey);
+            // Assert
+            Assert.Equal(5, result);
+            Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent", PartitionKey));
+        }
+
+        [Fact]
+        public async Task PartitionedDeleteManyAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync(documents);
+            // Assert
+            Assert.Equal(5, result);
+            Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent", PartitionKey));
+        }
+
+        [Fact]
+        public void PartitionedDeleteManyLinq()
+        {
+            // Arrange
+            var content = "DeleteManyLinqContent";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = content);
+            SUT.AddMany(documents);
+            // Act
+            var result = SUT.DeleteMany<DeleteTestsPartitionedDocument>(e => e.SomeContent == content, PartitionKey);
+            // Assert
+            Assert.Equal(5, result);
+            Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.SomeContent == content, PartitionKey));
+        }
+
+        [Fact]
+        public void PartitionedDeleteMany()
+        {
+            // Arrange
+            var content = "DeleteManyContent";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = content);
+            SUT.AddMany(documents);
+            // Act
+            var result = SUT.DeleteMany(documents);
+            // Assert
+            Assert.Equal(5, result);
+            Assert.False(SUT.Any<DeleteTestsPartitionedDocument>(e => e.SomeContent == content, PartitionKey));
+        }
+    }
+}

CoreIntegrationTests/DeleteTests.cs

@@ -0,0 +1,129 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class DeleteTestsDocument : Document
+    {
+        public DeleteTestsDocument()
+        {
+            Version = 2;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class DeleteTests : BaseMongoDbRepositoryTests<DeleteTestsDocument>
+    {
+        [Fact]
+        public void DeleteOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.DeleteOne(document);
+            // Assert
+            Assert.Equal(1, result);
+            Assert.False(SUT.Any<DeleteTestsDocument>(e => e.Id == document.Id));
+        }
+
+        [Fact]
+        public void DeleteOneLinq()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.DeleteOne<DeleteTestsDocument>(e => e.Id == document.Id);
+            // Assert
+            Assert.Equal(1, result);
+            Assert.False(SUT.Any<DeleteTestsDocument>(e => e.Id == document.Id));
+        }
+
+        [Fact]
+        public async Task DeleteOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.DeleteOneAsync(document);
+            // Assert
+            Assert.Equal(1, result);
+            Assert.False(SUT.Any<DeleteTestsDocument>(e => e.Id == document.Id));
+        }
+
+        [Fact]
+        public async Task DeleteOneAsyncLinq()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.DeleteOneAsync<DeleteTestsDocument>(e => e.Id == document.Id);
+            // Assert
+            Assert.Equal(1, result);
+            Assert.False(SUT.Any<DeleteTestsDocument>(e => e.Id == document.Id));
+        }
+
+        [Fact]
+        public async Task DeleteManyAsyncLinq()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync<DeleteTestsDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent");
+            // Assert
+            Assert.Equal(5, result);
+            Assert.False(SUT.Any<DeleteTestsDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent"));
+        }
+
+        [Fact]
+        public async Task DeleteManyAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync(documents);
+            // Assert
+            Assert.Equal(5, result);
+            Assert.False(SUT.Any<DeleteTestsDocument>(e => e.SomeContent == "DeleteManyAsyncLinqContent"));
+        }
+
+        [Fact]
+        public void DeleteManyLinq()
+        {
+            // Arrange
+            var content = "DeleteManyLinqContent";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = content);
+            SUT.AddMany(documents);
+            // Act
+            var result = SUT.DeleteMany<DeleteTestsDocument>(e => e.SomeContent == content);
+            // Assert
+            Assert.Equal(5, result);
+            Assert.False(SUT.Any<DeleteTestsDocument>(e => e.SomeContent == content));
+        }
+
+        [Fact]
+        public void DeleteMany()
+        {
+            // Arrange
+            var content = "DeleteManyContent";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = content);
+            SUT.AddMany(documents);
+            // Act
+            var result = SUT.DeleteMany(documents);
+            // Assert
+            Assert.Equal(5, result);
+            Assert.False(SUT.Any<DeleteTestsDocument>(e => e.SomeContent == content));
+        }
+    }
+}

CoreIntegrationTests/IdentityUserTests.cs

@@ -0,0 +1,77 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Collections.Generic;
+using Xunit;
+using Microsoft.AspNetCore.Identity;
+using System.Threading.Tasks;
+
+namespace CoreCoreIntegrationTests
+{
+    public class MongoIdentityUser<TKey> : IdentityUser<TKey>, IDocument<TKey>
+        where TKey : IEquatable<TKey>
+    {
+        public int Version { get; set; }
+    }
+
+    public class IdentityUserTest : MongoIdentityUser<Guid>, IDocument<Guid>
+    {
+        public IdentityUserTest()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class IdentityUserTests : BaseMongoDbRepositoryTests<IdentityUserTest>
+    {
+        [Fact]
+        public void AddOne()
+        {
+            // Arrange
+            var document = new IdentityUserTest();
+            // Act
+            SUT.AddOne<IdentityUserTest, Guid>(document);
+            // Assert
+            long count = SUT.Count<IdentityUserTest, Guid>(e => e.Id == document.Id);
+            Assert.Equal(1, count);
+        }
+
+        [Fact]
+        public async Task AddOneAsync()
+        {
+            // Arrange
+            var document = new IdentityUserTest();
+            // Act
+            await SUT.AddOneAsync<IdentityUserTest, Guid>(document);
+            // Assert
+            long count = SUT.Count<IdentityUserTest, Guid>(e => e.Id == document.Id);
+            Assert.Equal(1, count);
+        }
+
+        [Fact]
+        public void AddMany()
+        {
+            // Arrange
+            var documents = new List<IdentityUserTest> { new IdentityUserTest(), new IdentityUserTest() };
+            // Act
+            SUT.AddMany<IdentityUserTest, Guid>(documents);
+            // Assert
+            long count = SUT.Count<IdentityUserTest, Guid>(e => e.Id == documents[0].Id || e.Id == documents[1].Id);
+            Assert.Equal(2, count);
+        }
+
+        [Fact]
+        public async Task AddManyAsync()
+        {
+            // Arrange
+            var documents = new List<IdentityUserTest> { new IdentityUserTest(), new IdentityUserTest() };
+            // Act
+            await SUT.AddManyAsync<IdentityUserTest, Guid>(documents);
+            // Assert
+            long count = SUT.Count<IdentityUserTest, Guid>(e => e.Id == documents[0].Id || e.Id == documents[1].Id);
+            Assert.Equal(2, count);
+        }
+    }
+}

CoreIntegrationTests/Infrastructure/BaseMongoDbRepositoryTests.cs

@@ -0,0 +1,88 @@
+using MongoDbGenericRepository.Models;
+using System.Collections.Generic;
+using System;
+
+namespace CoreIntegrationTests.Infrastructure
+{
+
+    public class BaseMongoDbRepositoryTests<T> : IDisposable where T : new() 
+    {
+        public T CreateTestDocument()
+        {
+            return new T();
+        }
+
+        public List<T> CreateTestDocuments(int numberOfDocumentsToCreate)
+        {
+            var docs = new List<T>();
+            for(var i = 0; i < numberOfDocumentsToCreate; i++)
+            {
+                docs.Add(new T());
+            }
+            return docs;
+        }
+
+        /// <summary>
+        /// Constructor, init code
+        /// </summary>
+        public BaseMongoDbRepositoryTests()
+        {
+            Init();
+            var type = CreateTestDocument();
+            if (type is IPartitionedDocument)
+            {
+                PartitionKey = ((IPartitionedDocument)type).PartitionKey;
+            }
+        }
+
+        public string PartitionKey { get; set; }
+
+        /// <summary>
+        /// SUT: System Under Test
+        /// </summary>
+        protected static ITestRepository SUT { get; set; }
+
+        public void Init()
+        {
+            MongoDbConfig.EnsureConfigured();
+            SUT = TestRepository.Instance;
+        }
+
+        public void Cleanup()
+        {
+            // We drop the collection at the end of each test session.
+            if (!string.IsNullOrEmpty(PartitionKey))
+            {
+                SUT.DropTestCollection<T>(PartitionKey);
+            }
+            else
+            {
+                SUT.DropTestCollection<T>();
+            }
+        }
+
+        #region IDisposable Support
+        private bool disposedValue = false; // Pour détecter les appels redondants
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposedValue)
+            {
+                if (disposing)
+                {
+                    Cleanup();
+                }
+
+                disposedValue = true;
+            }
+        }
+
+        // Ce code est ajouté pour implémenter correctement le modèle supprimable.
+        public void Dispose()
+        {
+            // Ne modifiez pas ce code. Placez le code de nettoyage dans Dispose(bool disposing) ci-dessus.
+            Dispose(true);
+        }
+        #endregion
+    }
+}

CoreIntegrationTests/Infrastructure/ITestRepository.cs

@@ -0,0 +1,10 @@
+using MongoDbGenericRepository;
+
+namespace CoreIntegrationTests
+{
+    public interface ITestRepository : IBaseMongoRepository
+    {
+        void DropTestCollection<TDocument>();
+        void DropTestCollection<TDocument>(string partitionKey);
+    }
+}

CoreIntegrationTests/Infrastructure/MongoDbConfig.cs

@@ -0,0 +1,43 @@
+using CoreCoreIntegrationTests;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Conventions;
+using System.Threading;
+
+namespace CoreIntegrationTests.Infrastructure
+{
+    internal static class MongoDbConfig
+    {
+        private static bool _initialized = false;
+        private static object _initializationLock = new object();
+        private static object _initializationTarget;
+
+        public static void EnsureConfigured()
+        {
+            EnsureConfiguredImpl();
+        }
+
+        private static void EnsureConfiguredImpl()
+        {
+            LazyInitializer.EnsureInitialized(ref _initializationTarget, ref _initialized, ref _initializationLock, () =>
+            {
+                Configure();
+                return null;
+            });
+        }
+
+        private static void Configure()
+        {
+            RegisterConventions();
+        }
+
+        private static void RegisterConventions()
+        {
+            var pack = new ConventionPack
+            {
+                new IgnoreIfNullConvention(false),
+                new CamelCaseElementNameConvention(),
+            };
+        }
+
+    }
+}

CoreIntegrationTests/Infrastructure/TestRepository.cs

@@ -0,0 +1,43 @@
+using MongoDbGenericRepository;
+
+namespace CoreIntegrationTests.Infrastructure
+{
+    /// <summary>
+    /// A singleton implementation of the TestRepository
+    /// </summary>
+    public sealed class TestRepository : BaseMongoRepository, ITestRepository
+    {
+
+        const string connectionString = "mongodb://localhost:27017";
+        private static readonly ITestRepository _instance = new TestRepository(connectionString, "MongoDbTests");
+
+        // Explicit static constructor to tell C# compiler
+        // not to mark type as beforefieldinit
+        static TestRepository()
+        {
+        }
+
+        /// <inheritdoc />
+        private TestRepository(string connectionString, string databaseName) : base(connectionString, databaseName)
+        {
+        }
+
+        public static ITestRepository Instance
+        {
+            get
+            {
+                return _instance;
+            }
+        }
+
+        public void DropTestCollection<TDocument>()
+        {
+            MongoDbContext.DropCollection<TDocument>();
+        }
+
+        public void DropTestCollection<TDocument>(string partitionKey)
+        {
+            MongoDbContext.DropCollection<TDocument>(partitionKey);
+        }
+    }
+}

CoreIntegrationTests/ProjectPartitionedTests.cs

@@ -0,0 +1,140 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class ProjectTestsPartitionedDocument : PartitionedDocument
+    {
+        public ProjectTestsPartitionedDocument() : base("TestPartitionKey")
+        {
+            Version = 2;
+            Nested = new Nested
+            {
+                SomeDate = DateTime.UtcNow
+            };
+        }
+
+        public string SomeContent { get; set; }
+
+        public Nested Nested { get; set; }
+    }
+
+    public class ProjectPartitionedTests : BaseMongoDbRepositoryTests<ProjectTestsPartitionedDocument>
+    {
+        [Fact]
+        public async Task PartitionedProjectOneAsync()
+        {
+            // Arrange
+            const string someContent = "ProjectOneAsyncContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.ProjectOneAsync<ProjectTestsPartitionedDocument, MyProjection>(
+                x => x.Id == document.Id,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                PartitionKey);
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(someContent, result.SomeContent);
+            Assert.Equal(someDate.Minute, result.SomeDate.Minute);
+            Assert.Equal(someDate.Second, result.SomeDate.Second);
+        }
+
+        [Fact]
+        public void PartitionedProjectOne()
+        {
+            // Arrange
+            const string someContent = "ProjectOneContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.ProjectOne<ProjectTestsPartitionedDocument, MyProjection>(
+                x => x.Id == document.Id,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                PartitionKey);
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(someContent, result.SomeContent);
+            Assert.Equal(someDate.Minute, result.SomeDate.Minute);
+            Assert.Equal(someDate.Second, result.SomeDate.Second);
+        }
+
+        [Fact]
+        public async Task PartitionedProjectManyAsync()
+        {
+            // Arrange
+            const string someContent = "ProjectManyAsyncContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocuments(5);
+            document.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany(document);
+            // Act
+            var result = await SUT.ProjectManyAsync<ProjectTestsPartitionedDocument, MyProjection>(
+                x => x.SomeContent == someContent,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                PartitionKey);
+            // Assert
+            Assert.Equal(5, result.Count);
+            Assert.Equal(someContent, result.First().SomeContent);
+            Assert.Equal(someDate.Minute, result.First().SomeDate.Minute);
+            Assert.Equal(someDate.Second, result.First().SomeDate.Second);
+        }
+
+        [Fact]
+        public void PartitionedProjectMany()
+        {
+            // Arrange
+            const string someContent = "ProjectManyContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocuments(5);
+            document.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany(document);
+            // Act
+            var result = SUT.ProjectMany<ProjectTestsPartitionedDocument, MyProjection>(
+                x => x.SomeContent == someContent,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                PartitionKey);
+            // Assert
+            Assert.Equal(5, result.Count);
+            Assert.Equal(someContent, result.First().SomeContent);
+            Assert.Equal(someDate.Minute, result.First().SomeDate.Minute);
+            Assert.Equal(someDate.Second, result.First().SomeDate.Second);
+        }
+    }
+}

CoreIntegrationTests/ProjectTests.cs

@@ -0,0 +1,149 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class Nested
+    {
+        public DateTime SomeDate { get; set; }
+    }
+
+    public class MyProjection
+    {
+        public DateTime SomeDate { get; set; }
+        public string SomeContent { get; set; }
+    }
+
+    public class ProjectTestsDocument : Document
+    {
+        public ProjectTestsDocument()
+        {
+            Version = 2;
+            Nested = new Nested
+            {
+                SomeDate = DateTime.UtcNow
+            };
+        }
+
+        public string SomeContent { get; set; }
+
+        public Nested Nested { get; set; }
+    }
+
+    public class ProjectTests : BaseMongoDbRepositoryTests<ProjectTestsDocument>
+    {
+
+
+        [Fact]
+        public async Task ProjectOneAsync()
+        {
+            // Arrange
+            const string someContent = "ProjectOneAsyncContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.ProjectOneAsync<ProjectTestsDocument, MyProjection>(
+                x => x.Id == document.Id, 
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                });
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(someContent, result.SomeContent);
+            Assert.Equal(someDate.Minute, result.SomeDate.Minute);
+            Assert.Equal(someDate.Second, result.SomeDate.Second);
+        }
+
+        [Fact]
+        public void ProjectOne()
+        {
+            // Arrange
+            const string someContent = "ProjectOneContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.ProjectOne<ProjectTestsDocument, MyProjection>(
+                x => x.Id == document.Id,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                });
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(someContent, result.SomeContent);
+            Assert.Equal(someDate.Minute, result.SomeDate.Minute);
+            Assert.Equal(someDate.Second, result.SomeDate.Second);
+        }
+
+        [Fact]
+        public async Task ProjectManyAsync()
+        {
+            // Arrange
+            const string someContent = "ProjectManyAsyncContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocuments(5);
+            document.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany(document);
+            // Act
+            var result = await SUT.ProjectManyAsync<ProjectTestsDocument, MyProjection>(
+                x => x.SomeContent == someContent,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                });
+            // Assert
+            Assert.Equal(5, result.Count);
+            Assert.Equal(someContent, result.First().SomeContent);
+            Assert.Equal(someDate.Minute, result.First().SomeDate.Minute);
+            Assert.Equal(someDate.Second, result.First().SomeDate.Second);
+        }
+
+        [Fact]
+        public void ProjectMany()
+        {
+            // Arrange
+            const string someContent = "ProjectManyContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocuments(5);
+            document.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany(document);
+            // Act
+            var result = SUT.ProjectMany<ProjectTestsDocument, MyProjection>(
+                x => x.SomeContent == someContent,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                });
+            // Assert
+            Assert.Equal(5, result.Count);
+            Assert.Equal(someContent, result.First().SomeContent);
+            Assert.Equal(someDate.Minute, result.First().SomeDate.Minute);
+            Assert.Equal(someDate.Second, result.First().SomeDate.Second);
+        }
+    }
+}

CoreIntegrationTests/ReadPartitionedTests.cs

@@ -0,0 +1,181 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class ReadTestsPartitionedDocument : PartitionedDocument
+    {
+        public ReadTestsPartitionedDocument() : base("TestPartitionKey")
+        {
+            Version = 1;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class ReadPartitionedTests : BaseMongoDbRepositoryTests<ReadTestsPartitionedDocument>
+    {
+        [Fact]
+        public async Task PartitionedGetByIdAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.GetByIdAsync<ReadTestsPartitionedDocument>(document.Id, PartitionKey);
+            // Assert
+            Assert.NotNull(result);
+        }
+
+        [Fact]
+        public void PartitionedGetById()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.GetById<ReadTestsPartitionedDocument>(document.Id, PartitionKey);
+            // Assert
+            Assert.NotNull(result);
+        }
+
+        [Fact]
+        public async Task PartitionedGetOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.GetOneAsync<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.NotNull(result);
+        }
+
+        [Fact]
+        public void PartitionedGetOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.GetOne<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.NotNull(result);
+        }
+
+        [Fact]
+        public void PartitionedGetCursor()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var cursor = SUT.GetCursor<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
+            var count = cursor.Count();
+            // Assert
+            Assert.Equal(1, count);
+        }
+
+        [Fact]
+        public async Task PartitionedAnyAsyncReturnsTrue()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.AnyAsync<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public async Task PartitionedAnyAsyncReturnsFalse()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.AnyAsync<ReadTestsPartitionedDocument>(x => x.Id == Guid.NewGuid(), PartitionKey);
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void PartitionedAnyReturnsTrue()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.Any<ReadTestsPartitionedDocument>(x => x.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void PartitionedAnyReturnsFalse()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.Any<ReadTestsPartitionedDocument>(x => x.Id == Guid.NewGuid(), PartitionKey);
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public async Task PartitionedGetAllAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "GetAllAsyncContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = await SUT.GetAllAsync<ReadTestsPartitionedDocument>(x => x.SomeContent == "GetAllAsyncContent", PartitionKey);
+            // Assert
+            Assert.Equal(5, result.Count);
+        }
+
+        [Fact]
+        public void PartitionedGetAll()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "GetAllContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = SUT.GetAll<ReadTestsPartitionedDocument>(x => x.SomeContent == "GetAllContent", PartitionKey);
+            // Assert
+            Assert.Equal(5, result.Count);
+        }
+
+        [Fact]
+        public async Task PartitionedCountAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "CountAsyncContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = await SUT.CountAsync<ReadTestsPartitionedDocument>(x => x.SomeContent == "CountAsyncContent", PartitionKey);
+            // Assert
+            Assert.Equal(5, result);
+        }
+
+        [Fact]
+        public void PartitionedCount()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "CountContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = SUT.Count<ReadTestsPartitionedDocument>(x => x.SomeContent == "CountContent", PartitionKey);
+            // Assert
+            Assert.Equal(5, result);
+        }
+    }
+}

CoreIntegrationTests/ReadTests.cs

@@ -0,0 +1,181 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class ReadTestsDocument : Document
+    {
+        public ReadTestsDocument()
+        {
+            Version = 2;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class ReadTests : BaseMongoDbRepositoryTests<ReadTestsDocument>
+    {
+        [Fact]
+        public async Task GetByIdAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.GetByIdAsync<ReadTestsDocument>(document.Id);
+            // Assert
+            Assert.NotNull(result);
+        }
+
+        [Fact]
+        public void GetById()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.GetById<ReadTestsDocument>(document.Id);
+            // Assert
+            Assert.NotNull(result);
+        }
+
+        [Fact]
+        public async Task GetOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.GetOneAsync<ReadTestsDocument>(x => x.Id == document.Id);
+            // Assert
+            Assert.NotNull(result);
+        }
+
+        [Fact]
+        public void GetOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.GetOne<ReadTestsDocument>(x => x.Id == document.Id);
+            // Assert
+            Assert.NotNull(result);
+        }
+
+        [Fact]
+        public void GetCursor()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var cursor = SUT.GetCursor<ReadTestsDocument>(x => x.Id == document.Id);
+            var count = cursor.Count();
+            // Assert
+            Assert.Equal(1, count);
+        }
+
+        [Fact]
+        public async Task AnyAsyncReturnsTrue()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.AnyAsync<ReadTestsDocument>(x => x.Id == document.Id);
+            // Assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public async Task AnyAsyncReturnsFalse()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = await SUT.AnyAsync<ReadTestsDocument>(x => x.Id == Guid.NewGuid());
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void AnyReturnsTrue()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.Any<ReadTestsDocument>(x => x.Id == document.Id);
+            // Assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void AnyReturnsFalse()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var result = SUT.Any<ReadTestsDocument>(x => x.Id == Guid.NewGuid());
+            // Assert
+            Assert.False(result);
+        }
+
+        [Fact]
+        public async Task GetAllAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "GetAllAsyncContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = await SUT.GetAllAsync<ReadTestsDocument>(x => x.SomeContent == "GetAllAsyncContent");
+            // Assert
+            Assert.Equal(5, result.Count);
+        }
+
+        [Fact]
+        public void GetAll()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "GetAllContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = SUT.GetAll<ReadTestsDocument>(x => x.SomeContent == "GetAllContent");
+            // Assert
+            Assert.Equal(5, result.Count);
+        }
+
+        [Fact]
+        public async Task CountAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "CountAsyncContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = await SUT.CountAsync<ReadTestsDocument>(x => x.SomeContent == "CountAsyncContent");
+            // Assert
+            Assert.Equal(5, result);
+        }
+
+        [Fact]
+        public void Count()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "CountContent");
+            SUT.AddMany(documents);
+            // Act
+            var result = SUT.Count<ReadTestsDocument>(x => x.SomeContent == "CountContent");
+            // Assert
+            Assert.Equal(5, result);
+        }
+    }
+}

CoreIntegrationTests/UpdatePartitionedTests.cs

@@ -0,0 +1,51 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class UpdateTestsPartitionedDocument : PartitionedDocument
+    {
+        public UpdateTestsPartitionedDocument() : base("TestPartitionKey")
+        {
+            Version = 2;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class UpdatePartitionedTests : BaseMongoDbRepositoryTests<UpdateTestsPartitionedDocument>
+    {
+        [Fact]
+        public void PartitionedUpdateOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            document.SomeContent = "UpdateOneContent";
+            // Act
+            var result = SUT.UpdateOne(document);
+            // Assert
+            Assert.True(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, PartitionKey);
+            Assert.NotNull(updatedDocument);
+            Assert.Equal("UpdateOneContent", updatedDocument.SomeContent);
+        }
+
+        [Fact]
+        public async Task PartitionedUpdateOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            document.SomeContent = "UpdateOneAsyncContent";
+            // Act
+            var result = await SUT.UpdateOneAsync(document);
+            // Assert
+            Assert.True(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, PartitionKey);
+            Assert.NotNull(updatedDocument);
+            Assert.Equal("UpdateOneAsyncContent", updatedDocument.SomeContent);
+        }
+    }
+}

CoreIntegrationTests/UpdateTests.cs

@@ -0,0 +1,51 @@
+using CoreIntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using Xunit;
+using System.Threading.Tasks;
+
+namespace CoreIntegrationTests
+{
+    public class UpdateTestsDocument : Document
+    {
+        public UpdateTestsDocument()
+        {
+            Version = 2;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class UpdateTests : BaseMongoDbRepositoryTests<UpdateTestsDocument>
+    {
+        [Fact]
+        public void UpdateOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            document.SomeContent = "UpdateOneContent";
+            // Act
+            var result = SUT.UpdateOne(document);
+            // Assert
+            Assert.True(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.NotNull(updatedDocument);
+            Assert.Equal("UpdateOneContent", updatedDocument.SomeContent);
+        }
+
+        [Fact]
+        public async Task UpdateOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            document.SomeContent = "UpdateOneAsyncContent";
+            // Act
+            var result = await SUT.UpdateOneAsync(document);
+            // Assert
+            Assert.True(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.NotNull(updatedDocument);
+            Assert.Equal("UpdateOneAsyncContent", updatedDocument.SomeContent);
+        }
+    }
+}

IntegrationTests/CreateTKeyPartitionedTests.cs

@@ -0,0 +1,76 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+    public class CreateTestsPartitionedTKeyDocument : IDocument<Guid>, IPartitionedDocument
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public CreateTestsPartitionedTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+            PartitionKey = "TestPartitionKey";
+        }
+        public string PartitionKey { get; set; }
+        public string SomeContent { get; set; }
+    }
+
+    public class CreatePartitionedTKeyTests : BaseMongoDbRepositoryTests<CreateTestsPartitionedTKeyDocument>
+    {
+        [Test]
+        public void PartitionedAddOne()
+        {
+            // Arrange
+            var document = new CreateTestsPartitionedTKeyDocument();
+            // Act
+            SUT.AddOne<CreateTestsPartitionedTKeyDocument, Guid>(document);
+            // Assert
+            long count = SUT.Count<CreateTestsPartitionedTKeyDocument, Guid>(e => e.Id == document.Id, PartitionKey);
+            Assert.AreEqual(1, count);
+        }
+
+        [Test]
+        public async Task PartitionedAddOneAsync()
+        {
+            // Arrange
+            var document = new CreateTestsPartitionedTKeyDocument();
+            // Act
+            await SUT.AddOneAsync<CreateTestsPartitionedTKeyDocument, Guid>(document);
+            // Assert
+            long count = SUT.Count<CreateTestsPartitionedTKeyDocument, Guid>(e => e.Id == document.Id, PartitionKey);
+            Assert.AreEqual(1, count);
+        }
+
+        [Test]
+        public void PartitionedAddMany()
+        {
+            // Arrange
+            var documents = new List<CreateTestsPartitionedTKeyDocument> { new CreateTestsPartitionedTKeyDocument(), new CreateTestsPartitionedTKeyDocument() };
+            // Act
+            SUT.AddMany<CreateTestsPartitionedTKeyDocument, Guid>(documents);
+            // Assert
+            long count = SUT.Count<CreateTestsPartitionedTKeyDocument, Guid>(e => e.Id == documents[0].Id || e.Id == documents[1].Id, PartitionKey);
+            Assert.AreEqual(2, count);
+        }
+
+        [Test]
+        public async Task PartitionedAddManyAsync()
+        {
+            // Arrange
+            var documents = new List<CreateTestsPartitionedTKeyDocument> { new CreateTestsPartitionedTKeyDocument(), new CreateTestsPartitionedTKeyDocument() };
+            // Act
+            await SUT.AddManyAsync<CreateTestsPartitionedTKeyDocument, Guid>(documents);
+            // Assert
+            long count = SUT.Count<CreateTestsPartitionedTKeyDocument, Guid>(e => e.Id == documents[0].Id || e.Id == documents[1].Id, PartitionKey);
+            Assert.AreEqual(2, count);
+        }
+    }
+}

IntegrationTests/CreateTKeyTests.cs

@@ -0,0 +1,75 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+    public class CreateTestsTKeyDocument : IDocument<Guid>
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public CreateTestsTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    [TestFixture]
+    public class CreateTKeyTests : BaseMongoDbRepositoryTests<CreateTestsTKeyDocument>
+    {
+        [Test]
+        public void TKeyAddOne()
+        {
+            // Arrange
+            var document = new CreateTestsTKeyDocument();
+            // Act
+            SUT.AddOne<CreateTestsTKeyDocument, Guid>(document);
+            // Assert
+            long count = SUT.Count<CreateTestsTKeyDocument, Guid>(e => e.Id == document.Id);
+            Assert.AreEqual(1, count);
+        }
+
+        [Test]
+        public async Task TKeyAddOneAsync()
+        {
+            // Arrange
+            var document = new CreateTestsTKeyDocument();
+            // Act
+            await SUT.AddOneAsync<CreateTestsTKeyDocument, Guid>(document);
+            // Assert
+            long count = SUT.Count<CreateTestsTKeyDocument, Guid>(e => e.Id == document.Id);
+            Assert.AreEqual(1, count);
+        }
+
+        [Test]
+        public void TKeyAddMany()
+        {
+            // Arrange
+            var documents = new List<CreateTestsTKeyDocument> { new CreateTestsTKeyDocument(), new CreateTestsTKeyDocument() };
+            // Act
+            SUT.AddMany<CreateTestsTKeyDocument, Guid>(documents);
+            // Assert
+            long count = SUT.Count<CreateTestsTKeyDocument, Guid>(e => e.Id == documents[0].Id || e.Id == documents[1].Id);
+            Assert.AreEqual(2, count);
+        }
+
+        [Test]
+        public async Task TKeyAddManyAsync()
+        {
+            // Arrange
+            var documents = new List<CreateTestsTKeyDocument> { new CreateTestsTKeyDocument(), new CreateTestsTKeyDocument() };
+            // Act
+            await SUT.AddManyAsync<CreateTestsTKeyDocument, Guid>(documents);
+            // Assert
+            long count = SUT.Count<CreateTestsTKeyDocument, Guid>(e => e.Id == documents[0].Id || e.Id == documents[1].Id);
+            Assert.AreEqual(2, count);
+        }
+    }
+}

IntegrationTests/DeletePartitionedTKeyTests.cs

@@ -0,0 +1,137 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+    public class DeleteTestsPartitionedTKeyDocument : IPartitionedDocument, IDocument<Guid>
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public DeleteTestsPartitionedTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+            PartitionKey = "TestPartitionKey";
+        }
+        public string PartitionKey { get; set; }
+        public string SomeContent { get; set; }
+    }
+
+    public class DeletePartitionedTKeyTests : BaseMongoDbRepositoryTests<DeleteTestsPartitionedTKeyDocument>
+    {
+        [Test]
+        public void PartitionedDeleteOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<DeleteTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.DeleteOne<DeleteTestsPartitionedTKeyDocument, Guid>(document);
+            // Assert
+            Assert.AreEqual(1, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.Id == document.Id, PartitionKey));
+        }
+
+        [Test]
+        public void PartitionedDeleteOneLinq()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<DeleteTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.DeleteOne<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.AreEqual(1, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.Id == document.Id, PartitionKey));
+        }
+
+        [Test]
+        public async Task PartitionedDeleteOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<DeleteTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.DeleteOneAsync<DeleteTestsPartitionedTKeyDocument, Guid>(document);
+            // Assert
+            Assert.AreEqual(1, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.Id == document.Id, PartitionKey));
+        }
+
+        [Test]
+        public async Task PartitionedDeleteOneAsyncLinq()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<DeleteTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.DeleteOneAsync<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.AreEqual(1, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.Id == document.Id, PartitionKey));
+        }
+
+        [Test]
+        public async Task PartitionedDeleteManyAsyncLinq()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
+            SUT.AddMany<DeleteTestsPartitionedTKeyDocument, Guid>(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.SomeContent == "DeleteManyAsyncLinqContent", PartitionKey);
+            // Assert
+            Assert.AreEqual(5, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.SomeContent == "DeleteManyAsyncLinqContent", PartitionKey));
+        }
+
+        [Test]
+        public async Task PartitionedDeleteManyAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
+            SUT.AddMany<DeleteTestsPartitionedTKeyDocument, Guid>(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync<DeleteTestsPartitionedTKeyDocument, Guid>(documents);
+            // Assert
+            Assert.AreEqual(5, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.SomeContent == "DeleteManyAsyncLinqContent", PartitionKey));
+        }
+
+        [Test]
+        public void PartitionedDeleteManyLinq()
+        {
+            // Arrange
+            var content = "DeleteManyLinqContent";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = content);
+            SUT.AddMany<DeleteTestsPartitionedTKeyDocument, Guid>(documents);
+            // Act
+            var result = SUT.DeleteMany<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.SomeContent == content, PartitionKey);
+            // Assert
+            Assert.AreEqual(5, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.SomeContent == content, PartitionKey));
+        }
+
+        [Test]
+        public void PartitionedDeleteMany()
+        {
+            // Arrange
+            var content = "DeleteManyContent";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = content);
+            SUT.AddMany<DeleteTestsPartitionedTKeyDocument, Guid>(documents);
+            // Act
+            var result = SUT.DeleteMany<DeleteTestsPartitionedTKeyDocument, Guid>(documents);
+            // Assert
+            Assert.AreEqual(5, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsPartitionedTKeyDocument, Guid>(e => e.SomeContent == content, PartitionKey));
+        }
+    }
+}

IntegrationTests/DeleteTKeyTests.cs

@@ -0,0 +1,135 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+    public class DeleteTestsTKeyDocument : IDocument<Guid>
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public DeleteTestsTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    public class DeleteTKeyTests : BaseMongoDbRepositoryTests<DeleteTestsTKeyDocument>
+    {
+        [Test]
+        public void DeleteOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<DeleteTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.DeleteOne<DeleteTestsTKeyDocument, Guid>(document);
+            // Assert
+            Assert.AreEqual(1, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsTKeyDocument, Guid>(e => e.Id == document.Id));
+        }
+
+        [Test]
+        public void DeleteOneLinq()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<DeleteTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.DeleteOne<DeleteTestsTKeyDocument, Guid>(e => e.Id == document.Id);
+            // Assert
+            Assert.AreEqual(1, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsTKeyDocument, Guid>(e => e.Id == document.Id));
+        }
+
+        [Test]
+        public async Task DeleteOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<DeleteTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.DeleteOneAsync<DeleteTestsTKeyDocument, Guid>(document);
+            // Assert
+            Assert.AreEqual(1, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsTKeyDocument, Guid>(e => e.Id == document.Id));
+        }
+
+        [Test]
+        public async Task DeleteOneAsyncLinq()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<DeleteTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.DeleteOneAsync<DeleteTestsTKeyDocument, Guid>(e => e.Id == document.Id);
+            // Assert
+            Assert.AreEqual(1, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsTKeyDocument, Guid>(e => e.Id == document.Id));
+        }
+
+        [Test]
+        public async Task DeleteManyAsyncLinq()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
+            SUT.AddMany<DeleteTestsTKeyDocument, Guid>(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync<DeleteTestsTKeyDocument, Guid>(e => e.SomeContent == "DeleteManyAsyncLinqContent");
+            // Assert
+            Assert.AreEqual(5, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsTKeyDocument, Guid>(e => e.SomeContent == "DeleteManyAsyncLinqContent"));
+        }
+
+        [Test]
+        public async Task DeleteManyAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "DeleteManyAsyncLinqContent");
+            SUT.AddMany<DeleteTestsTKeyDocument, Guid>(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync<DeleteTestsTKeyDocument, Guid>(documents);
+            // Assert
+            Assert.AreEqual(5, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsTKeyDocument, Guid>(e => e.SomeContent == "DeleteManyAsyncLinqContent"));
+        }
+
+        [Test]
+        public void DeleteManyLinq()
+        {
+            // Arrange
+            var content = "DeleteManyLinqContent";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = content);
+            SUT.AddMany<DeleteTestsTKeyDocument, Guid>(documents);
+            // Act
+            var result = SUT.DeleteMany<DeleteTestsTKeyDocument, Guid>(e => e.SomeContent == content);
+            // Assert
+            Assert.AreEqual(5, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsTKeyDocument, Guid>(e => e.SomeContent == content));
+        }
+
+        [Test]
+        public void DeleteMany()
+        {
+            // Arrange
+            var content = "DeleteManyContent";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = content);
+            SUT.AddMany<DeleteTestsTKeyDocument, Guid>(documents);
+            // Act
+            var result = SUT.DeleteMany<DeleteTestsTKeyDocument, Guid>(documents);
+            // Assert
+            Assert.AreEqual(5, result);
+            Assert.IsFalse(SUT.Any<DeleteTestsTKeyDocument, Guid>(e => e.SomeContent == content));
+        }
+    }
+}

IntegrationTests/GroupTests/GroupingTests.cs

@@ -0,0 +1,108 @@
+using IntegrationTests.Infrastructure;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace IntegrationTests.GroupTests
+{
+    public class GroupingTestsDocument : Document
+    {
+        public GroupingTestsDocument()
+        {
+            Version = 2;
+            Children = new List<Child>();
+        }
+        public string SomeContent { get; set; }
+        public int GroupingKey { get; set; }
+        public List<Child> Children { get; set; }
+    }
+
+    public class ProjectedGroup
+    {
+        public int Key { get; set; }
+        public List<string> Content { get; set; } 
+    }
+
+    public class GroupingTests : BaseMongoDbRepositoryTests<GroupingTestsDocument>
+    {
+        [Test]
+        public void GroupByTProjection()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            for(var i = 0; i < documents.Count - 2; i++)
+            {
+                documents[i].GroupingKey = 1;
+                documents[i].SomeContent = $"content-{i}";
+            }
+            for (var i = 3; i < documents.Count; i++)
+            {
+                documents[i].GroupingKey = 2;
+                documents[i].SomeContent = $"content-{i}";
+            }
+            SUT.AddMany(documents);
+
+            // Act
+
+            var result = SUT.GroupBy<GroupingTestsDocument, int, ProjectedGroup>(
+                            e => e.GroupingKey, g => new ProjectedGroup {
+                                Key = g.Key,
+                                Content = g.Select(doc => doc.SomeContent).ToList()
+                            });
+
+            // Assert
+            var key1Group = result.First(e => e.Key == 1);
+            Assert.NotNull(key1Group);
+            Assert.AreEqual(3, key1Group.Content.Count);
+            var key2Group = result.First(e => e.Key == 2);
+            Assert.NotNull(key2Group);
+            Assert.AreEqual(2, key2Group.Content.Count);
+        }
+
+        [Test]
+        public void FilteredGroupByTProjection()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            for (var i = 0; i < documents.Count - 2; i++)
+            {
+                documents[i].GroupingKey = 4;
+                documents[i].SomeContent = $"content-{i}";
+            }
+            for (var i = 3; i < documents.Count; i++)
+            {
+                documents[i].GroupingKey = 5;
+                documents[i].SomeContent = $"content-{i}";
+            }
+            var guid1 = Guid.NewGuid().ToString("n");
+            var guid2 = Guid.NewGuid().ToString("n");
+            for (var i = 0; i < documents.Count - 1; i++)
+            {
+                documents[i].Children = new List<Child> {
+                    new Child(guid1, guid2)
+                };
+            }
+
+            SUT.AddMany(documents);
+
+            // Act
+            var result = SUT.GroupBy<GroupingTestsDocument, int, ProjectedGroup>(
+                            e => e.Children.Any(c => c.Type == guid1),
+                            e => e.GroupingKey, g => new ProjectedGroup
+                            {
+                                Key = g.Key,
+                                Content = g.Select(doc => doc.SomeContent).ToList()
+                            });
+
+            // Assert
+            var key1Group = result.First(e => e.Key == 4);
+            Assert.NotNull(key1Group);
+            Assert.AreEqual(3, key1Group.Content.Count);
+            var key2Group = result.First(e => e.Key == 5);
+            Assert.NotNull(key2Group);
+            Assert.AreEqual(1, key2Group.Content.Count);
+        }
+    }
+}

IntegrationTests/Infrastructure/BaseMongoDbRepositoryTests.cs

@@ -5,7 +5,7 @@ using System.Configuration;
 
 namespace IntegrationTests.Infrastructure
 {
-    public class BaseMongoDbRepositoryTests<T> where T : Document, new()
+    public class BaseMongoDbRepositoryTests<T> where T : class, new()
     {
         public T CreateTestDocument()
         {

IntegrationTests/Infrastructure/Child.cs

@@ -0,0 +1,14 @@
+namespace IntegrationTests.Infrastructure
+{
+    public class Child
+    {
+        public Child(string type, string value)
+        {
+            Type = type;
+            Value = value;
+        }
+
+        public string Type { get; set; }
+        public string Value { get; set; }
+    }
+}

IntegrationTests/Infrastructure/TestRepository.cs

@@ -11,12 +11,12 @@ namespace IntegrationTests.Infrastructure
 
         public void DropTestCollection<TDocument>()
         {
-            _mongoDbContext.DropCollection<TDocument>();
+            MongoDbContext.DropCollection<TDocument>();
         }
 
         public void DropTestCollection<TDocument>(string partitionKey)
         {
-            _mongoDbContext.DropCollection<TDocument>(partitionKey);
+            MongoDbContext.DropCollection<TDocument>(partitionKey);
         }
     }
 }

IntegrationTests/IntegrationTests.csproj

@@ -45,30 +45,38 @@
     <Reference Include="System" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
+    <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Runtime.InteropServices.RuntimeInformation, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Runtime.InteropServices.RuntimeInformation.4.3.0\lib\net45\System.Runtime.InteropServices.RuntimeInformation.dll</HintPath>
+      <Private>True</Private>
     </Reference>
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CreateTKeyPartitionedTests.cs" />
+    <Compile Include="CreateTKeyTests.cs" />
+    <Compile Include="DeletePartitionedTKeyTests.cs" />
     <Compile Include="DeletePartitionedTests.cs" />
+    <Compile Include="DeleteTKeyTests.cs" />
     <Compile Include="DeleteTests.cs" />
+    <Compile Include="GroupTests\GroupingTests.cs" />
     <Compile Include="Infrastructure\BaseMongoDbRepositoryTests.cs" />
     <Compile Include="CreatePartitionedTests.cs" />
+    <Compile Include="Infrastructure\Child.cs" />
     <Compile Include="Infrastructure\ITestRepository.cs" />
     <Compile Include="Infrastructure\TestRepository.cs" />
     <Compile Include="CreateTests.cs" />
+    <Compile Include="ProjectPartitionedTKeyTests.cs" />
     <Compile Include="ProjectPartitionedTests.cs" />
+    <Compile Include="ProjectTKeyTests.cs" />
     <Compile Include="ProjectTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ReadPartitionedTKeyTests.cs" />
     <Compile Include="ReadPartitionedTests.cs" />
+    <Compile Include="ReadTKeyTests.cs" />
     <Compile Include="ReadTests.cs" />
+    <Compile Include="UpdatePartitionedTKeyTests.cs" />
     <Compile Include="UpdatePartitionedTests.cs" />
+    <Compile Include="UpdateTKeyTests.cs" />
     <Compile Include="UpdateTests.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -77,14 +85,14 @@
     </None>
     <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\MongoDbGenericRepository\MongoDbGenericRepository.csproj">
-      <Project>{d154e7d0-9a3c-43ab-8e90-ed92bc4343f0}</Project>
+      <Project>{efc776c4-2af3-440c-be80-3fbe335817a5}</Project>
       <Name>MongoDbGenericRepository</Name>
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

IntegrationTests/ProjectPartitionedTKeyTests.cs

@@ -0,0 +1,143 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+
+    public class ProjectTestsPartitionedTKeyDocument : IDocument<Guid>, IPartitionedDocument
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public ProjectTestsPartitionedTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+            PartitionKey = "TestPartitionKey";
+            Nested = new NestedTKey();
+        }
+        public string PartitionKey { get; set; }
+        public NestedTKey Nested { get; set; }
+        public string SomeContent { get; set; }
+    }
+
+    public class ProjectPartitionedTKeyTests : BaseMongoDbRepositoryTests<ProjectTestsPartitionedTKeyDocument>
+    {
+        [Test]
+        public async Task PartitionedProjectOneAsync()
+        {
+            // Arrange
+            const string someContent = "ProjectOneAsyncContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<ProjectTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.ProjectOneAsync<ProjectTestsPartitionedTKeyDocument, MyProjection, Guid>(
+                x => x.Id == document.Id,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                PartitionKey);
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.AreEqual(someContent, result.SomeContent);
+            Assert.AreEqual(someDate.Minute, result.SomeDate.Minute);
+            Assert.AreEqual(someDate.Second, result.SomeDate.Second);
+        }
+
+        [Test]
+        public void PartitionedProjectOne()
+        {
+            // Arrange
+            const string someContent = "ProjectOneContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<ProjectTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.ProjectOne<ProjectTestsPartitionedTKeyDocument, MyProjection, Guid>(
+                x => x.Id == document.Id,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                PartitionKey);
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.AreEqual(someContent, result.SomeContent);
+            Assert.AreEqual(someDate.Minute, result.SomeDate.Minute);
+            Assert.AreEqual(someDate.Second, result.SomeDate.Second);
+        }
+
+        [Test]
+        public async Task PartitionedProjectManyAsync()
+        {
+            // Arrange
+            const string someContent = "ProjectManyAsyncContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocuments(5);
+            document.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<ProjectTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.ProjectManyAsync<ProjectTestsPartitionedTKeyDocument, MyProjection, Guid>(
+                x => x.SomeContent == someContent,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                PartitionKey);
+            // Assert
+            Assert.AreEqual(5, result.Count);
+            Assert.AreEqual(someContent, result.First().SomeContent);
+            Assert.AreEqual(someDate.Minute, result.First().SomeDate.Minute);
+            Assert.AreEqual(someDate.Second, result.First().SomeDate.Second);
+        }
+
+        [Test]
+        public void PartitionedProjectMany()
+        {
+            // Arrange
+            const string someContent = "ProjectManyContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocuments(5);
+            document.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<ProjectTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.ProjectMany<ProjectTestsPartitionedTKeyDocument, MyProjection, Guid>(
+                x => x.SomeContent == someContent,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                PartitionKey);
+            // Assert
+            Assert.AreEqual(5, result.Count);
+            Assert.AreEqual(someContent, result.First().SomeContent);
+            Assert.AreEqual(someDate.Minute, result.First().SomeDate.Minute);
+            Assert.AreEqual(someDate.Second, result.First().SomeDate.Second);
+        }
+    }
+}

IntegrationTests/ProjectTKeyTests.cs

@@ -0,0 +1,150 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+    public class NestedTKey
+    {
+        public DateTime SomeDate { get; set; }
+    }
+
+    public class MyProjectionTKey
+    {
+        public DateTime SomeDate { get; set; }
+        public string SomeContent { get; set; }
+    }
+
+    public class ProjectTestsTKeyDocument : IDocument<Guid>
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public ProjectTestsTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+            Nested = new NestedTKey
+            {
+                SomeDate = DateTime.UtcNow
+            };
+        }
+        public string SomeContent { get; set; }
+        public NestedTKey Nested { get; set; }
+    }
+
+    public class ProjectTKeyTests : BaseMongoDbRepositoryTests<ProjectTestsTKeyDocument>
+    {
+        [Test]
+        public async Task ProjectOneAsync()
+        {
+            // Arrange
+            const string someContent = "ProjectOneAsyncContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<ProjectTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.ProjectOneAsync<ProjectTestsTKeyDocument, MyProjection, Guid>(
+                x => x.Id == document.Id, 
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                });
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.AreEqual(someContent, result.SomeContent);
+            Assert.AreEqual(someDate.Minute, result.SomeDate.Minute);
+            Assert.AreEqual(someDate.Second, result.SomeDate.Second);
+        }
+
+        [Test]
+        public void ProjectOne()
+        {
+            // Arrange
+            const string someContent = "ProjectOneContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<ProjectTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.ProjectOne<ProjectTestsTKeyDocument, MyProjection, Guid>(
+                x => x.Id == document.Id,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                });
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.AreEqual(someContent, result.SomeContent);
+            Assert.AreEqual(someDate.Minute, result.SomeDate.Minute);
+            Assert.AreEqual(someDate.Second, result.SomeDate.Second);
+        }
+
+        [Test]
+        public async Task ProjectManyAsync()
+        {
+            // Arrange
+            const string someContent = "ProjectManyAsyncContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocuments(5);
+            document.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<ProjectTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.ProjectManyAsync<ProjectTestsTKeyDocument, MyProjection, Guid>(
+                x => x.SomeContent == someContent,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                });
+            // Assert
+            Assert.AreEqual(5, result.Count);
+            Assert.AreEqual(someContent, result.First().SomeContent);
+            Assert.AreEqual(someDate.Minute, result.First().SomeDate.Minute);
+            Assert.AreEqual(someDate.Second, result.First().SomeDate.Second);
+        }
+
+        [Test]
+        public void ProjectMany()
+        {
+            // Arrange
+            const string someContent = "ProjectManyContent";
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocuments(5);
+            document.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<ProjectTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.ProjectMany<ProjectTestsTKeyDocument, MyProjection, Guid>(
+                x => x.SomeContent == someContent,
+                x => new MyProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                });
+            // Assert
+            Assert.AreEqual(5, result.Count);
+            Assert.AreEqual(someContent, result.First().SomeContent);
+            Assert.AreEqual(someDate.Minute, result.First().SomeDate.Minute);
+            Assert.AreEqual(someDate.Second, result.First().SomeDate.Second);
+        }
+    }
+}

IntegrationTests/ReadPartitionedTKeyTests.cs

@@ -0,0 +1,189 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+    public class ReadTestsPartitionedTKeyDocument : IDocument<Guid>, IPartitionedDocument
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public ReadTestsPartitionedTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+            PartitionKey = "TestPartitionKey";
+        }
+        public string PartitionKey { get; set; }
+        public string SomeContent { get; set; }
+    }
+
+    [TestFixture]
+    public class ReadPartitionedTKeyTests : BaseMongoDbRepositoryTests<ReadTestsPartitionedTKeyDocument>
+    {
+        [Test]
+        public async Task PartitionedGetByIdAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.GetByIdAsync<ReadTestsPartitionedTKeyDocument, Guid>(document.Id, PartitionKey);
+            // Assert
+            Assert.IsNotNull(result);
+        }
+
+        [Test]
+        public void PartitionedGetById()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.GetById<ReadTestsPartitionedTKeyDocument, Guid>(document.Id, PartitionKey);
+            // Assert
+            Assert.IsNotNull(result);
+        }
+
+        [Test]
+        public async Task PartitionedGetOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.GetOneAsync<ReadTestsPartitionedTKeyDocument, Guid>(x => x.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.IsNotNull(result);
+        }
+
+        [Test]
+        public void PartitionedGetOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.GetOne<ReadTestsPartitionedTKeyDocument, Guid>(x => x.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.IsNotNull(result);
+        }
+
+        [Test]
+        public void PartitionedGetCursor()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var cursor = SUT.GetCursor<ReadTestsPartitionedTKeyDocument, Guid>(x => x.Id == document.Id, PartitionKey);
+            var count = cursor.Count();
+            // Assert
+            Assert.AreEqual(1, count);
+        }
+
+        [Test]
+        public async Task PartitionedAnyAsyncReturnsTrue()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.AnyAsync<ReadTestsPartitionedTKeyDocument, Guid>(x => x.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.AreEqual(true, result);
+        }
+
+        [Test]
+        public async Task PartitionedAnyAsyncReturnsFalse()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.AnyAsync<ReadTestsPartitionedTKeyDocument, Guid>(x => x.Id == Guid.NewGuid(), PartitionKey);
+            // Assert
+            Assert.AreEqual(false, result);
+        }
+
+        [Test]
+        public void PartitionedAnyReturnsTrue()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.Any<ReadTestsPartitionedTKeyDocument, Guid>(x => x.Id == document.Id, PartitionKey);
+            // Assert
+            Assert.AreEqual(true, result);
+        }
+
+        [Test]
+        public void PartitionedAnyReturnsFalse()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsPartitionedTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.Any<ReadTestsPartitionedTKeyDocument, Guid>(x => x.Id == Guid.NewGuid(), PartitionKey);
+            // Assert
+            Assert.AreEqual(false, result);
+        }
+
+        [Test]
+        public async Task PartitionedGetAllAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "GetAllAsyncContent");
+            SUT.AddMany<ReadTestsPartitionedTKeyDocument, Guid>(documents);
+            // Act
+            var result = await SUT.GetAllAsync<ReadTestsPartitionedTKeyDocument, Guid>(x => x.SomeContent == "GetAllAsyncContent", PartitionKey);
+            // Assert
+            Assert.AreEqual(5, result.Count);
+        }
+
+        [Test]
+        public void PartitionedGetAll()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "GetAllContent");
+            SUT.AddMany<ReadTestsPartitionedTKeyDocument, Guid>(documents);
+            // Act
+            var result = SUT.GetAll<ReadTestsPartitionedTKeyDocument, Guid>(x => x.SomeContent == "GetAllContent", PartitionKey);
+            // Assert
+            Assert.AreEqual(5, result.Count);
+        }
+
+        [Test]
+        public async Task PartitionedCountAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "CountAsyncContent");
+            SUT.AddMany<ReadTestsPartitionedTKeyDocument, Guid>(documents);
+            // Act
+            var result = await SUT.CountAsync<ReadTestsPartitionedTKeyDocument, Guid>(x => x.SomeContent == "CountAsyncContent", PartitionKey);
+            // Assert
+            Assert.AreEqual(5, result);
+        }
+
+        [Test]
+        public void PartitionedCount()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "CountContent");
+            SUT.AddMany<ReadTestsPartitionedTKeyDocument, Guid>(documents);
+            // Act
+            var result = SUT.Count<ReadTestsPartitionedTKeyDocument, Guid>(x => x.SomeContent == "CountContent", PartitionKey);
+            // Assert
+            Assert.AreEqual(5, result);
+        }
+    }
+}

IntegrationTests/ReadTKeyTests.cs

@@ -0,0 +1,187 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+    public class ReadTestsTKeyDocument : IDocument<Guid>
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public ReadTestsTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+        }
+        public string SomeContent { get; set; }
+    }
+
+    [TestFixture]
+    public class ReadTKeyTests : BaseMongoDbRepositoryTests<ReadTestsTKeyDocument>
+    {
+        [Test]
+        public async Task GetByIdAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.GetByIdAsync<ReadTestsTKeyDocument, Guid>(document.Id);
+            // Assert
+            Assert.IsNotNull(result);
+        }
+
+        [Test]
+        public void GetById()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.GetById<ReadTestsTKeyDocument, Guid>(document.Id);
+            // Assert
+            Assert.IsNotNull(result);
+        }
+
+        [Test]
+        public async Task GetOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.GetOneAsync<ReadTestsTKeyDocument, Guid>(x => x.Id == document.Id);
+            // Assert
+            Assert.IsNotNull(result);
+        }
+
+        [Test]
+        public void GetOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.GetOne<ReadTestsTKeyDocument, Guid>(x => x.Id == document.Id);
+            // Assert
+            Assert.IsNotNull(result);
+        }
+
+        [Test]
+        public void GetCursor()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsTKeyDocument, Guid>(document);
+            // Act
+            var cursor = SUT.GetCursor<ReadTestsTKeyDocument, Guid>(x => x.Id == document.Id);
+            var count = cursor.Count();
+            // Assert
+            Assert.AreEqual(1, count);
+        }
+
+        [Test]
+        public async Task AnyAsyncReturnsTrue()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.AnyAsync<ReadTestsTKeyDocument, Guid>(x => x.Id == document.Id);
+            // Assert
+            Assert.AreEqual(true, result);
+        }
+
+        [Test]
+        public async Task AnyAsyncReturnsFalse()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = await SUT.AnyAsync<ReadTestsTKeyDocument, Guid>(x => x.Id == Guid.NewGuid());
+            // Assert
+            Assert.AreEqual(false, result);
+        }
+
+        [Test]
+        public void AnyReturnsTrue()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.Any<ReadTestsTKeyDocument, Guid>(x => x.Id == document.Id);
+            // Assert
+            Assert.AreEqual(true, result);
+        }
+
+        [Test]
+        public void AnyReturnsFalse()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<ReadTestsTKeyDocument, Guid>(document);
+            // Act
+            var result = SUT.Any<ReadTestsTKeyDocument, Guid>(x => x.Id == Guid.NewGuid());
+            // Assert
+            Assert.AreEqual(false, result);
+        }
+
+        [Test]
+        public async Task GetAllAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "GetAllAsyncContent");
+            SUT.AddMany<ReadTestsTKeyDocument, Guid>(documents);
+            // Act
+            var result = await SUT.GetAllAsync<ReadTestsTKeyDocument, Guid>(x => x.SomeContent == "GetAllAsyncContent");
+            // Assert
+            Assert.AreEqual(5, result.Count);
+        }
+
+        [Test]
+        public void GetAll()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "GetAllContent");
+            SUT.AddMany<ReadTestsTKeyDocument, Guid>(documents);
+            // Act
+            var result = SUT.GetAll<ReadTestsTKeyDocument, Guid>(x => x.SomeContent == "GetAllContent");
+            // Assert
+            Assert.AreEqual(5, result.Count);
+        }
+
+        [Test]
+        public async Task CountAsync()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "CountAsyncContent");
+            SUT.AddMany<ReadTestsTKeyDocument, Guid>(documents);
+            // Act
+            var result = await SUT.CountAsync<ReadTestsTKeyDocument, Guid>(x => x.SomeContent == "CountAsyncContent");
+            // Assert
+            Assert.AreEqual(5, result);
+        }
+
+        [Test]
+        public void Count()
+        {
+            // Arrange
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = "CountContent");
+            SUT.AddMany<ReadTestsTKeyDocument, Guid>(documents);
+            // Act
+            var result = SUT.Count<ReadTestsTKeyDocument, Guid>(x => x.SomeContent == "CountContent");
+            // Assert
+            Assert.AreEqual(5, result);
+        }
+    }
+}

IntegrationTests/UpdatePartitionedTKeyTests.cs

@@ -0,0 +1,117 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Driver;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+
+    public class UpdateTestsPartitionedTKeyDocument : IDocument<Guid>, IPartitionedDocument
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public UpdateTestsPartitionedTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+            PartitionKey = "TestPartitionKey";
+            Children = new List<Child>();
+        }
+        public string PartitionKey { get; set; }
+        public string SomeContent { get; set; }
+        public List<Child> Children { get; set; }
+    }
+
+    [TestFixture]
+    public class UpdatePartitionedTKeyTests : BaseMongoDbRepositoryTests<UpdateTestsPartitionedTKeyDocument>
+    {
+        [Test]
+        public void PartitionedUpdateOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedTKeyDocument, Guid>(document);
+            document.SomeContent = "UpdateOneContent";
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsPartitionedTKeyDocument, Guid>(document);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedTKeyDocument, Guid>(document.Id, PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual("UpdateOneContent", updatedDocument.SomeContent);
+        }
+
+        [Test]
+        public async Task PartitionedUpdateOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedTKeyDocument, Guid>(document);
+            document.SomeContent = "UpdateOneAsyncContent";
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsPartitionedTKeyDocument, Guid>(document);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedTKeyDocument, Guid>(document.Id, PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual("UpdateOneAsyncContent", updatedDocument.SomeContent);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedTKeyDocument, Guid>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsPartitionedTKeyDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsPartitionedTKeyDocument, Guid>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedTKeyDocument, Guid>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedTKeyDocument, Guid>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsPartitionedTKeyDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsPartitionedTKeyDocument, Guid>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedTKeyDocument, Guid>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+    }
+}

IntegrationTests/UpdatePartitionedTests.cs

@@ -1,6 +1,8 @@
 using IntegrationTests.Infrastructure;
+using MongoDB.Driver;
 using MongoDbGenericRepository.Models;
 using NUnit.Framework;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace IntegrationTests
@@ -10,8 +12,10 @@ namespace IntegrationTests
         public UpdateTestsPartitionedDocument() : base("TestPartitionKey")
         {
             Version = 2;
+            Children = new List<Child>();
         }
         public string SomeContent { get; set; }
+        public List<Child> Children { get; set; }
     }
 
     public class UpdatePartitionedTests : BaseMongoDbRepositoryTests<UpdateTestsPartitionedDocument>
@@ -47,5 +51,155 @@ namespace IntegrationTests
             Assert.IsNotNull(updatedDocument);
             Assert.AreEqual("UpdateOneAsyncContent", updatedDocument.SomeContent);
         }
+
+        [Test]
+        public async Task UpdateOneAsyncWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedDocument>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsPartitionedDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsPartitionedDocument>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsPartitionedDocument>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsPartitionedDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsPartitionedDocument>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var result = SUT.UpdateOne(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var result = await SUT.UpdateOneAsync(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var filter = Builders<UpdateTestsPartitionedDocument>.Filter.Eq("Id", document.Id);
+            var result = SUT.UpdateOne(filter, x => x.Children, childrenToAdd, document.PartitionKey);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var filter = Builders<UpdateTestsPartitionedDocument>.Filter.Eq("Id", document.Id);
+            var result = await SUT.UpdateOneAsync(filter, x => x.Children, childrenToAdd, document.PartitionKey);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsPartitionedDocument>(document.Id, document.PartitionKey);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
     }
 }

IntegrationTests/UpdateTKeyTests.cs

@@ -0,0 +1,195 @@
+using IntegrationTests.Infrastructure;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Driver;
+using MongoDbGenericRepository.Models;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace IntegrationTests
+{
+
+    public class UpdateTestsTKeyDocument : IDocument<Guid>
+    {
+        [BsonId]
+        public Guid Id { get; set; }
+        public int Version { get; set; }
+        public UpdateTestsTKeyDocument()
+        {
+            Id = Guid.NewGuid();
+            Version = 2;
+            Children = new List<Child>();
+        }
+        public string SomeContent { get; set; }
+        public List<Child> Children { get; set; }
+    }
+
+    [TestFixture]
+    public class UpdateTKeyTests : BaseMongoDbRepositoryTests<UpdateTestsTKeyDocument>
+    {
+        [Test]
+        public void UpdateOne()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+            document.SomeContent = "UpdateOneContent";
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsTKeyDocument, Guid>(document);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual("UpdateOneContent", updatedDocument.SomeContent);
+        }
+
+        [Test]
+        public async Task UpdateOneAsync()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+            document.SomeContent = "UpdateOneAsyncContent";
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsTKeyDocument, Guid>(document);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual("UpdateOneAsyncContent", updatedDocument.SomeContent);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsTKeyDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsTKeyDocument, Guid>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsTKeyDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsTKeyDocument, Guid>(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var filter = Builders<UpdateTestsTKeyDocument>.Filter.Eq("Id", document.Id);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsTKeyDocument, Guid, List<Child>>(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var filter = Builders<UpdateTestsTKeyDocument>.Filter.Eq("Id", document.Id);
+
+            // Act
+            var result = await SUT.UpdateOneAsync<UpdateTestsTKeyDocument, Guid, List<Child>>(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<UpdateTestsTKeyDocument, Guid>(document);
+
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var filter = Builders<UpdateTestsTKeyDocument>.Filter.Eq("Id", document.Id);
+
+            // Act
+            var result = SUT.UpdateOne<UpdateTestsTKeyDocument, Guid, List<Child>>(filter, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsTKeyDocument, Guid>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+    }
+}

IntegrationTests/UpdateTests.cs

@@ -1,6 +1,8 @@
 using IntegrationTests.Infrastructure;
+using MongoDB.Driver;
 using MongoDbGenericRepository.Models;
 using NUnit.Framework;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace IntegrationTests
@@ -10,8 +12,10 @@ namespace IntegrationTests
         public UpdateTestsDocument()
         {
             Version = 2;
+            Children = new List<Child>();
         }
         public string SomeContent { get; set; }
+        public List<Child> Children { get; set; }
     }
 
     public class UpdateTests : BaseMongoDbRepositoryTests<UpdateTestsDocument>
@@ -47,5 +51,155 @@ namespace IntegrationTests
             Assert.IsNotNull(updatedDocument);
             Assert.AreEqual("UpdateOneAsyncContent", updatedDocument.SomeContent);
         }
+
+        [Test]
+        public async Task UpdateOneAsyncWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = await SUT.UpdateOneAsync(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithUpdateDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            var updateDef = Builders<UpdateTestsDocument>.Update.AddToSetEach(p => p.Children, childrenToAdd);
+
+            // Act
+            var result = SUT.UpdateOne(document, updateDef);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var result = SUT.UpdateOne(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var result = await SUT.UpdateOneAsync(document, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public void UpdateOneWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var filter = Builders<UpdateTestsDocument>.Filter.Eq("Id", document.Id);
+            var result = SUT.UpdateOne(filter, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
+
+        [Test]
+        public async Task UpdateOneAsyncWithFilterAndFieldSelector()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            var childrenToAdd = new List<Child>
+            {
+                new Child("testType1", "testValue1"),
+                new Child("testType2", "testValue2")
+            };
+
+            // Act
+            var filter = Builders<UpdateTestsDocument>.Filter.Eq("Id", document.Id);
+            var result = await SUT.UpdateOneAsync(filter, x => x.Children, childrenToAdd);
+            // Assert
+            Assert.IsTrue(result);
+            var updatedDocument = SUT.GetById<UpdateTestsDocument>(document.Id);
+            Assert.IsNotNull(updatedDocument);
+            Assert.AreEqual(childrenToAdd[0].Type, updatedDocument.Children[0].Type);
+            Assert.AreEqual(childrenToAdd[0].Value, updatedDocument.Children[0].Value);
+            Assert.AreEqual(childrenToAdd[1].Type, updatedDocument.Children[1].Type);
+            Assert.AreEqual(childrenToAdd[1].Value, updatedDocument.Children[1].Value);
+        }
     }
 }

IntegrationTests/bin/Debug/ApplicationInsights.config

@@ -1,3 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<ApplicationInsights xmlns="http://schemas.microsoft.com/ApplicationInsights/2013/Settings">
-</ApplicationInsights>

IntegrationTests/bin/Debug/IntegrationTests.dll.config

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  For more information on how to configure your ASP.NET application, please visit
-  http://go.microsoft.com/fwlink/?LinkId=169433
-  -->
-<configuration>
-  <connectionStrings>
-    <add name="MongoDbTests" connectionString="mongodb://localhost:27017" />
-  </connectionStrings>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="System.Runtime.InteropServices.RuntimeInformation" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-4.0.1.0" newVersion="4.0.1.0" />
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
-</configuration>

IntegrationTests/bin/Debug/MongoDbGenericRepository.dll.config

@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  For more information on how to configure your ASP.NET application, please visit
-  http://go.microsoft.com/fwlink/?LinkId=169433
-  -->
-<configuration>
-  <system.web>
-    <compilation debug="true" targetFramework="4.5.2" />
-    <httpRuntime targetFramework="4.5.2" />
-    <httpModules>
-    </httpModules>
-  </system.web>
-  <system.webServer>
-    <validation validateIntegratedModeConfiguration="false" />
-    <modules>
-    </modules>
-  </system.webServer>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="System.Runtime.InteropServices.RuntimeInformation" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-4.0.1.0" newVersion="4.0.1.0" />
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
-  <system.codedom>
-    <compilers>
-      <compiler language="c#;cs;csharp" extension=".cs" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.7.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:6 /nowarn:1659;1699;1701" />
-      <compiler language="vb;vbs;visualbasic;vbscript" extension=".vb" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.7.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:14 /nowarn:41008 /define:_MYTYPE=\&quot;Web\&quot; /optionInfer+" />
-    </compilers>
-  </system.codedom>
-</configuration>

IntegrationTests/bin/Microsoft.CodeDom.Providers.DotNetCompilerPlatform.xml

@@ -1,40 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>Microsoft.CodeDom.Providers.DotNetCompilerPlatform</name>
-    </assembly>
-    <members>
-        <member name="T:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider">
-            <summary>
-            Provides access to instances of the .NET Compiler Platform C# code generator and code compiler.
-            </summary>
-        </member>
-        <member name="M:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider.#ctor">
-            <summary>
-            Default Constructor
-            </summary>
-        </member>
-        <member name="M:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider.CreateCompiler">
-            <summary>
-            Gets an instance of the .NET Compiler Platform C# code compiler.
-            </summary>
-            <returns>An instance of the .NET Compiler Platform C# code compiler</returns>
-        </member>
-        <member name="T:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider">
-            <summary>
-            Provides access to instances of the .NET Compiler Platform VB code generator and code compiler.
-            </summary>
-        </member>
-        <member name="M:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider.#ctor">
-            <summary>
-            Default Constructor
-            </summary>
-        </member>
-        <member name="M:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider.CreateCompiler">
-            <summary>
-            Gets an instance of the .NET Compiler Platform VB code compiler.
-            </summary>
-            <returns>An instance of the .NET Compiler Platform VB code compiler</returns>
-        </member>
-    </members>
-</doc>

IntegrationTests/obj/Debug/IntegrationTests.csproj.FileListAbsolute.txt

@@ -1,19 +0,0 @@
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\ApplicationInsights.config
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\IntegrationTests.dll.config
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\IntegrationTests.dll
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\IntegrationTests.pdb
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\MongoDbGenericRepository.dll
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\nunit.framework.dll
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\MongoDB.Driver.dll
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\MongoDB.Bson.dll
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\MongoDB.Driver.Core.dll
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\MongoDbGenericRepository.pdb
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\MongoDbGenericRepository.dll.config
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\nunit.framework.xml
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\MongoDB.Driver.xml
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\MongoDB.Bson.xml
-C:\dev\MongoDbRepoUpdate\IntegrationTests\obj\Debug\IntegrationTests.csprojResolveAssemblyReference.cache
-C:\dev\MongoDbRepoUpdate\IntegrationTests\obj\Debug\IntegrationTests.dll
-C:\dev\MongoDbRepoUpdate\IntegrationTests\obj\Debug\IntegrationTests.pdb
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\System.Runtime.InteropServices.RuntimeInformation.dll
-C:\dev\MongoDbRepoUpdate\IntegrationTests\bin\Debug\MongoDB.Driver.Core.xml

IntegrationTests/packages.config

@@ -5,5 +5,6 @@
   <package id="MongoDB.Driver.Core" version="2.4.4" targetFramework="net461" />
   <package id="NUnit" version="3.7.1" targetFramework="net461" />
   <package id="NUnit.ConsoleRunner" version="3.7.0" targetFramework="net461" />
+  <package id="System.Runtime.InteropServices" version="4.3.0" targetFramework="net461" />
   <package id="System.Runtime.InteropServices.RuntimeInformation" version="4.3.0" targetFramework="net461" />
 </packages>

MongoDbGenericRepository.sln

@@ -1,28 +1,37 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26430.16
+VisualStudioVersion = 15.0.26730.12
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MongoDbGenericRepository", "MongoDbGenericRepository\MongoDbGenericRepository.csproj", "{D154E7D0-9A3C-43AB-8E90-ED92BC4343F0}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IntegrationTests", "IntegrationTests\IntegrationTests.csproj", "{A484A355-A015-40CC-9B35-A4E872421128}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MongoDbGenericRepository", "MongoDbGenericRepository\MongoDbGenericRepository.csproj", "{EFC776C4-2AF3-440C-BE80-3FBE335817A5}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CoreIntegrationTests", "CoreIntegrationTests\CoreIntegrationTests.csproj", "{C640C106-7A25-4E49-A0CF-E4F248E5A97F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{D154E7D0-9A3C-43AB-8E90-ED92BC4343F0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D154E7D0-9A3C-43AB-8E90-ED92BC4343F0}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D154E7D0-9A3C-43AB-8E90-ED92BC4343F0}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D154E7D0-9A3C-43AB-8E90-ED92BC4343F0}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A484A355-A015-40CC-9B35-A4E872421128}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{A484A355-A015-40CC-9B35-A4E872421128}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A484A355-A015-40CC-9B35-A4E872421128}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A484A355-A015-40CC-9B35-A4E872421128}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EFC776C4-2AF3-440C-BE80-3FBE335817A5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EFC776C4-2AF3-440C-BE80-3FBE335817A5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EFC776C4-2AF3-440C-BE80-3FBE335817A5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EFC776C4-2AF3-440C-BE80-3FBE335817A5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C640C106-7A25-4E49-A0CF-E4F248E5A97F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C640C106-7A25-4E49-A0CF-E4F248E5A97F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C640C106-7A25-4E49-A0CF-E4F248E5A97F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C640C106-7A25-4E49-A0CF-E4F248E5A97F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {78214390-EFBD-403C-8AAA-5CD4CA5AE2ED}
+	EndGlobalSection
 EndGlobal

MongoDbGenericRepository/ApplicationInsights.config

@@ -1,3 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<ApplicationInsights xmlns="http://schemas.microsoft.com/ApplicationInsights/2013/Settings">
-</ApplicationInsights>

MongoDbGenericRepository/IMongoDbContext.cs

@@ -1,10 +1,24 @@
 using MongoDB.Driver;
 using MongoDbGenericRepository.Models;
+using System;
 
 namespace MongoDbGenericRepository
 {
+    /// <summary>
+    /// This is the interface of the IMongoDbContext which is managed by the <see cref="BaseMongoRepository"/>.
+    /// </summary>
     public interface IMongoDbContext
     {
+        /// <summary>
+        /// The IMongoClient from the official MongoDb driver
+        /// </summary>
+        IMongoClient Client { get; }
+
+        /// <summary>
+        /// The IMongoDatabase from the official Mongodb driver
+        /// </summary>
+        IMongoDatabase Database { get; }
+
         /// <summary>
         /// The private GetCollection method
         /// </summary>
@@ -18,6 +32,16 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">The value of the partition key.</param>
         IMongoCollection<TDocument> GetCollection<TDocument>(string partitionKey) where TDocument : IDocument;
 
+        /// <summary>
+        /// Returns a collection for a document type that has a partition key.
+        /// </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">The value of the partition key.</param>
+        IMongoCollection<TDocument> GetCollection<TDocument, TKey>(string partitionKey)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
         /// <summary>
         /// Drops a collection, use very carefully.
         /// </summary>
@@ -29,5 +53,11 @@ namespace MongoDbGenericRepository
         /// </summary>
         /// <typeparam name="TDocument"></typeparam>
         void DropCollection<TDocument>(string partitionKey);
+
+        /// <summary>
+        /// Sets the Guid representation of the MongoDb Driver.
+        /// </summary>
+        /// <param name="guidRepresentation">The new value of the GuidRepresentation</param>
+        void SetGuidRepresentation(MongoDB.Bson.GuidRepresentation guidRepresentation);
     }
 }

MongoDbGenericRepository/Models/Document.cs

@@ -4,7 +4,8 @@ using System;
 namespace MongoDbGenericRepository.Models
 {
     /// <summary>
-    /// This class represents a basic document that can be stored in MongoDb
+    /// This class represents a basic document that can be stored in MongoDb.
+    /// Your document must implement this class in order for the MongoDbRepository to handle them.
     /// </summary>
     public class Document : IDocument
     {
@@ -33,18 +34,4 @@ namespace MongoDbGenericRepository.Models
         /// </summary>
         public int Version { get; set; }
     }
-
-    public class PartitionedDocument : Document, IPartitionedDocument
-    {
-        public PartitionedDocument(string partitionKey)
-        {
-            PartitionKey = partitionKey;
-        }
-        /// <summary>
-        /// The name of the property used for partitioning the collection
-        /// This will not be inserted into the collection.
-        /// This partition key will be prepended to the collection name to create a new collection.
-        /// </summary>
-        public string PartitionKey { get; set; }
-    }
 }

MongoDbGenericRepository/Models/IDocument.cs

@@ -1,4 +1,5 @@
-using System;
+using MongoDB.Bson.Serialization.Attributes;
+using System;
 
 namespace MongoDbGenericRepository.Models
 {
@@ -6,21 +7,24 @@ namespace MongoDbGenericRepository.Models
     /// This class represents a basic document that can be stored in MongoDb.
     /// Your document must implement this class in order for the MongoDbRepository to handle them.
     /// </summary>
-    public interface IDocument
+    public interface IDocument<TKey> where TKey : IEquatable<TKey>
     {
-        DateTime AddedAtUtc { get; set; }
+        /// <summary>
-        Guid Id { get; set; }
+        /// The Primary Key, which must be decorated with the [BsonId] attribute 
+        /// if you want the MongoDb C# driver to consider it to be the document ID.
+        /// </summary>
+        TKey Id { get; set; }
+        /// <summary>
+        /// A version number, to indicate the version of the schema.
+        /// </summary>
         int Version { get; set; }
     }
 
     /// <summary>
-    /// This class represents a document that can be inserted in a collection that can be partitioned.
+    /// This class represents a basic document that can be stored in MongoDb.
-    /// The partition key allows for the creation of different collections having the same document schema.
+    /// Your document must implement this class in order for the MongoDbRepository to handle them.
-    /// This can be useful if you are planning to build a Software as a Service (SaaS) Platform, or if you want to reduce indexing.
-    /// You could for example insert Logs in different collections based on the week and year they where created, or their Log category/source.
     /// </summary>
-    public interface IPartitionedDocument : IDocument
+    public interface IDocument : IDocument<Guid>
     {
-        string PartitionKey { get; set; }
     }
 }

MongoDbGenericRepository/Models/IPartitionedDocument.cs

@@ -0,0 +1,16 @@
+namespace MongoDbGenericRepository.Models
+{
+    /// <summary>
+    /// This class represents a document that can be inserted in a collection that can be partitioned.
+    /// The partition key allows for the creation of different collections having the same document schema.
+    /// This can be useful if you are planning to build a Software as a Service (SaaS) Platform, or if you want to reduce indexing.
+    /// You could for example insert Logs in different collections based on the week and year they where created, or their Log category/source.
+    /// </summary>
+    public interface IPartitionedDocument
+    {
+        /// <summary>
+        /// The partition key used to partition your collection.
+        /// </summary>
+        string PartitionKey { get; set; }
+    }
+}

MongoDbGenericRepository/Models/PartitionedDocument.cs

@@ -0,0 +1,26 @@
+namespace MongoDbGenericRepository.Models
+{
+    /// <summary>
+    /// This class represents a document that can be inserted in a collection that can be partitioned.
+    /// The partition key allows for the creation of different collections having the same document schema.
+    /// This can be useful if you are planning to build a Software as a Service (SaaS) Platform, or if you want to reduce indexing.
+    /// You could for example insert Logs in different collections based on the week and year they where created, or their Log category/source.
+    /// </summary>
+    public class PartitionedDocument : Document, IPartitionedDocument
+    {
+        /// <summary>
+        /// The constructor, it needs a partition key.
+        /// </summary>
+        /// <param name="partitionKey"></param>
+        public PartitionedDocument(string partitionKey)
+        {
+            PartitionKey = partitionKey;
+        }
+        /// <summary>
+        /// The name of the property used for partitioning the collection
+        /// This will not be inserted into the collection.
+        /// This partition key will be prepended to the collection name to create a new collection.
+        /// </summary>
+        public string PartitionKey { get; set; }
+    }
+}

MongoDbGenericRepository/MongoDbContext.cs

@@ -1,5 +1,6 @@
 using MongoDB.Driver;
 using MongoDbGenericRepository.Models;
+using System;
 
 namespace MongoDbGenericRepository
 {
@@ -8,8 +9,15 @@ namespace MongoDbGenericRepository
     /// </summary>
     public class MongoDbContext : IMongoDbContext
     {
-        private readonly IMongoClient _client;
+        /// <summary>
-        private readonly IMongoDatabase _database;
+        /// The IMongoClient from the official MongoDb driver
+        /// </summary>
+        public IMongoClient Client { get; }
+
+        /// <summary>
+        /// The IMongoDatabase from the official Mongodb driver
+        /// </summary>
+        public IMongoDatabase Database { get; }
 
         static MongoDbContext()
         {
@@ -17,58 +25,95 @@ namespace MongoDbGenericRepository
             MongoDefaults.GuidRepresentation = MongoDB.Bson.GuidRepresentation.Standard;
         }
 
+        /// <summary>
+        /// Sets the Guid representation of the MongoDb Driver.
+        /// </summary>
+        /// <param name="guidRepresentation">The new value of the GuidRepresentation</param>
+        public void SetGuidRepresentation(MongoDB.Bson.GuidRepresentation guidRepresentation)
+        {
+            MongoDefaults.GuidRepresentation = guidRepresentation;
+        }
+
+        /// <summary>
+        /// The constructor of the MongoDbContext, it needs a an object implementing <see cref="IMongoDatabase"/>.
+        /// </summary>
+        /// <param name="mongoDatabase">An object implementing IMongoDatabase</param>
+        public MongoDbContext(IMongoDatabase mongoDatabase)
+        {
+            Database = mongoDatabase;
+            Client = Database.Client;
+        }
+
+        /// <summary>
+        /// The constructor of the MongoDbContext, it needs a connection string and a database name. 
+        /// </summary>
+        /// <param name="connectionString">The connections string.</param>
+        /// <param name="databaseName">The name of your database.</param>
         public MongoDbContext(string connectionString, string databaseName)
         {
-            _client = new MongoClient(connectionString);
+            Client = new MongoClient(connectionString);
-            _database = _client.GetDatabase(databaseName);
+            Database = Client.GetDatabase(databaseName);
         }
 
         /// <summary>
         /// The private GetCollection method
         /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
         /// <returns></returns>
         public IMongoCollection<TDocument> GetCollection<TDocument>()
         {
-            return _database.GetCollection<TDocument>(Pluralize<TDocument>());
+            return Database.GetCollection<TDocument>(Pluralize<TDocument>());
         }
 
         /// <summary>
         /// Returns a collection for a document type that has a partition key.
         /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
         /// <param name="partitionKey">The value of the partition key.</param>
         public IMongoCollection<TDocument> GetCollection<TDocument>(string partitionKey) where TDocument : IDocument
         {
-            return _database.GetCollection<TDocument>(partitionKey +"-"+ Pluralize<TDocument>());
+            return Database.GetCollection<TDocument>(partitionKey +"-"+ Pluralize<TDocument>());
+        }
+
+        /// <summary>
+        /// Returns a collection for a document type that has a partition key.
+        /// </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">The value of the partition key.</param>
+        public IMongoCollection<TDocument> GetCollection<TDocument, TKey>(string partitionKey) 
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return Database.GetCollection<TDocument>(partitionKey + "-" + Pluralize<TDocument>());
         }
 
         /// <summary>
         /// Drops a collection, use very carefully.
         /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
         public void DropCollection<TDocument>()
         {
-            _database.DropCollection(Pluralize<TDocument>());
+            Database.DropCollection(Pluralize<TDocument>());
         }
 
         /// <summary>
         /// Drops a collection having a partitionkey, use very carefully.
         /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
         public void DropCollection<TDocument>(string partitionKey)
         {
-            _database.DropCollection(partitionKey + "-" + Pluralize<TDocument>());
+            Database.DropCollection(partitionKey + "-" + Pluralize<TDocument>());
         }
 
         /// <summary>
         /// Very naively pluralizes a TDocument type name.
         /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
         /// <returns></returns>
         private string Pluralize<TDocument>()
         {
-            return typeof(TDocument).Name.ToLower() + "s";
+            return (typeof(TDocument).Name.Pluralize()).Camelize();
         }
     }
 }

MongoDbGenericRepository/MongoDbGenericRepository.csproj

@@ -1,141 +1,23 @@
-<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Microsoft.NET.Sdk">
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
-  <Import Project="..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.7\build\net45\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.props" Condition="Exists('..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.7\build\net45\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.props')" />
-  <Import Project="..\packages\Microsoft.Net.Compilers.2.3.1\build\Microsoft.Net.Compilers.props" Condition="Exists('..\packages\Microsoft.Net.Compilers.2.3.1\build\Microsoft.Net.Compilers.props')" />
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <TargetFrameworks>net45;netstandard1.5;netstandard2.0</TargetFrameworks>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <PackageId>MongoDbGenericRepository</PackageId>
-    <ProductVersion>
+    <PackageVersion>1.2.0</PackageVersion>
-    </ProductVersion>
+    <Authors>Alexandre Spieser</Authors>
-    <SchemaVersion>2.0</SchemaVersion>
+    <Description>A generic repository implementation using the MongoDB C# Sharp 2.0 driver.</Description>
-    <ProjectGuid>{D154E7D0-9A3C-43AB-8E90-ED92BC4343F0}</ProjectGuid>
+    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-    <ProjectTypeGuids>{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
+    <PackageReleaseNotes>.NET Core supported.</PackageReleaseNotes>
-    <OutputType>Library</OutputType>
+    <Copyright>Copyright 2017 (c) Alexandre Spieser. All rights reserved.</Copyright>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <PackageTags>MongoDb Repository NoSql Generic</PackageTags>
-    <RootNamespace>MongoDbGenericRepository</RootNamespace>
-    <AssemblyName>MongoDbGenericRepository</AssemblyName>
-    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
-    <UseIISExpress>true</UseIISExpress>
-    <IISExpressSSLPort />
-    <IISExpressAnonymousAuthentication />
-    <IISExpressWindowsAuthentication />
-    <IISExpressUseClassicPipelineMode />
-    <UseGlobalApplicationHostFile />
-    <NuGetPackageImportStamp>
-    </NuGetPackageImportStamp>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+
-    <DebugSymbols>true</DebugSymbols>
+  <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Release|net45|AnyCPU'">
-    <DebugType>full</DebugType>
+    <DocumentationFile>bin\Release\net45\MongoDbGenericRepository.xml</DocumentationFile>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
   </PropertyGroup>
+
   <ItemGroup>
-    <Reference Include="Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.7.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+    <PackageReference Include="MongoDB.Driver" Version="2.4.4" />
-      <HintPath>..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.7\lib\net45\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.dll</HintPath>
-    </Reference>
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="MongoDB.Bson, Version=2.4.4.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\MongoDB.Bson.2.4.4\lib\net45\MongoDB.Bson.dll</HintPath>
-    </Reference>
-    <Reference Include="MongoDB.Driver, Version=2.4.4.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\MongoDB.Driver.2.4.4\lib\net45\MongoDB.Driver.dll</HintPath>
-    </Reference>
-    <Reference Include="MongoDB.Driver.Core, Version=2.4.4.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\MongoDB.Driver.Core.2.4.4\lib\net45\MongoDB.Driver.Core.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Runtime.InteropServices.RuntimeInformation, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Runtime.InteropServices.RuntimeInformation.4.3.0\lib\net45\System.Runtime.InteropServices.RuntimeInformation.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Web.DynamicData" />
-    <Reference Include="System.Web.Entity" />
-    <Reference Include="System.Web.ApplicationServices" />
-    <Reference Include="System.ComponentModel.DataAnnotations" />
-    <Reference Include="System" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="System.Web.Extensions" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Drawing" />
-    <Reference Include="System.Web" />
-    <Reference Include="System.Xml" />
-    <Reference Include="System.Configuration" />
-    <Reference Include="System.Web.Services" />
-    <Reference Include="System.EnterpriseServices" />
   </ItemGroup>
-  <ItemGroup>
+
-    <Content Include="packages.config" />
-    <Content Include="ApplicationInsights.config">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-    <None Include="Web.Debug.config">
-      <DependentUpon>Web.config</DependentUpon>
-    </None>
-    <None Include="Web.Release.config">
-      <DependentUpon>Web.config</DependentUpon>
-    </None>
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="Web.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="IMongoDbContext.cs" />
-    <Compile Include="Models\Document.cs" />
-    <Compile Include="Models\IDocument.cs" />
-    <Compile Include="MongoDbContext.cs" />
-    <Compile Include="MongoDbRepository.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <PropertyGroup>
-    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
-    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
-  </PropertyGroup>
-  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(VSToolsPath)\WebApplications\Microsoft.WebApplication.targets" Condition="'$(VSToolsPath)' != ''" />
-  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets" Condition="false" />
-  <ProjectExtensions>
-    <VisualStudio>
-      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
-        <WebProjectProperties>
-          <UseIIS>True</UseIIS>
-          <AutoAssignPort>True</AutoAssignPort>
-          <DevelopmentServerPort>52313</DevelopmentServerPort>
-          <DevelopmentServerVPath>/</DevelopmentServerVPath>
-          <IISUrl>http://localhost:52313/</IISUrl>
-          <NTLMAuthentication>False</NTLMAuthentication>
-          <UseCustomServer>False</UseCustomServer>
-          <CustomServerUrl>
-          </CustomServerUrl>
-          <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
-        </WebProjectProperties>
-      </FlavorProperties>
-    </VisualStudio>
-  </ProjectExtensions>
-  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
-    <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
-    </PropertyGroup>
-    <Error Condition="!Exists('..\packages\Microsoft.Net.Compilers.2.3.1\build\Microsoft.Net.Compilers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.Net.Compilers.2.3.1\build\Microsoft.Net.Compilers.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.7\build\net45\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.7\build\net45\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.props'))" />
-  </Target>
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
 </Project>

MongoDbGenericRepository/MongoDbGenericRepository.csproj.user

@@ -1,31 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <UseIISExpress>true</UseIISExpress>
+    <ShowAllFiles>true</ShowAllFiles>
   </PropertyGroup>
-  <ProjectExtensions>
-    <VisualStudio>
-      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
-        <WebProjectProperties>
-          <StartPageUrl>
-          </StartPageUrl>
-          <StartAction>CurrentPage</StartAction>
-          <AspNetDebugging>True</AspNetDebugging>
-          <SilverlightDebugging>False</SilverlightDebugging>
-          <NativeDebugging>False</NativeDebugging>
-          <SQLDebugging>False</SQLDebugging>
-          <ExternalProgram>
-          </ExternalProgram>
-          <StartExternalURL>
-          </StartExternalURL>
-          <StartCmdLineArguments>
-          </StartCmdLineArguments>
-          <StartWorkingDirectory>
-          </StartWorkingDirectory>
-          <EnableENC>True</EnableENC>
-          <AlwaysStartWebServerOnDebug>True</AlwaysStartWebServerOnDebug>
-        </WebProjectProperties>
-      </FlavorProperties>
-    </VisualStudio>
-  </ProjectExtensions>
 </Project>

MongoDbGenericRepository/MongoDbGenericRepository.nuspec

@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>MongoDbGenericRepository</id>
+    <version>1.3</version>
+    <title>MongoDb Generic Repository</title>
+    <authors>Alexandre Spieser</authors>
+    <owners>Alexandre Spieser</owners>
+    <licenseUrl>http://www.opensource.org/licenses/mit-license.php</licenseUrl>
+    <projectUrl>https://github.com/alexandre-spieser/mongodb-generic-repository</projectUrl>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description>A generic repository implementation using the MongoDB C# Sharp 2.0 driver.</description>
+    <releaseNotes>Added support for Documents that have an Id of type TKey, and implement the IDocument{TKey} interface.</releaseNotes>
+    <copyright>Copyright 2017 (c) Alexandre Spieser. All rights reserved.</copyright>
+    <tags>MongoDb Repository Generic NoSql</tags>
+  </metadata>
+  <files>
+    <file src="lib\**" target="lib" />
+  </files>
+</package>

MongoDbGenericRepository/MongoDbGenericRepository.xml

@@ -0,0 +1,752 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>MongoDbGenericRepository</name>
+    </assembly>
+    <members>
+        <member name="M:MongoDbGenericRepository.IMongoDbContext.GetCollection``1">
+            <summary>
+            The private GetCollection method
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+        </member>
+        <member name="M:MongoDbGenericRepository.IMongoDbContext.GetCollection``1(System.String)">
+            <summary>
+            Returns a collection for a document type that has a partition key.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="partitionKey">The value of the partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IMongoDbContext.DropCollection``1">
+            <summary>
+            Drops a collection, use very carefully.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+        </member>
+        <member name="M:MongoDbGenericRepository.IMongoDbContext.DropCollection``1(System.String)">
+            <summary>
+            Drops a collection having a partitionkey, use very carefully.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+        </member>
+        <member name="T:MongoDbGenericRepository.Models.Document">
+            <summary>
+            This class represents a basic document that can be stored in MongoDb
+            </summary>
+        </member>
+        <member name="M:MongoDbGenericRepository.Models.Document.#ctor">
+            <summary>
+            The document constructor
+            </summary>
+        </member>
+        <member name="P:MongoDbGenericRepository.Models.Document.Id">
+            <summary>
+            The Id of the document
+            </summary>
+        </member>
+        <member name="P:MongoDbGenericRepository.Models.Document.AddedAtUtc">
+            <summary>
+            The datetime in UTC at which the document was added.
+            </summary>
+        </member>
+        <member name="P:MongoDbGenericRepository.Models.Document.Version">
+            <summary>
+            The version of the schema of the document
+            </summary>
+        </member>
+        <member name="P:MongoDbGenericRepository.Models.PartitionedDocument.PartitionKey">
+            <summary>
+            The name of the property used for partitioning the collection
+            This will not be inserted into the collection.
+            This partition key will be prepended to the collection name to create a new collection.
+            </summary>
+        </member>
+        <member name="T:MongoDbGenericRepository.Models.IDocument">
+            <summary>
+            This class represents a basic document that can be stored in MongoDb.
+            Your document must implement this class in order for the MongoDbRepository to handle them.
+            </summary>
+        </member>
+        <member name="T:MongoDbGenericRepository.Models.IPartitionedDocument">
+            <summary>
+            This class represents a document that can be inserted in a collection that can be partitioned.
+            The partition key allows for the creation of different collections having the same document schema.
+            This can be useful if you are planning to build a Software as a Service (SaaS) Platform, or if you want to reduce indexing.
+            You could for example insert Logs in different collections based on the week and year they where created, or their Log category/source.
+            </summary>
+        </member>
+        <member name="T:MongoDbGenericRepository.MongoDbContext">
+            <summary>
+            The MongoDb context
+            </summary>
+        </member>
+        <member name="M:MongoDbGenericRepository.MongoDbContext.GetCollection``1">
+            <summary>
+            The private GetCollection method
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <returns></returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.MongoDbContext.GetCollection``1(System.String)">
+            <summary>
+            Returns a collection for a document type that has a partition key.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="partitionKey">The value of the partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.MongoDbContext.DropCollection``1">
+            <summary>
+            Drops a collection, use very carefully.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+        </member>
+        <member name="M:MongoDbGenericRepository.MongoDbContext.DropCollection``1(System.String)">
+            <summary>
+            Drops a collection having a partitionkey, use very carefully.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+        </member>
+        <member name="M:MongoDbGenericRepository.MongoDbContext.Pluralize``1">
+            <summary>
+            Very naively pluralizes a TDocument type name.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <returns></returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.AddOneAsync``1(``0)">
+            <summary>
+            Asynchronously adds a document to the collection.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="document">The document you want to add.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.AddOne``1(``0)">
+            <summary>
+            Adds a document to the collection.
+            Populates the Id and AddedAtUtc fields if necessary.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="document">The document you want to add.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.AddManyAsync``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Asynchronously adds a list of documents to the collection.
+            Populates the Id and AddedAtUtc fields if necessary.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="document">The document you want to add.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.AddMany``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Adds a list of documents to the collection.
+            Populates the Id and AddedAtUtc fields if necessary.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="document">The document you want to add.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.GetByIdAsync``1(System.Guid,System.String)">
+            <summary>
+            Asynchronously returns one document given its id.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="id">The Id of the document you want to get.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.GetById``1(System.Guid,System.String)">
+            <summary>
+            Returns one document given its id.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="id">The Id of the document you want to get.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.GetOneAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously returns one document given an expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.GetOne``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Returns one document given an expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.GetCursor``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Returns a collection cursor.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.AnyAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously returns true if any of the document of the collection matches the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.Any``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Returns true if any of the document of the collection matches the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.GetAllAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously returns a list of the documents matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.GetAll``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Returns a list of the documents matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.CountAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously counts how many documents match the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.Count``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Counts how many documents match the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.UpdateOneAsync``1(``0)">
+            <summary>
+            Asynchronously Updates a document.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.UpdateOne``1(``0)">
+            <summary>
+            Updates a document.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.DeleteOneAsync``1(``0)">
+            <summary>
+            Asynchronously deletes a document.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="TDocument">The document you want to delete.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.DeleteOneAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously deletes a document matching the condition of the LINQ expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.DeleteOne``1(``0)">
+            <summary>
+            Deletes a document.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="TDocument">The document you want to delete.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.DeleteOne``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Deletes a document matching the condition of the LINQ expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.DeleteManyAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.DeleteManyAsync``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Asynchronously deletes a list of documents.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="documents">The list of documents to delete.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.DeleteMany``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Deletes a list of documents.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="documents">The list of documents to delete.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.DeleteMany``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Deletes the documents matching the condition of the LINQ expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.ProjectOneAsync``2(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)">
+            <summary>
+            Asynchronously returns a projected document matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <typeparam name="TProjection"></typeparam>
+            <param name="filter"></param>
+            <param name="projection">The projection expression.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.ProjectOne``2(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)">
+            <summary>
+            Returns a projected document matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <typeparam name="TProjection"></typeparam>
+            <param name="filter"></param>
+            <param name="projection">The projection expression.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.ProjectManyAsync``2(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)">
+            <summary>
+            Asynchronously returns a list of projected documents matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <typeparam name="TProjection"></typeparam>
+            <param name="filter"></param>
+            <param name="projection">The projection expression.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.IBaseMongoRepository.ProjectMany``2(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)">
+            <summary>
+            Asynchronously returns a list of projected documents matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <typeparam name="TProjection"></typeparam>
+            <param name="filter"></param>
+            <param name="projection">The projection expression.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="T:MongoDbGenericRepository.BaseMongoRepository">
+            <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>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.#ctor(System.String,System.String)">
+            <summary>
+            The base constructor
+            </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>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.AddOneAsync``1(``0)">
+            <summary>
+            Asynchronously adds a document to the collection.
+            Populates the Id and AddedAtUtc fields if necessary.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="document">The document you want to add.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.AddOne``1(``0)">
+            <summary>
+            Adds a document to the collection.
+            Populates the Id and AddedAtUtc fields if necessary.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="document">The document you want to add.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.AddManyAsync``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Asynchronously adds a list of documents to the collection.
+            Populates the Id and AddedAtUtc fields if necessary.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="document">The document you want to add.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.AddMany``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Adds a list of documents to the collection.
+            Populates the Id and AddedAtUtc fields if necessary.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="document">The document you want to add.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.GetByIdAsync``1(System.Guid,System.String)">
+            <summary>
+            Asynchronously returns one document given its id.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="id">The Id of the document you want to get.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.GetById``1(System.Guid,System.String)">
+            <summary>
+            Returns one document given its id.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="id">The Id of the document you want to get.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.GetOneAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously returns one document given an expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.GetOne``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Returns one document given an expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.GetCursor``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Returns a collection cursor.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.AnyAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Returns true if any of the document of the collection matches the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.Any``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Returns true if any of the document of the collection matches the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.GetAllAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously returns a list of the documents matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.GetAll``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Returns a list of the documents matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.CountAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously counts how many documents match the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partitionKey</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.Count``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Counts how many documents match the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partitionKey</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.UpdateOneAsync``1(``0)">
+            <summary>
+            Asynchronously Updates a document.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.UpdateOne``1(``0)">
+            <summary>
+            Updates a document.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.DeleteOneAsync``1(``0)">
+            <summary>
+            Asynchronously deletes a document.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="TDocument">The document you want to delete.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.DeleteOne``1(``0)">
+            <summary>
+            Deletes a document.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="TDocument">The document you want to delete.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.DeleteOne``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Deletes a document matching the condition of the LINQ expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.DeleteOneAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously deletes a document matching the condition of the LINQ expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.DeleteManyAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.DeleteManyAsync``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Asynchronously deletes a list of documents.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="documents">The list of documents to delete.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.DeleteMany``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Deletes a list of documents.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="documents">The list of documents to delete.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.DeleteMany``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.String)">
+            <summary>
+            Deletes the documents matching the condition of the LINQ expression filter.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter">A LINQ expression filter.</param>
+            <param name="partitionKey">An optional partition key.</param>
+            <returns>The number of documents deleted.</returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.ProjectOneAsync``2(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)">
+            <summary>
+            Asynchronously returns a projected document matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <typeparam name="TProjection"></typeparam>
+            <param name="filter"></param>
+            <param name="projection">The projection expression.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.ProjectOne``2(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)">
+            <summary>
+            Returns a projected document matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <typeparam name="TProjection"></typeparam>
+            <param name="filter"></param>
+            <param name="projection">The projection expression.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.ProjectManyAsync``2(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)">
+            <summary>
+            Asynchronously returns a list of projected documents matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <typeparam name="TProjection"></typeparam>
+            <param name="filter"></param>
+            <param name="projection">The projection expression.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.ProjectMany``2(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)">
+            <summary>
+            Asynchronously returns a list of projected documents matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <typeparam name="TProjection"></typeparam>
+            <param name="filter"></param>
+            <param name="projection">The projection expression.</param>
+            <param name="partitionKey">An optional partition key.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.GetPaginatedAsync``1(System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Int32,System.Int32,System.String)">
+            <summary>
+            Asynchronously returns a paginated list of the documents matching the filter condition.
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="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>
+        </member>
+        <member name="M:MongoDbGenericRepository.BaseMongoRepository.GetAndUpdateOne``1(MongoDB.Driver.FilterDefinition{``0},MongoDB.Driver.UpdateDefinition{``0},MongoDB.Driver.FindOneAndUpdateOptions{``0,``0})">
+            <summary>
+            GetAndUpdateOne with filter
+            </summary>
+            <typeparam name="TDocument"></typeparam>
+            <param name="filter"></param>
+            <param name="update"></param>
+            <param name="options"></param>
+            <returns></returns>
+        </member>
+        <member name="T:MongoDbGenericRepository.Vocabularies">
+            <summary>
+            Container for registered Vocabularies.  At present, only a single vocabulary is supported: Default.
+            </summary>
+        </member>
+        <member name="P:MongoDbGenericRepository.Vocabularies.Default">
+            <summary>
+            The default vocabulary used for singular/plural irregularities.
+            Rules can be added to this vocabulary and will be picked up by called to Singularize() and Pluralize().
+            At this time, multiple vocabularies and removing existing rules are not supported.
+            </summary>
+        </member>
+        <member name="T:MongoDbGenericRepository.Vocabulary">
+            <summary>
+            A container for exceptions to simple pluralization/singularization rules.
+            Vocabularies.Default contains an extensive list of rules for US English.
+            At this time, multiple vocabularies and removing existing rules are not supported.
+            </summary>
+        </member>
+        <member name="M:MongoDbGenericRepository.Vocabulary.AddIrregular(System.String,System.String,System.Boolean)">
+            <summary>
+            Adds a word to the vocabulary which cannot easily be pluralized/singularized by RegEx, e.g. "person" and "people".
+            </summary>
+            <param name="singular">The singular form of the irregular word, e.g. "person".</param>
+            <param name="plural">The plural form of the irregular word, e.g. "people".</param>
+            <param name="matchEnding">True to match these words on their own as well as at the end of longer words. False, otherwise.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.Vocabulary.AddUncountable(System.String)">
+            <summary>
+            Adds an uncountable word to the vocabulary, e.g. "fish".  Will be ignored when plurality is changed.
+            </summary>
+            <param name="word">Word to be added to the list of uncountables.</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.Vocabulary.AddPlural(System.String,System.String)">
+            <summary>
+            Adds a rule to the vocabulary that does not follow trivial rules for pluralization, e.g. "bus" -> "buses"
+            </summary>
+            <param name="rule">RegEx to be matched, case insensitive, e.g. "(bus)es$"</param>
+            <param name="replacement">RegEx replacement  e.g. "$1"</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.Vocabulary.AddSingular(System.String,System.String)">
+            <summary>
+            Adds a rule to the vocabulary that does not follow trivial rules for singularization, e.g. "vertices/indices -> "vertex/index"
+            </summary>
+            <param name="rule">RegEx to be matched, case insensitive, e.g. ""(vert|ind)ices$""</param>
+            <param name="replacement">RegEx replacement  e.g. "$1ex"</param>
+        </member>
+        <member name="M:MongoDbGenericRepository.Vocabulary.Pluralize(System.String,System.Boolean)">
+            <summary>
+            Pluralizes the provided input considering irregular words
+            </summary>
+            <param name="word">Word to be pluralized</param>
+            <param name="inputIsKnownToBeSingular">Normally you call Pluralize on singular words; but if you're unsure call it with false</param>
+            <returns></returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.Vocabulary.Singularize(System.String,System.Boolean)">
+            <summary>
+            Singularizes the provided input considering irregular words
+            </summary>
+            <param name="word">Word to be singularized</param>
+            <param name="inputIsKnownToBePlural">Normally you call Singularize on plural words; but if you're unsure call it with false</param>
+            <returns></returns>
+        </member>
+        <member name="T:MongoDbGenericRepository.InflectorExtensions">
+            <summary>
+            Inflector extensions
+            </summary>
+        </member>
+        <member name="M:MongoDbGenericRepository.InflectorExtensions.Pluralize(System.String,System.Boolean)">
+            <summary>
+            Pluralizes the provided input considering irregular words
+            </summary>
+            <param name="word">Word to be pluralized</param>
+            <param name="inputIsKnownToBeSingular">Normally you call Pluralize on singular words; but if you're unsure call it with false</param>
+            <returns></returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.InflectorExtensions.Singularize(System.String,System.Boolean)">
+            <summary>
+            Singularizes the provided input considering irregular words
+            </summary>
+            <param name="word">Word to be singularized</param>
+            <param name="inputIsKnownToBePlural">Normally you call Singularize on plural words; but if you're unsure call it with false</param>
+            <returns></returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.InflectorExtensions.Pascalize(System.String)">
+            <summary>
+            By default, pascalize converts strings to UpperCamelCase also removing underscores
+            </summary>
+            <param name="input"></param>
+            <returns></returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.InflectorExtensions.Camelize(System.String)">
+            <summary>
+            Same as Pascalize except that the first character is lower case
+            </summary>
+            <param name="input"></param>
+            <returns></returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.InflectorExtensions.Underscore(System.String)">
+            <summary>
+            Separates the input words with underscore
+            </summary>
+            <param name="input">The string to be underscored</param>
+            <returns></returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.InflectorExtensions.Dasherize(System.String)">
+            <summary>
+            Replaces underscores with dashes in the string
+            </summary>
+            <param name="underscoredWord"></param>
+            <returns></returns>
+        </member>
+        <member name="M:MongoDbGenericRepository.InflectorExtensions.Hyphenate(System.String)">
+            <summary>
+            Replaces underscores with hyphens in the string
+            </summary>
+            <param name="underscoredWord"></param>
+            <returns></returns>
+        </member>
+    </members>
+</doc>

MongoDbGenericRepository/MongoDbRepository.cs

@@ -1,783 +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
-{
-    public interface IBaseMongoRepository
-    {
-        #region Create
-
-        /// <summary>
-        /// Asynchronously adds a document to the collection.
-        /// </summary>
-        /// <typeparam name="TDocument"></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"></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"></typeparam>
-        /// <param name="document">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"></typeparam>
-        /// <param name="document">The document you want to add.</param>
-        void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument;
-
-        #endregion
-
-        #region Read
-
-        /// <summary>
-        /// Asynchronously returns one document given its id.
-        /// </summary>
-        /// <typeparam name="TDocument"></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>(Guid id, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Returns one document given its id.
-        /// </summary>
-        /// <typeparam name="TDocument"></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>(Guid id, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Asynchronously returns one document given an expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<TDocument> GetOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Returns one document given an expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        TDocument GetOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Returns a collection cursor.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        IFindFluent<TDocument, TDocument> GetCursor<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Asynchronously returns true if any of the document of the collection matches the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<bool> AnyAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Returns true if any of the document of the collection matches the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        bool Any<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Asynchronously returns a list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<List<TDocument>> GetAllAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Returns a list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        List<TDocument> GetAll<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Asynchronously counts how many documents match the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        Task<long> CountAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        /// <summary>
-        /// Counts how many documents match the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        long Count<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
-
-        #endregion
-
-        #region Update
-
-        /// <summary>
-        /// Asynchronously Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument"></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"></typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        bool UpdateOne<TDocument>(TDocument modifiedDocument) where TDocument : IDocument;
-
-        #endregion
-
-        #region Delete
-
-        /// <summary>
-        /// Asynchronously deletes a document.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="TDocument">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"></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"></typeparam>
-        /// <param name="TDocument">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"></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"></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"></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"></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"></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 Project
-
-        /// <summary>
-        /// Asynchronously returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <typeparam name="TProjection"></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>
-        /// Returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <typeparam name="TProjection"></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>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <typeparam name="TProjection"></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"></typeparam>
-        /// <typeparam name="TProjection"></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;
-
-        #endregion
-
-    }
-
-    /// <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 class BaseMongoRepository : IBaseMongoRepository
-    {
-        public string ConnectionString { get; set; }
-        public string DatabaseName { get; set; }
-
-        /// <summary>
-        /// The base constructor
-        /// </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)
-        {
-            _mongoDbContext = new MongoDbContext(connectionString, databaseName);
-        }
-
-        protected IMongoDbContext _mongoDbContext = null;
-
-        #region Create
-
-        /// <summary>
-        /// Asynchronously adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public 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"></typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public 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"></typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public async Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument
-        {
-            if (!documents.Any())
-            {
-                return;
-            }
-            foreach (var doc in documents)
-            {
-                FormatDocument(doc);
-            }
-            await HandlePartitioned(documents.FirstOrDefault()).InsertManyAsync(documents);
-        }
-
-        /// <summary>
-        /// Adds a list of documents to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument
-        {
-            if (!documents.Any())
-            {
-                return;
-            }
-            foreach (var document in documents)
-            {
-                FormatDocument(document);
-            }
-            HandlePartitioned(documents.FirstOrDefault()).InsertMany(documents.ToList());
-        }
-
-        #endregion Create
-
-        #region Read
-
-        /// <summary>
-        /// Asynchronously returns one document given its id.
-        /// </summary>
-        /// <typeparam name="TDocument"></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>(Guid id, string partitionKey = null) where TDocument : IDocument
-        {
-            var filter = Builders<TDocument>.Filter.Eq("Id", id);
-            return await HandlePartitioned<TDocument>(partitionKey).Find(filter).FirstOrDefaultAsync();
-        }
-
-        /// <summary>
-        /// Returns one document given its id.
-        /// </summary>
-        /// <typeparam name="TDocument"></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>(Guid id, string partitionKey = null) where TDocument : IDocument
-        {
-            var filter = Builders<TDocument>.Filter.Eq("Id", id);
-            return HandlePartitioned<TDocument>(partitionKey).Find(filter).FirstOrDefault();
-        }
-
-        /// <summary>
-        /// Asynchronously returns one document given an expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <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
-        {
-            return await HandlePartitioned<TDocument>(partitionKey).Find(filter).FirstOrDefaultAsync();
-        }
-
-        /// <summary>
-        /// Returns one document given an expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public TDocument GetOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return HandlePartitioned<TDocument>(partitionKey).Find(filter).FirstOrDefault();
-        }
-
-        /// <summary>
-        /// Returns a collection cursor.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <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
-        {
-            return HandlePartitioned<TDocument>(partitionKey).Find(filter);
-        }
-
-        /// <summary>
-        /// Returns true if any of the document of the collection matches the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <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
-        {
-            var count = await HandlePartitioned<TDocument>(partitionKey).CountAsync(filter);
-            return (count > 0);
-        }
-
-        /// <summary>
-        /// Returns true if any of the document of the collection matches the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public bool Any<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            var count = HandlePartitioned<TDocument>(partitionKey).Count(filter);
-            return (count > 0);
-        }
-
-        /// <summary>
-        /// Asynchronously returns a list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <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
-        {
-            return await HandlePartitioned<TDocument>(partitionKey).Find(filter).ToListAsync();
-        }
-
-        /// <summary>
-        /// Returns a list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public List<TDocument> GetAll<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return HandlePartitioned<TDocument>(partitionKey).Find(filter).ToList();
-        }
-
-        /// <summary>
-        /// Asynchronously counts how many documents match the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partitionKey</param>
-        public async Task<long> CountAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return await HandlePartitioned<TDocument>(partitionKey).CountAsync(filter);
-        }
-
-        /// <summary>
-        /// Counts how many documents match the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter">A LINQ expression filter.</param>
-        /// <param name="partitionKey">An optional partitionKey</param>
-        public long Count<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return HandlePartitioned<TDocument>(partitionKey).Find(filter).Count();
-        }
-
-        #endregion
-
-        #region Update
-
-        /// <summary>
-        /// Asynchronously Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        public 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;
-        }
-
-        /// <summary>
-        /// Updates a document.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
-        public bool UpdateOne<TDocument>(TDocument modifiedDocument) where TDocument : IDocument
-        {
-            var updateRes = HandlePartitioned(modifiedDocument).ReplaceOne(x => x.Id == modifiedDocument.Id, modifiedDocument);
-            return updateRes.ModifiedCount == 1;
-        }
-
-        #endregion Update
-
-        #region Delete
-
-        /// <summary>
-        /// Asynchronously deletes a document.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="TDocument">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public async Task<long> DeleteOneAsync<TDocument>(TDocument document) where TDocument : IDocument
-        {
-            return (await HandlePartitioned(document).DeleteOneAsync(x => x.Id == document.Id)).DeletedCount;
-        }
-
-        /// <summary>
-        /// Deletes a document.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="TDocument">The document you want to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public long DeleteOne<TDocument>(TDocument document) where TDocument : IDocument
-        {
-            return HandlePartitioned(document).DeleteOne(x => x.Id == document.Id).DeletedCount;
-        }
-
-        /// <summary>
-        /// Deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument"></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 long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return HandlePartitioned<TDocument>(partitionKey).DeleteOne(filter).DeletedCount;
-        }
-
-        /// <summary>
-        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument"></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 async Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return (await HandlePartitioned<TDocument>(partitionKey).DeleteOneAsync(filter)).DeletedCount;
-        }
-
-        /// <summary>
-        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
-        /// </summary>
-        /// <typeparam name="TDocument"></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 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"></typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public async Task<long> DeleteManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument
-        {
-            if (!documents.Any())
-            {
-                return 0;
-            }
-            var idsTodelete = documents.Select(e => e.Id).ToArray();
-            return (await HandlePartitioned(documents.FirstOrDefault()).DeleteManyAsync(x => idsTodelete.Contains(x.Id))).DeletedCount;
-        }
-
-        /// <summary>
-        /// Deletes a list of documents.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="documents">The list of documents to delete.</param>
-        /// <returns>The number of documents deleted.</returns>
-        public long DeleteMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument
-        {
-            if (!documents.Any())
-            {
-                return 0;
-            }
-            var idsTodelete = documents.Select(e => e.Id).ToArray();
-            return HandlePartitioned(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"></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 long DeleteMany<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
-        {
-            return HandlePartitioned<TDocument>(partitionKey).DeleteMany(filter).DeletedCount;
-        }
-
-        #endregion Delete
-
-        #region Project
-
-        /// <summary>
-        /// Asynchronously returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <typeparam name="TProjection"></typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public 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>
-        /// Returns a projected document matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <typeparam name="TProjection"></typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public 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>
-        /// Asynchronously returns a list of projected documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <typeparam name="TProjection"></typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public 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"></typeparam>
-        /// <typeparam name="TProjection"></typeparam>
-        /// <param name="filter"></param>
-        /// <param name="projection">The projection expression.</param>
-        /// <param name="partitionKey">An optional partition key.</param>
-        public 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();
-        }
-
-        #endregion
-
-        /// <summary>
-        /// Asynchronously returns a paginated list of the documents matching the filter condition.
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="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 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();
-        }
-
-        #region Find And Update
-
-        /// <summary>
-        /// GetAndUpdateOne with filter
-        /// </summary>
-        /// <typeparam name="TDocument"></typeparam>
-        /// <param name="filter"></param>
-        /// <param name="update"></param>
-        /// <param name="options"></param>
-        /// <returns></returns>
-        public 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);
-        }
-
-        #endregion Find And Update
-
-        #region Private Methods
-
-        private IMongoCollection<TDocument> GetCollection<TDocument>(string partitionKey) where TDocument : IDocument
-        {
-            return _mongoDbContext.GetCollection<TDocument>(partitionKey);
-        }
-
-        private IMongoCollection<TDocument> GetCollection<TDocument>() where TDocument : IDocument
-        {
-            return _mongoDbContext.GetCollection<TDocument>();
-        }
-
-        private IMongoCollection<TDocument> HandlePartitioned<TDocument>(TDocument document) where TDocument : IDocument
-        {
-            if (document is IPartitionedDocument)
-            {
-                return GetCollection<TDocument>(((IPartitionedDocument)document).PartitionKey);
-            }
-            return GetCollection<TDocument>();
-        }
-
-        private IMongoCollection<TDocument> HandlePartitioned<TDocument>(string partitionKey) where TDocument : IDocument
-        {
-            if (!string.IsNullOrEmpty(partitionKey))
-            {
-                return GetCollection<TDocument>(partitionKey);
-            }
-            return GetCollection<TDocument>();
-        }
-
-        private 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();
-            }
-
-            if (document.AddedAtUtc == default(DateTime))
-            {
-                document.AddedAtUtc = DateTime.UtcNow;
-            }
-        }
-
-        #endregion
-    }
-}

MongoDbGenericRepository/Pluralization.cs

@@ -0,0 +1,428 @@
+//The Inflector class was cloned from Inflector (https://github.com/srkirkland/Inflector)
+
+//The MIT License (MIT)
+
+//Copyright (c) 2013 Scott Kirkland
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy of
+//this software and associated documentation files (the "Software"), to deal in
+//the Software without restriction, including without limitation the rights to
+//use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+//the Software, and to permit persons to whom the Software is furnished to do so,
+//subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+//FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+//COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+//IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+//CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+//Vocabulary and Vocabularies classes were copied from Humanizer.Inflections (https://github.com/Humanizr/Humanizer)
+//The MIT License(MIT)
+
+//Copyright(c) 2012-2014 Mehdi Khalili
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in
+//all copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//THE SOFTWARE.
+
+//==============================================================================
+
+//Inflector (https://github.com/srkirkland/Inflector)
+//The MIT License (MIT)
+//Copyright (c) 2013 Scott Kirkland
+
+//==============================================================================
+
+//ByteSize (https://github.com/omar/ByteSize)
+//The MIT License (MIT)
+//Copyright (c) 2013-2014 Omar Khudeira (http://omar.io)
+
+//==============================================================================
+
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using System.Threading;
+
+namespace MongoDbGenericRepository
+{
+    /// <summary>
+    /// Container for registered Vocabularies.  At present, only a single vocabulary is supported: Default.
+    /// </summary>
+    public static class Vocabularies
+    {
+        private static readonly Lazy<Vocabulary> Instance;
+
+        static Vocabularies()
+        {
+            Instance = new Lazy<Vocabulary>(BuildDefault, LazyThreadSafetyMode.PublicationOnly);
+        }
+
+        /// <summary>
+        /// The default vocabulary used for singular/plural irregularities.
+        /// Rules can be added to this vocabulary and will be picked up by called to Singularize() and Pluralize().
+        /// At this time, multiple vocabularies and removing existing rules are not supported.
+        /// </summary>
+        public static Vocabulary Default => Instance.Value;
+
+        private static Vocabulary BuildDefault()
+        {
+            var _default = new Vocabulary();
+
+            _default.AddPlural("$", "s");
+            _default.AddPlural("s$", "s");
+            _default.AddPlural("(ax|test)is$", "$1es");
+            _default.AddPlural("(octop|vir|alumn|fung|cact|foc|hippopotam|radi|stimul|syllab|nucle)us$", "$1i");
+            _default.AddPlural("(alias|bias|iris|status|campus|apparatus|virus|walrus|trellis)$", "$1es");
+            _default.AddPlural("(buffal|tomat|volcan|ech|embarg|her|mosquit|potat|torped|vet)o$", "$1oes");
+            _default.AddPlural("([dti])um$", "$1a");
+            _default.AddPlural("sis$", "ses");
+            _default.AddPlural("(?:([^f])fe|([lr])f)$", "$1$2ves");
+            _default.AddPlural("(hive)$", "$1s");
+            _default.AddPlural("([^aeiouy]|qu)y$", "$1ies");
+            _default.AddPlural("(x|ch|ss|sh)$", "$1es");
+            _default.AddPlural("(matr|vert|ind|d)ix|ex$", "$1ices");
+            _default.AddPlural("([m|l])ouse$", "$1ice");
+            _default.AddPlural("^(ox)$", "$1en");
+            _default.AddPlural("(quiz)$", "$1zes");
+            _default.AddPlural("(buz|blit|walt)z$", "$1zes");
+            _default.AddPlural("(hoo|lea|loa|thie)f$", "$1ves");
+            _default.AddPlural("(alumn|alg|larv|vertebr)a$", "$1ae");
+            _default.AddPlural("(criteri|phenomen)on$", "$1a");
+
+            _default.AddSingular("s$", "");
+            _default.AddSingular("(n)ews$", "$1ews");
+            _default.AddSingular("([dti])a$", "$1um");
+            _default.AddSingular("(analy|ba|diagno|parenthe|progno|synop|the|ellip|empha|neuro|oa|paraly)ses$", "$1sis");
+            _default.AddSingular("([^f])ves$", "$1fe");
+            _default.AddSingular("(hive)s$", "$1");
+            _default.AddSingular("(tive)s$", "$1");
+            _default.AddSingular("([lr]|hoo|lea|loa|thie)ves$", "$1f");
+            _default.AddSingular("(^zomb)?([^aeiouy]|qu)ies$", "$2y");
+            _default.AddSingular("(s)eries$", "$1eries");
+            _default.AddSingular("(m)ovies$", "$1ovie");
+            _default.AddSingular("(x|ch|ss|sh)es$", "$1");
+            _default.AddSingular("([m|l])ice$", "$1ouse");
+            _default.AddSingular("(o)es$", "$1");
+            _default.AddSingular("(shoe)s$", "$1");
+            _default.AddSingular("(cris|ax|test)es$", "$1is");
+            _default.AddSingular("(octop|vir|alumn|fung|cact|foc|hippopotam|radi|stimul|syllab|nucle)i$", "$1us");
+            _default.AddSingular("(alias|bias|iris|status|campus|apparatus|virus|walrus|trellis)es$", "$1");
+            _default.AddSingular("^(ox)en", "$1");
+            _default.AddSingular("(matr|d)ices$", "$1ix");
+            _default.AddSingular("(vert|ind)ices$", "$1ex");
+            _default.AddSingular("(quiz)zes$", "$1");
+            _default.AddSingular("(buz|blit|walt)zes$", "$1z");
+            _default.AddSingular("(alumn|alg|larv|vertebr)ae$", "$1a");
+            _default.AddSingular("(criteri|phenomen)a$", "$1on");
+
+            _default.AddIrregular("person", "people");
+            _default.AddIrregular("man", "men");
+            _default.AddIrregular("child", "children");
+            _default.AddIrregular("sex", "sexes");
+            _default.AddIrregular("move", "moves");
+            _default.AddIrregular("goose", "geese");
+            _default.AddIrregular("wave", "waves");
+            _default.AddIrregular("die", "dice");
+            _default.AddIrregular("foot", "feet");
+            _default.AddIrregular("tooth", "teeth");
+            _default.AddIrregular("curriculum", "curricula");
+            _default.AddIrregular("database", "databases");
+            _default.AddIrregular("zombie", "zombies");
+
+            _default.AddIrregular("is", "are", matchEnding: false);
+            _default.AddIrregular("that", "those", matchEnding: false);
+            _default.AddIrregular("this", "these", matchEnding: false);
+            _default.AddIrregular("bus", "buses", matchEnding: false);
+
+            _default.AddUncountable("equipment");
+            _default.AddUncountable("information");
+            _default.AddUncountable("rice");
+            _default.AddUncountable("money");
+            _default.AddUncountable("species");
+            _default.AddUncountable("series");
+            _default.AddUncountable("fish");
+            _default.AddUncountable("sheep");
+            _default.AddUncountable("deer");
+            _default.AddUncountable("aircraft");
+            _default.AddUncountable("oz");
+            _default.AddUncountable("tsp");
+            _default.AddUncountable("tbsp");
+            _default.AddUncountable("ml");
+            _default.AddUncountable("l");
+            _default.AddUncountable("water");
+            _default.AddUncountable("waters");
+            _default.AddUncountable("semen");
+            _default.AddUncountable("sperm");
+            _default.AddUncountable("bison");
+            _default.AddUncountable("grass");
+            _default.AddUncountable("hair");
+            _default.AddUncountable("mud");
+            _default.AddUncountable("elk");
+            _default.AddUncountable("luggage");
+            _default.AddUncountable("moose");
+            _default.AddUncountable("offspring");
+            _default.AddUncountable("salmon");
+            _default.AddUncountable("shrimp");
+            _default.AddUncountable("someone");
+            _default.AddUncountable("swine");
+            _default.AddUncountable("trout");
+            _default.AddUncountable("tuna");
+            _default.AddUncountable("corps");
+            _default.AddUncountable("scissors");
+            _default.AddUncountable("means");
+
+            return _default;
+        }
+    }
+    /// <summary>
+    /// A container for exceptions to simple pluralization/singularization rules.
+    /// Vocabularies.Default contains an extensive list of rules for US English.
+    /// At this time, multiple vocabularies and removing existing rules are not supported.
+    /// </summary>
+    public class Vocabulary
+    {
+        internal Vocabulary()
+        {
+        }
+
+        private readonly List<Rule> _plurals = new List<Rule>();
+        private readonly List<Rule> _singulars = new List<Rule>();
+        private readonly List<string> _uncountables = new List<string>();
+
+        /// <summary>
+        /// Adds a word to the vocabulary which cannot easily be pluralized/singularized by RegEx, e.g. "person" and "people".
+        /// </summary>
+        /// <param name="singular">The singular form of the irregular word, e.g. "person".</param>
+        /// <param name="plural">The plural form of the irregular word, e.g. "people".</param>
+        /// <param name="matchEnding">True to match these words on their own as well as at the end of longer words. False, otherwise.</param>
+        public void AddIrregular(string singular, string plural, bool matchEnding = true)
+        {
+            if (matchEnding)
+            {
+                AddPlural("(" + singular[0] + ")" + singular.Substring(1) + "$", "$1" + plural.Substring(1));
+                AddSingular("(" + plural[0] + ")" + plural.Substring(1) + "$", "$1" + singular.Substring(1));
+            }
+            else
+            {
+                AddPlural($"^{singular}$", plural);
+                AddSingular($"^{plural}$", singular);
+            }
+        }
+
+        /// <summary>
+        /// Adds an uncountable word to the vocabulary, e.g. "fish".  Will be ignored when plurality is changed.
+        /// </summary>
+        /// <param name="word">Word to be added to the list of uncountables.</param>
+        public void AddUncountable(string word)
+        {
+            _uncountables.Add(word.ToLower());
+        }
+
+        /// <summary>
+        /// Adds a rule to the vocabulary that does not follow trivial rules for pluralization, e.g. "bus" -> "buses"
+        /// </summary>
+        /// <param name="rule">RegEx to be matched, case insensitive, e.g. "(bus)es$"</param>
+        /// <param name="replacement">RegEx replacement  e.g. "$1"</param>
+        public void AddPlural(string rule, string replacement)
+        {
+            _plurals.Add(new Rule(rule, replacement));
+        }
+
+        /// <summary>
+        /// Adds a rule to the vocabulary that does not follow trivial rules for singularization, e.g. "vertices/indices -> "vertex/index"
+        /// </summary>
+        /// <param name="rule">RegEx to be matched, case insensitive, e.g. ""(vert|ind)ices$""</param>
+        /// <param name="replacement">RegEx replacement  e.g. "$1ex"</param>
+        public void AddSingular(string rule, string replacement)
+        {
+            _singulars.Add(new Rule(rule, replacement));
+        }
+
+        /// <summary>
+        /// Pluralizes the provided input considering irregular words
+        /// </summary>
+        /// <param name="word">Word to be pluralized</param>
+        /// <param name="inputIsKnownToBeSingular">Normally you call Pluralize on singular words; but if you're unsure call it with false</param>
+        /// <returns></returns>
+        public string Pluralize(string word, bool inputIsKnownToBeSingular = true)
+        {
+            var result = ApplyRules(_plurals, word);
+
+            if (inputIsKnownToBeSingular)
+                return result;
+
+            var asSingular = ApplyRules(_singulars, word);
+            var asSingularAsPlural = ApplyRules(_plurals, asSingular);
+            if (asSingular != null && asSingular != word && asSingular + "s" != word && asSingularAsPlural == word && result != word)
+                return word;
+
+            return result;
+        }
+
+        /// <summary>
+        /// Singularizes the provided input considering irregular words
+        /// </summary>
+        /// <param name="word">Word to be singularized</param>
+        /// <param name="inputIsKnownToBePlural">Normally you call Singularize on plural words; but if you're unsure call it with false</param>
+        /// <returns></returns>
+        public string Singularize(string word, bool inputIsKnownToBePlural = true)
+        {
+            var result = ApplyRules(_singulars, word);
+
+            if (inputIsKnownToBePlural)
+                return result;
+
+            // the Plurality is unknown so we should check all possibilities
+            var asPlural = ApplyRules(_plurals, word);
+            var asPluralAsSingular = ApplyRules(_singulars, asPlural);
+            if (asPlural != word && word + "s" != asPlural && asPluralAsSingular == word && result != word)
+                return word;
+
+            return result ?? word;
+        }
+
+        private string ApplyRules(IList<Rule> rules, string word)
+        {
+            if (word == null)
+                return null;
+
+            if (IsUncountable(word))
+                return word;
+
+            var result = word;
+            for (var i = rules.Count - 1; i >= 0; i--)
+            {
+                if ((result = rules[i].Apply(word)) != null)
+                    break;
+            }
+            return result;
+        }
+
+        private bool IsUncountable(string word)
+        {
+            return _uncountables.Contains(word.ToLower());
+        }
+
+        private class Rule
+        {
+            private readonly Regex _regex;
+            private readonly string _replacement;
+
+            public Rule(string pattern, string replacement)
+            {
+                _regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
+                _replacement = replacement;
+            }
+
+            public string Apply(string word)
+            {
+                if (!_regex.IsMatch(word))
+                    return null;
+
+                return _regex.Replace(word, _replacement);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Inflector extensions
+    /// </summary>
+    public static class InflectorExtensions
+    {
+        /// <summary>
+        /// Pluralizes the provided input considering irregular words
+        /// </summary>
+        /// <param name="word">Word to be pluralized</param>
+        /// <param name="inputIsKnownToBeSingular">Normally you call Pluralize on singular words; but if you're unsure call it with false</param>
+        /// <returns></returns>
+        public static string Pluralize(this string word, bool inputIsKnownToBeSingular = true)
+        {
+            return Vocabularies.Default.Pluralize(word, inputIsKnownToBeSingular);
+        }
+
+        /// <summary>
+        /// Singularizes the provided input considering irregular words
+        /// </summary>
+        /// <param name="word">Word to be singularized</param>
+        /// <param name="inputIsKnownToBePlural">Normally you call Singularize on plural words; but if you're unsure call it with false</param>
+        /// <returns></returns>
+        public static string Singularize(this string word, bool inputIsKnownToBePlural = true)
+        {
+            return Vocabularies.Default.Singularize(word, inputIsKnownToBePlural);
+        }
+
+        /// <summary>
+        /// By default, pascalize converts strings to UpperCamelCase also removing underscores
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public static string Pascalize(this string input)
+        {
+            return Regex.Replace(input, "(?:^|_)(.)", match => match.Groups[1].Value.ToUpper());
+        }
+
+        /// <summary>
+        /// Same as Pascalize except that the first character is lower case
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public static string Camelize(this string input)
+        {
+            var word = Pascalize(input);
+            return word.Substring(0, 1).ToLower() + word.Substring(1);
+        }
+
+        /// <summary>
+        /// Separates the input words with underscore
+        /// </summary>
+        /// <param name="input">The string to be underscored</param>
+        /// <returns></returns>
+        public static string Underscore(this string input)
+        {
+            return Regex.Replace(
+                Regex.Replace(
+                    Regex.Replace(input, @"([A-Z]+)([A-Z][a-z])", "$1_$2"), @"([a-z\d])([A-Z])", "$1_$2"), @"[-\s]", "_").ToLower();
+        }
+
+        /// <summary>
+        /// Replaces underscores with dashes in the string
+        /// </summary>
+        /// <param name="underscoredWord"></param>
+        /// <returns></returns>
+        public static string Dasherize(this string underscoredWord)
+        {
+            return underscoredWord.Replace('_', '-');
+        }
+
+        /// <summary>
+        /// Replaces underscores with hyphens in the string
+        /// </summary>
+        /// <param name="underscoredWord"></param>
+        /// <returns></returns>
+        public static string Hyphenate(this string underscoredWord)
+        {
+            return Dasherize(underscoredWord);
+        }
+    }
+}

MongoDbGenericRepository/Properties/AssemblyInfo.cs

@@ -1,35 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following 
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("MongoDbGenericRepository")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("MongoDbGenericRepository")]
-[assembly: AssemblyCopyright("Copyright ©  2016")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("d154e7d0-9a3c-43ab-8e90-ed92bc4343f0")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Revision and Build Numbers 
-// by using the '*' as shown below:
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]

MongoDbGenericRepository/Web.Debug.config

@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<!-- For more information on using web.config transformation visit http://go.microsoft.com/fwlink/?LinkId=125889 -->
-
-<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
-  <!--
-    In the example below, the "SetAttributes" transform will change the value of 
-    "connectionString" to use "ReleaseSQLServer" only when the "Match" locator 
-    finds an attribute "name" that has a value of "MyDB".
-    
-    <connectionStrings>
-      <add name="MyDB" 
-        connectionString="Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;Integrated Security=True" 
-        xdt:Transform="SetAttributes" xdt:Locator="Match(name)"/>
-    </connectionStrings>
-  -->
-  <system.web>
-    <!--
-      In the example below, the "Replace" transform will replace the entire 
-      <customErrors> section of your web.config file.
-      Note that because there is only one customErrors section under the 
-      <system.web> node, there is no need to use the "xdt:Locator" attribute.
-      
-      <customErrors defaultRedirect="GenericError.htm"
-        mode="RemoteOnly" xdt:Transform="Replace">
-        <error statusCode="500" redirect="InternalError.htm"/>
-      </customErrors>
-    -->
-  </system.web>
-</configuration>

MongoDbGenericRepository/Web.Release.config

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<!-- For more information on using web.config transformation visit http://go.microsoft.com/fwlink/?LinkId=125889 -->
-
-<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
-  <!--
-    In the example below, the "SetAttributes" transform will change the value of 
-    "connectionString" to use "ReleaseSQLServer" only when the "Match" locator 
-    finds an attribute "name" that has a value of "MyDB".
-    
-    <connectionStrings>
-      <add name="MyDB" 
-        connectionString="Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;Integrated Security=True" 
-        xdt:Transform="SetAttributes" xdt:Locator="Match(name)"/>
-    </connectionStrings>
-  -->
-  <system.web>
-    <compilation xdt:Transform="RemoveAttributes(debug)" />
-    <!--
-      In the example below, the "Replace" transform will replace the entire 
-      <customErrors> section of your web.config file.
-      Note that because there is only one customErrors section under the 
-      <system.web> node, there is no need to use the "xdt:Locator" attribute.
-      
-      <customErrors defaultRedirect="GenericError.htm"
-        mode="RemoteOnly" xdt:Transform="Replace">
-        <error statusCode="500" redirect="InternalError.htm"/>
-      </customErrors>
-    -->
-  </system.web>
-</configuration>

MongoDbGenericRepository/Web.config

@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  For more information on how to configure your ASP.NET application, please visit
-  http://go.microsoft.com/fwlink/?LinkId=169433
-  -->
-<configuration>
-  <system.web>
-    <compilation debug="true" targetFramework="4.5.2" />
-    <httpRuntime targetFramework="4.5.2" />
-    <httpModules>
-    </httpModules>
-  </system.web>
-  <system.webServer>
-    <validation validateIntegratedModeConfiguration="false" />
-    <modules>
-    </modules>
-  </system.webServer>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="System.Runtime.InteropServices.RuntimeInformation" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-4.0.1.0" newVersion="4.0.1.0" />
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
-  <system.codedom>
-    <compilers>
-      <compiler language="c#;cs;csharp" extension=".cs" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.7.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:6 /nowarn:1659;1699;1701" />
-      <compiler language="vb;vbs;visualbasic;vbscript" extension=".vb" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.7.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:14 /nowarn:41008 /define:_MYTYPE=\&quot;Web\&quot; /optionInfer+" />
-    </compilers>
-  </system.codedom>
-</configuration>

MongoDbGenericRepository/_rels/.rels

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+    <Relationship Type="http://schemas.microsoft.com/packaging/2010/07/manifest" Target="/MongoDbGenericRepository.nuspec" Id="Rd7ba7aa97a7d4fb2" />
+    <Relationship Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="/package/services/metadata/core-properties/e5080d3094a649a39d247315f4dcd1ba.psmdcp" Id="Rcfffb2818c774b93" />
+</Relationships>

MongoDbGenericRepository/bin/ApplicationInsights.config

@@ -1,3 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<ApplicationInsights xmlns="http://schemas.microsoft.com/ApplicationInsights/2013/Settings">
-</ApplicationInsights>

MongoDbGenericRepository/bin/Microsoft.CodeDom.Providers.DotNetCompilerPlatform.xml

@@ -1,40 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>Microsoft.CodeDom.Providers.DotNetCompilerPlatform</name>
-    </assembly>
-    <members>
-        <member name="T:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider">
-            <summary>
-            Provides access to instances of the .NET Compiler Platform C# code generator and code compiler.
-            </summary>
-        </member>
-        <member name="M:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider.#ctor">
-            <summary>
-            Default Constructor
-            </summary>
-        </member>
-        <member name="M:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider.CreateCompiler">
-            <summary>
-            Gets an instance of the .NET Compiler Platform C# code compiler.
-            </summary>
-            <returns>An instance of the .NET Compiler Platform C# code compiler</returns>
-        </member>
-        <member name="T:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider">
-            <summary>
-            Provides access to instances of the .NET Compiler Platform VB code generator and code compiler.
-            </summary>
-        </member>
-        <member name="M:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider.#ctor">
-            <summary>
-            Default Constructor
-            </summary>
-        </member>
-        <member name="M:Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider.CreateCompiler">
-            <summary>
-            Gets an instance of the .NET Compiler Platform VB code compiler.
-            </summary>
-            <returns>An instance of the .NET Compiler Platform VB code compiler</returns>
-        </member>
-    </members>
-</doc>

MongoDbGenericRepository/bin/MongoDbGenericRepository.dll.config

@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  For more information on how to configure your ASP.NET application, please visit
-  http://go.microsoft.com/fwlink/?LinkId=169433
-  -->
-<configuration>
-  <system.web>
-    <compilation debug="true" targetFramework="4.5.2" />
-    <httpRuntime targetFramework="4.5.2" />
-    <httpModules>
-    </httpModules>
-  </system.web>
-  <system.webServer>
-    <validation validateIntegratedModeConfiguration="false" />
-    <modules>
-    </modules>
-  </system.webServer>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="System.Runtime.InteropServices.RuntimeInformation" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-4.0.1.0" newVersion="4.0.1.0" />
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
-  <system.codedom>
-    <compilers>
-      <compiler language="c#;cs;csharp" extension=".cs" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.7.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:6 /nowarn:1659;1699;1701" />
-      <compiler language="vb;vbs;visualbasic;vbscript" extension=".vb" type="Microsoft.CodeDom.Providers.DotNetCompilerPlatform.VBCodeProvider, Microsoft.CodeDom.Providers.DotNetCompilerPlatform, Version=1.0.7.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" warningLevel="4" compilerOptions="/langversion:14 /nowarn:41008 /define:_MYTYPE=\&quot;Web\&quot; /optionInfer+" />
-    </compilers>
-  </system.codedom>
-</configuration>

MongoDbGenericRepository/bin/roslyn/Microsoft.CSharp.Core.targets

@@ -1,165 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (c)  Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information. -->
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Target Name="ShimReferencePathsWhenCommonTargetsDoesNotUnderstandReferenceAssemblies"
-          BeforeTargets="CoreCompile"
-          Condition="'@(ReferencePathWithRefAssemblies)' == ''">
-    <!-- Common targets should populate this item from dev15.3, but this file
-         may be used (via NuGet package) on earlier MSBuilds. If the
-         adjusted-for-reference-assemblies item is not populated, just use
-         the older item's contents. -->
-    <ItemGroup>
-      <ReferencePathWithRefAssemblies Include="@(ReferencePath)" />
-    </ItemGroup>
-  </Target>
-
-  <Target Name="CoreCompile"
-          Inputs="$(MSBuildAllProjects);
-                  @(Compile);
-                  @(_CoreCompileResourceInputs);
-                  $(ApplicationIcon);
-                  $(AssemblyOriginatorKeyFile);
-                  @(ReferencePathWithRefAssemblies);
-                  @(CompiledLicenseFile);
-                  @(LinkResource);
-                  @(EmbeddedDocumentation);
-                  $(Win32Resource);
-                  $(Win32Manifest);
-                  @(CustomAdditionalCompileInputs);
-                  $(ResolvedCodeAnalysisRuleSet);
-                  @(AdditionalFiles);
-                  @(EmbeddedFiles)"
-          Outputs="@(DocFileItem);
-                   @(IntermediateAssembly);
-                   @(IntermediateRefAssembly);
-                   @(_DebugSymbolsIntermediatePath);
-                   $(NonExistentFile);
-                   @(CustomAdditionalCompileOutputs)"
-          Returns="@(CscCommandLineArgs)"
-          DependsOnTargets="$(CoreCompileDependsOn)">
-    <!-- These two compiler warnings are raised when a reference is bound to a different version
-             than specified in the assembly reference version number.  MSBuild raises the same warning in this case,
-             so the compiler warning would be redundant. -->
-    <PropertyGroup Condition="('$(TargetFrameworkVersion)' != 'v1.0') and ('$(TargetFrameworkVersion)' != 'v1.1')">
-      <NoWarn>$(NoWarn);1701;1702</NoWarn>
-    </PropertyGroup>
-
-    <PropertyGroup>
-      <!-- To match historical behavior, when inside VS11+ disable the warning from csc.exe indicating that no sources were passed in-->
-      <NoWarn Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '$(VisualStudioVersion)' != '' AND '$(VisualStudioVersion)' &gt; '10.0'">$(NoWarn);2008</NoWarn>
-    </PropertyGroup>
-
-    <ItemGroup Condition="'$(TargetingClr2Framework)' == 'true'">
-      <ReferencePathWithRefAssemblies>
-        <EmbedInteropTypes />
-      </ReferencePathWithRefAssemblies>
-    </ItemGroup>
-
-    <PropertyGroup>
-      <!-- If the user has specified AppConfigForCompiler, we'll use it. If they have not, but they set UseAppConfigForCompiler,
-                 then we'll use AppConfig -->
-      <AppConfigForCompiler Condition="'$(AppConfigForCompiler)' == '' AND '$(UseAppConfigForCompiler)' == 'true'">$(AppConfig)</AppConfigForCompiler>
-
-      <!-- If we are targeting winmdobj we want to specifically the pdbFile property since we do not want it to collide with the output of winmdexp-->
-      <PdbFile Condition="'$(PdbFile)' == '' AND '$(OutputType)' == 'winmdobj' AND '$(_DebugSymbolsProduced)' == 'true'">$(IntermediateOutputPath)$(TargetName).compile.pdb</PdbFile>
-    </PropertyGroup>
-
-    <!-- Prefer32Bit was introduced in .NET 4.5. Set it to false if we are targeting 4.0 -->
-    <PropertyGroup Condition="('$(TargetFrameworkVersion)' == 'v4.0')">
-      <Prefer32Bit>false</Prefer32Bit>
-    </PropertyGroup>
-
-    <!-- TODO: Remove this ItemGroup once it has been moved to "_GenerateCompileInputs" target in Microsoft.Common.CurrentVersion.targets.
-         https://github.com/dotnet/roslyn/issues/12223 -->
-    <ItemGroup Condition="('$(AdditionalFileItemNames)' != '')">
-      <AdditionalFileItems Include="$(AdditionalFileItemNames)" />
-      <AdditionalFiles Include="@(%(AdditionalFileItems.Identity))" />
-    </ItemGroup>
-
-    <PropertyGroup Condition="'$(UseSharedCompilation)' == ''">
-      <UseSharedCompilation>true</UseSharedCompilation>
-    </PropertyGroup>
-
-    <!-- Condition is to filter out the _CoreCompileResourceInputs so that it doesn't pass in culture resources to the compiler -->
-    <Csc Condition="'%(_CoreCompileResourceInputs.WithCulture)' != 'true'"
-         AdditionalLibPaths="$(AdditionalLibPaths)"
-         AddModules="@(AddModules)"
-         AdditionalFiles="@(AdditionalFiles)"
-         AllowUnsafeBlocks="$(AllowUnsafeBlocks)"
-         Analyzers="@(Analyzer)"
-         ApplicationConfiguration="$(AppConfigForCompiler)"
-         BaseAddress="$(BaseAddress)"
-         CheckForOverflowUnderflow="$(CheckForOverflowUnderflow)"
-         ChecksumAlgorithm="$(ChecksumAlgorithm)"
-         CodeAnalysisRuleSet="$(ResolvedCodeAnalysisRuleSet)"
-         CodePage="$(CodePage)"
-         DebugType="$(DebugType)"
-         DefineConstants="$(DefineConstants)"
-         DelaySign="$(DelaySign)"
-         DisabledWarnings="$(NoWarn)"
-         DocumentationFile="@(DocFileItem)"
-         EmbeddedFiles="@(EmbeddedFiles)"
-         EmitDebugInformation="$(DebugSymbols)"
-         EnvironmentVariables="$(CscEnvironment)"
-         ErrorEndLocation="$(ErrorEndLocation)"
-         ErrorLog="$(ErrorLog)"
-         ErrorReport="$(ErrorReport)"
-         Features="$(Features)"
-         FileAlignment="$(FileAlignment)"
-         GenerateFullPaths="$(GenerateFullPaths)"
-         HighEntropyVA="$(HighEntropyVA)"
-         Instrument="$(Instrument)"
-         KeyContainer="$(KeyContainerName)"
-         KeyFile="$(KeyOriginatorFile)"
-         LangVersion="$(LangVersion)"
-         LinkResources="@(LinkResource)"
-         MainEntryPoint="$(StartupObject)"
-         ModuleAssemblyName="$(ModuleAssemblyName)"
-         NoConfig="true"
-         NoLogo="$(NoLogo)"
-         NoStandardLib="$(NoCompilerStandardLib)"
-         NoWin32Manifest="$(NoWin32Manifest)"
-         Optimize="$(Optimize)"
-         Deterministic="$(Deterministic)"
-         PublicSign="$(PublicSign)"
-         OutputAssembly="@(IntermediateAssembly)"
-         OutputRefAssembly="@(IntermediateRefAssembly)"
-         PdbFile="$(PdbFile)"
-         Platform="$(PlatformTarget)"
-         Prefer32Bit="$(Prefer32Bit)"
-         PreferredUILang="$(PreferredUILang)"
-         ProvideCommandLineArgs="$(ProvideCommandLineArgs)"
-         References="@(ReferencePathWithRefAssemblies)"
-         ReportAnalyzer="$(ReportAnalyzer)"
-         Resources="@(_CoreCompileResourceInputs);@(CompiledLicenseFile)"
-         ResponseFiles="$(CompilerResponseFile)"
-         RuntimeMetadataVersion="$(RuntimeMetadataVersion)"
-         SkipCompilerExecution="$(SkipCompilerExecution)"
-         Sources="@(Compile)"
-         SubsystemVersion="$(SubsystemVersion)"
-         TargetType="$(OutputType)"
-         ToolExe="$(CscToolExe)"
-         ToolPath="$(CscToolPath)"
-         TreatWarningsAsErrors="$(TreatWarningsAsErrors)"
-         UseHostCompilerIfAvailable="$(UseHostCompilerIfAvailable)"
-         UseSharedCompilation="$(UseSharedCompilation)"
-         Utf8Output="$(Utf8Output)"
-         VsSessionGuid="$(VsSessionGuid)"
-         WarningLevel="$(WarningLevel)"
-         WarningsAsErrors="$(WarningsAsErrors)"
-         WarningsNotAsErrors="$(WarningsNotAsErrors)"
-         Win32Icon="$(ApplicationIcon)"
-         Win32Manifest="$(Win32Manifest)"
-         Win32Resource="$(Win32Resource)"
-         PathMap="$(PathMap)"
-         SourceLink="$(SourceLink)">
-      <Output TaskParameter="CommandLineArgs" ItemName="CscCommandLineArgs" />
-    </Csc>
-
-    <ItemGroup>
-      <_CoreCompileResourceInputs Remove="@(_CoreCompileResourceInputs)" />
-    </ItemGroup>
-
-    <CallTarget Targets="$(TargetsTriggeredByCompilation)" Condition="'$(TargetsTriggeredByCompilation)' != ''" />
-  </Target>
-</Project>

MongoDbGenericRepository/bin/roslyn/Microsoft.VisualBasic.Core.targets

@@ -1,162 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (c)  Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information. -->
-<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Target Name="ShimReferencePathsWhenCommonTargetsDoesNotUnderstandReferenceAssemblies"
-          BeforeTargets="CoreCompile"
-          Condition="'@(ReferencePathWithRefAssemblies)' == ''">
-    <!-- Common targets should populate this item from dev15.3, but this file
-         may be used (via NuGet package) on earlier MSBuilds. If the
-         adjusted-for-reference-assemblies item is not populated, just use
-         the older item's contents. -->
-    <ItemGroup>
-      <ReferencePathWithRefAssemblies Include="@(ReferencePath)" />
-    </ItemGroup>
-  </Target>
-
-  <Target Name="CoreCompile"
-          Inputs="$(MSBuildAllProjects);
-                  @(Compile);
-                  @(_CoreCompileResourceInputs);
-                  $(ApplicationIcon);
-                  $(AssemblyOriginatorKeyFile);
-                  @(ReferencePathWithRefAssemblies);
-                  @(CompiledLicenseFile);
-                  @(LinkResource);
-                  @(EmbeddedDocumentation);
-                  $(Win32Resource);
-                  $(Win32Manifest);
-                  @(CustomAdditionalCompileInputs);
-                  $(ResolvedCodeAnalysisRuleSet);
-                  @(AdditionalFiles);
-                  @(EmbeddedFiles)"
-          Outputs="@(DocFileItem);
-                   @(IntermediateAssembly);
-                   @(IntermediateRefAssembly);
-                   @(_DebugSymbolsIntermediatePath);
-                   $(NonExistentFile);
-                   @(CustomAdditionalCompileOutputs)"
-          Returns="@(VbcCommandLineArgs)"
-          DependsOnTargets="$(CoreCompileDependsOn)">
-    <PropertyGroup>
-      <_NoWarnings Condition="'$(WarningLevel)' == '0'">true</_NoWarnings>
-      <_NoWarnings Condition="'$(WarningLevel)' == '1'">false</_NoWarnings>
-    </PropertyGroup>
-
-    <PropertyGroup>
-      <!-- If we are targeting winmdobj we want to specifically the pdbFile property since we do not want it to collide with the output of winmdexp-->
-      <PdbFile Condition="'$(PdbFile)' == '' AND '$(OutputType)' == 'winmdobj' AND '$(DebugSymbols)' == 'true'">$(IntermediateOutputPath)$(TargetName).compile.pdb</PdbFile>
-    </PropertyGroup>
-
-    <ItemGroup Condition="'$(TargetingClr2Framework)' == 'true'">
-      <ReferencePathWithRefAssemblies>
-        <EmbedInteropTypes />
-      </ReferencePathWithRefAssemblies>
-    </ItemGroup>
-
-    <!-- Prefer32Bit was introduced in .NET 4.5. Set it to false if we are targeting 4.0 -->
-    <PropertyGroup Condition="('$(TargetFrameworkVersion)' == 'v4.0')">
-      <Prefer32Bit>false</Prefer32Bit>
-    </PropertyGroup>
-
-    <!-- TODO: Remove this ItemGroup once it has been moved to "_GenerateCompileInputs" target in Microsoft.Common.CurrentVersion.targets.
-         https://github.com/dotnet/roslyn/issues/12223 -->
-    <ItemGroup Condition="('$(AdditionalFileItemNames)' != '')">
-      <AdditionalFileItems Include="$(AdditionalFileItemNames)" />
-      <AdditionalFiles Include="@(%(AdditionalFileItems.Identity))" />
-    </ItemGroup>
-
-    <PropertyGroup Condition="'$(UseSharedCompilation)' == ''">
-      <UseSharedCompilation>true</UseSharedCompilation>
-    </PropertyGroup>
-
-    <!-- Condition is to filter out the _CoreCompileResourceInputs so that it doesn't pass in culture resources to the compiler -->
-    <Vbc Condition="'%(_CoreCompileResourceInputs.WithCulture)' != 'true'"
-         AdditionalLibPaths="$(AdditionalLibPaths)"
-         AddModules="@(AddModules)"
-         AdditionalFiles="@(AdditionalFiles)"
-         Analyzers="@(Analyzer)"
-         BaseAddress="$(BaseAddress)"
-         ChecksumAlgorithm="$(ChecksumAlgorithm)"
-         CodeAnalysisRuleSet="$(ResolvedCodeAnalysisRuleSet)"
-         CodePage="$(CodePage)"
-         DebugType="$(DebugType)"
-         DefineConstants="$(FinalDefineConstants)"
-         DelaySign="$(DelaySign)"
-         DisabledWarnings="$(NoWarn)"
-         DocumentationFile="@(DocFileItem)"
-         EmbeddedFiles="@(EmbeddedFiles)"
-         EmitDebugInformation="$(DebugSymbols)"
-         EnvironmentVariables="$(VbcEnvironment)"
-         ErrorLog="$(ErrorLog)"
-         ErrorReport="$(ErrorReport)"
-         Features="$(Features)"
-         FileAlignment="$(FileAlignment)"
-         GenerateDocumentation="$(GenerateDocumentation)"
-         HighEntropyVA="$(HighEntropyVA)"
-         Imports="@(Import)"
-         Instrument="$(Instrument)"
-         KeyContainer="$(KeyContainerName)"
-         KeyFile="$(KeyOriginatorFile)"
-         LangVersion="$(LangVersion)"
-         LinkResources="@(LinkResource)"
-         MainEntryPoint="$(StartupObject)"
-         ModuleAssemblyName="$(ModuleAssemblyName)"
-         NoConfig="true"
-         NoStandardLib="$(NoCompilerStandardLib)"
-         NoVBRuntimeReference="$(NoVBRuntimeReference)"
-         NoWarnings="$(_NoWarnings)"
-         NoWin32Manifest="$(NoWin32Manifest)"
-         Optimize="$(Optimize)"
-         Deterministic="$(Deterministic)"
-         PublicSign="$(PublicSign)"
-         OptionCompare="$(OptionCompare)"
-         OptionExplicit="$(OptionExplicit)"
-         OptionInfer="$(OptionInfer)"
-         OptionStrict="$(OptionStrict)"
-         OptionStrictType="$(OptionStrictType)"
-         OutputAssembly="@(IntermediateAssembly)"
-         OutputRefAssembly="@(IntermediateRefAssembly)"
-         PdbFile="$(PdbFile)"
-         Platform="$(PlatformTarget)"
-         Prefer32Bit="$(Prefer32Bit)"
-         PreferredUILang="$(PreferredUILang)"
-         ProvideCommandLineArgs="$(ProvideCommandLineArgs)"
-         References="@(ReferencePathWithRefAssemblies)"
-         RemoveIntegerChecks="$(RemoveIntegerChecks)"
-         ReportAnalyzer="$(ReportAnalyzer)"
-         Resources="@(_CoreCompileResourceInputs);@(CompiledLicenseFile)"
-         ResponseFiles="$(CompilerResponseFile)"
-         RootNamespace="$(RootNamespace)"
-         RuntimeMetadataVersion="$(RuntimeMetadataVersion)"
-         SdkPath="$(FrameworkPathOverride)"
-         SkipCompilerExecution="$(SkipCompilerExecution)"
-         Sources="@(Compile)"
-         SubsystemVersion="$(SubsystemVersion)"
-         TargetCompactFramework="$(TargetCompactFramework)"
-         TargetType="$(OutputType)"
-         ToolExe="$(VbcToolExe)"
-         ToolPath="$(VbcToolPath)"
-         TreatWarningsAsErrors="$(TreatWarningsAsErrors)"
-         UseHostCompilerIfAvailable="$(UseHostCompilerIfAvailable)"
-         UseSharedCompilation="$(UseSharedCompilation)"
-         Utf8Output="$(Utf8Output)"
-         VBRuntimePath="$(VBRuntimePath)"
-         Verbosity="$(VbcVerbosity)"
-         VsSessionGuid="$(VsSessionGuid)"
-         WarningsAsErrors="$(WarningsAsErrors)"
-         WarningsNotAsErrors="$(WarningsNotAsErrors)"
-         Win32Icon="$(ApplicationIcon)"
-         Win32Manifest="$(Win32Manifest)"
-         Win32Resource="$(Win32Resource)"
-         VBRuntime="$(VBRuntime)"
-         PathMap="$(PathMap)"
-         SourceLink="$(SourceLink)">
-      <Output TaskParameter="CommandLineArgs" ItemName="VbcCommandLineArgs" />
-    </Vbc>
-    <ItemGroup>
-      <_CoreCompileResourceInputs Remove="@(_CoreCompileResourceInputs)" />
-    </ItemGroup>
-
-    <CallTarget Targets="$(TargetsTriggeredByCompilation)" Condition="'$(TargetsTriggeredByCompilation)' != ''" />
-  </Target>
-</Project>