Added tests

IntegrationTests/CreateTKeyPartitionedTests.cs

@@ -0,0 +1,77 @@
+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/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/IntegrationTests.csproj

@@ -52,7 +52,11 @@
     </Reference>
   </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="Infrastructure\BaseMongoDbRepositoryTests.cs" />
     <Compile Include="CreatePartitionedTests.cs" />
@@ -60,6 +64,7 @@
     <Compile Include="Infrastructure\TestRepository.cs" />
     <Compile Include="CreateTests.cs" />
     <Compile Include="ProjectPartitionedTests.cs" />
+    <Compile Include="ProjectTKeyTests.cs" />
     <Compile Include="ProjectTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ReadPartitionedTests.cs" />

IntegrationTests/ProjectTKeyTests.cs

@@ -0,0 +1,152 @@
+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);
+        }
+    }
+}

MongoDbGenericRepository/BaseMongoDbRepository.cs

@@ -31,6 +31,34 @@ namespace MongoDbGenericRepository
         /// <param name="document">The document you want to add.</param>
         Task AddOneAsync<TDocument>(TDocument document) where TDocument : IDocument;
 
+        /// <summary>
+        /// Adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        void AddOne<TDocument>(TDocument document) where TDocument : IDocument;
+
+        /// <summary>
+        /// Asynchronously adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The document you want to add.</param>
+        Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument;
+
+        /// <summary>
+        /// Adds a list of documents to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="documents">The document you want to add.</param>
+        void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument;
+
+        #endregion
+
+        #region Create TKey
+
         /// <summary>
         /// Asynchronously adds a document to the collection.
         /// Populates the Id and AddedAtUtc fields if necessary.
@@ -42,14 +70,6 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
-        /// <summary>
-        /// Adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        void AddOne<TDocument>(TDocument document) where TDocument : IDocument;
-
         /// <summary>
         /// Adds a document to the collection.
         /// Populates the Id and AddedAtUtc fields if necessary.
@@ -66,16 +86,22 @@ namespace MongoDbGenericRepository
         /// Populates the Id and AddedAtUtc fields if necessary.
         /// </summary>
         /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The document you want to add.</param>
-        Task AddManyAsync<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument;
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        Task AddManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
 
         /// <summary>
         /// Adds a list of documents to the collection.
         /// Populates the Id and AddedAtUtc fields if necessary.
         /// </summary>
         /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <param name="documents">The document you want to add.</param>
-        void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument;
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The documents you want to add.</param>
+        void AddMany<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
 
         #endregion
 
@@ -171,6 +197,134 @@ namespace MongoDbGenericRepository
 
         #endregion
 
+        #region Read TKey
+
+        /// <summary>
+        /// Asynchronously returns one document given its id.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="id">The Id of the document you want to get.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<TDocument> GetByIdAsync<TDocument, TKey>(Guid id, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns one document given its id.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="id">The Id of the document you want to get.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TDocument GetById<TDocument, TKey>(Guid id, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously returns one document given an expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<TDocument> GetOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns one document given an expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+
+        /// <summary>
+        /// Returns a collection cursor.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+
+        /// <summary>
+        /// Returns true if any of the document of the collection matches the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<bool> AnyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns true if any of the document of the collection matches the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        bool Any<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously returns a list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<List<TDocument>> GetAllAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Returns a list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        List<TDocument> GetAll<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously counts how many documents match the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partitionKey</param>
+        Task<long> CountAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Counts how many documents match the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partitionKey</param>
+        long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        #endregion
+
+
         #region Update
 
         /// <summary>
@@ -189,6 +343,30 @@ namespace MongoDbGenericRepository
 
         #endregion
 
+        #region Update TKey
+
+        /// <summary>
+        /// Asynchronously Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument modifiedDocument)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Updates a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
+        bool UpdateOne<TDocument, TKey>(TDocument modifiedDocument)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        #endregion
+
         #region Delete
 
         /// <summary>
@@ -259,6 +437,90 @@ namespace MongoDbGenericRepository
         /// <returns>The number of documents deleted.</returns>
         long DeleteMany<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
 
+        #endregion
+
+        #region Delete TKey
+
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteOneAsync<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteManyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Asynchronously deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
         /// <summary>
         /// Deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
@@ -273,6 +535,7 @@ namespace MongoDbGenericRepository
 
         #endregion
 
+
         #region Project
 
         /// <summary>
@@ -485,21 +748,6 @@ namespace MongoDbGenericRepository
             await HandlePartitioned(document).InsertOneAsync(document);
         }
 
-        /// <summary>
-        /// Asynchronously adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public async Task AddOneAsync<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            FormatDocument<TDocument, TKey>(document);
-            await HandlePartitioned<TDocument, TKey>(document).InsertOneAsync(document);
-        }
-
         /// <summary>
         /// Adds a document to the collection.
         /// Populates the Id and AddedAtUtc fields if necessary.
@@ -512,21 +760,6 @@ namespace MongoDbGenericRepository
             HandlePartitioned(document).InsertOne(document);
         }
 
-        /// <summary>
-        /// Adds a document to the collection.
-        /// Populates the Id and AddedAtUtc fields if necessary.
-        /// </summary>
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
-        /// <param name="document">The document you want to add.</param>
-        public void AddOne<TDocument, TKey>(TDocument document)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            FormatDocument<TDocument, TKey>(document);
-            HandlePartitioned<TDocument, TKey>(document).InsertOne(document);
-        }
-
         /// <summary>
         /// Asynchronously adds a list of documents to the collection.
         /// Populates the Id and AddedAtUtc fields if necessary.
@@ -546,6 +779,59 @@ namespace MongoDbGenericRepository
             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">The type representing a Document.</typeparam>
+        /// <param name="documents">The documents 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 Create TKey
+
+        /// <summary>
+        /// Asynchronously adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public async Task AddOneAsync<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            FormatDocument<TDocument, TKey>(document);
+            await HandlePartitioned<TDocument, TKey>(document).InsertOneAsync(document);
+        }
+
+        /// <summary>
+        /// Adds a document to the collection.
+        /// Populates the Id and AddedAtUtc fields if necessary.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to add.</param>
+        public void AddOne<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            FormatDocument<TDocument, TKey>(document);
+            HandlePartitioned<TDocument, TKey>(document).InsertOne(document);
+        }
+
         /// <summary>
         /// Asynchronously adds a list of documents to the collection.
         /// Populates the Id and AddedAtUtc fields if necessary.
@@ -573,8 +859,11 @@ namespace MongoDbGenericRepository
         /// Populates the Id and AddedAtUtc fields if necessary.
         /// </summary>
         /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="documents">The documents you want to add.</param>
-        public void AddMany<TDocument>(IEnumerable<TDocument> documents) where TDocument : IDocument
+        public void AddMany<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             if (!documents.Any())
             {
@@ -582,12 +871,13 @@ namespace MongoDbGenericRepository
             }
             foreach (var document in documents)
             {
-                FormatDocument(document);
+                FormatDocument<TDocument, TKey>(document);
             }
-            HandlePartitioned(documents.FirstOrDefault()).InsertMany(documents.ToList());
+            HandlePartitioned<TDocument, TKey>(documents.FirstOrDefault()).InsertMany(documents.ToList());
         }
 
-        #endregion Create
+
+        #endregion 
 
         #region Read
 
@@ -728,7 +1018,8 @@ namespace MongoDbGenericRepository
         /// <param name="id">The Id of the document you want to get.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public async Task<TDocument> GetByIdAsync<TDocument, TKey>(Guid id, string partitionKey = null)
-            where TDocument : IDocument<TKey>
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             var filter = Builders<TDocument>.Filter.Eq("Id", id);
             return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefaultAsync();
@@ -742,7 +1033,8 @@ namespace MongoDbGenericRepository
         /// <param name="id">The Id of the document you want to get.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public TDocument GetById<TDocument, TKey>(Guid id, string partitionKey = null)
-        public TDocument GetById<TDocument, TKey>(Guid id, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             var filter = Builders<TDocument>.Filter.Eq("Id", id);
             return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefault();
@@ -756,7 +1048,8 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public async Task<TDocument> GetOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-        /// <param name="partitionKey">An optional partition key.</param>
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefaultAsync();
         }
@@ -769,7 +1062,8 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-        /// <param name="filter">A LINQ expression filter.</param>
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefault();
         }
@@ -782,7 +1076,8 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter);
         }
@@ -795,7 +1090,8 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public async Task<bool> AnyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             var count = await HandlePartitioned<TDocument, TKey>(partitionKey).CountAsync(filter);
             return (count > 0);
@@ -809,7 +1105,8 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public bool Any<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-        /// </summary>
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             var count = HandlePartitioned<TDocument, TKey>(partitionKey).Count(filter);
             return (count > 0);
@@ -823,7 +1120,8 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public async Task<List<TDocument>> GetAllAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-        /// Asynchronously returns a list of the documents matching the filter condition.
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             return await HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).ToListAsync();
         }
@@ -836,7 +1134,8 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partition key.</param>
         public List<TDocument> GetAll<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-        /// <summary>
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).ToList();
         }
@@ -849,7 +1148,8 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partitionKey</param>
         public async Task<long> CountAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             return await HandlePartitioned<TDocument, TKey>(partitionKey).CountAsync(filter);
         }
@@ -862,7 +1162,8 @@ namespace MongoDbGenericRepository
         /// <param name="filter">A LINQ expression filter.</param>
         /// <param name="partitionKey">An optional partitionKey</param>
         public long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
-        }
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).Count();
         }
@@ -904,7 +1205,8 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
         public async Task<bool> UpdateOneAsync<TDocument, TKey>(TDocument modifiedDocument)
-        #endregion Update
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             var filter = Builders<TDocument>.Filter.Eq("Id", modifiedDocument.Id);
             var updateRes = await HandlePartitioned<TDocument, TKey>(modifiedDocument).ReplaceOneAsync(filter, modifiedDocument);
@@ -918,7 +1220,8 @@ namespace MongoDbGenericRepository
         /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
         /// <param name="modifiedDocument">The document with the modifications you want to persist.</param>
         public bool UpdateOne<TDocument, TKey>(TDocument modifiedDocument)
-            var filter = Builders<TDocument>.Filter.Eq("Id", modifiedDocument.Id);
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
         {
             var filter = Builders<TDocument>.Filter.Eq("Id", modifiedDocument.Id);
             var updateRes = HandlePartitioned<TDocument, TKey>(modifiedDocument).ReplaceOne(filter, modifiedDocument);
@@ -1019,6 +1322,116 @@ namespace MongoDbGenericRepository
             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">The type representing a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public long DeleteMany<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
+        {
+            return HandlePartitioned<TDocument>(partitionKey).DeleteMany(filter).DeletedCount;
+        }
+
+        #endregion Delete
+
+        #region Delete TKey
+
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public long DeleteOne<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", document.Id);
+            return HandlePartitioned<TDocument, TKey>(document).DeleteOne(filter).DeletedCount;
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="document">The document you want to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public async Task<long> DeleteOneAsync<TDocument, TKey>(TDocument document)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            var filter = Builders<TDocument>.Filter.Eq("Id", document.Id);
+            return (await HandlePartitioned<TDocument, TKey>(document).DeleteOneAsync(filter)).DeletedCount;
+        }
+
+        /// <summary>
+        /// Deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOne(filter).DeletedCount;
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public async Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return (await HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOneAsync(filter)).DeletedCount;
+        }
+
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public async Task<long> DeleteManyAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return (await HandlePartitioned<TDocument, TKey>(partitionKey).DeleteManyAsync(filter)).DeletedCount;
+        }
+
+        /// <summary>
+        /// Asynchronously deletes a list of documents.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="documents">The list of documents to delete.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public async Task<long> DeleteManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            if (!documents.Any())
+            {
+                return 0;
+            }
+            var idsTodelete = documents.Select(e => e.Id).ToArray();
+            return (await HandlePartitioned<TDocument, TKey>(documents.FirstOrDefault()).DeleteManyAsync(x => idsTodelete.Contains(x.Id))).DeletedCount;
+        }
+
         /// <summary>
         /// Deletes a list of documents.
         /// </summary>
@@ -1038,18 +1451,6 @@ namespace MongoDbGenericRepository
             return HandlePartitioned<TDocument, TKey>(documents.FirstOrDefault()).DeleteMany(x => idsTodelete.Contains(x.Id)).DeletedCount;
         }
 
-        /// <returns>The number of documents deleted.</returns>
-        public long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents)
-            where TDocument : IDocument<TKey>
-            where TKey : IEquatable<TKey>
-        {
-            if (!documents.Any())
-            {
-                return 0;
-            }
-            var idsTodelete = documents.Select(e => e.Id).ToArray();
-            return HandlePartitioned<TDocument, TKey>(documents.FirstOrDefault()).DeleteMany(x => idsTodelete.Contains(x.Id)).DeletedCount;
-        }
         /// <summary>
         /// Deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
@@ -1065,7 +1466,7 @@ namespace MongoDbGenericRepository
             return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteMany(filter).DeletedCount;
         }
 
-        /// </summary>
+        #endregion
 
         #region Project
 

MongoDbGenericRepository/Models/IDocument.cs

@@ -1,4 +1,5 @@
-using System;
+using MongoDB.Bson.Serialization.Attributes;
+using System;
 
 namespace MongoDbGenericRepository.Models
 {
@@ -9,9 +10,10 @@ namespace MongoDbGenericRepository.Models
     public interface IDocument<TKey> where TKey : IEquatable<TKey>
     {
         /// <summary>
-        /// The Guid, which must be decorated with the [BsonId] attribute 
+        /// 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>
+        [BsonId]
         TKey Id { get; set; }
         /// <summary>
         /// A version number, to indicate the version of the schema.