+ Upgraded packages

+ Added GetByMax, GetByMaxAsync, GetByMin, GetByMinAsync, GetMaxValue and GetMaxValueAsync Methods (GetMinValue and GetMinValueAsync will come in another PR)
+ Added tests

CoreIntegrationTests/CRUDPartitionedTests.cs

@@ -18,7 +18,6 @@ namespace CoreIntegrationTests
     {
         public CRUDPartitionedTests(MongoDbTestFixture<CorePartitionedDoc, Guid> fixture) : base(fixture)
         {
-
         }
 
         public override string GetClassName()

CoreIntegrationTests/CoreIntegrationTests.csproj

@@ -5,17 +5,20 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Identity" Version="2.0.1" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity" Version="2.1.2" />
-    <PackageReference Include="Microsoft.Extensions.Identity.Stores" Version="2.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Identity.Stores" Version="2.1.2" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
-    <PackageReference Include="MongoDB.Driver" Version="2.5.0" />
+    <PackageReference Include="MongoDB.Driver" Version="2.7.0" />
-    <PackageReference Include="MongoDbGenericRepository" Version="1.3.6" />
+    <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit" Version="2.3.1" />
+    <PackageReference Include="xunit.runner.console" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.console" Version="2.3.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
     <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0-beta4-build3742" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\MongoDbGenericRepository\MongoDbGenericRepository.csproj" />
+  </ItemGroup>
+
   <ItemGroup>
     <Reference Include="System.Configuration">
       <HintPath>..\..\..\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\System.Configuration.dll</HintPath>

CoreIntegrationTests/IdentityUserTests.cs

@@ -6,7 +6,7 @@ using Xunit;
 using Microsoft.AspNetCore.Identity;
 using System.Threading.Tasks;
 
-namespace CoreCoreIntegrationTests
+namespace CoreIntegrationTests
 {
     public class MongoIdentityUser<TKey> : IdentityUser<TKey>, IDocument<TKey>
         where TKey : IEquatable<TKey>

CoreIntegrationTests/Infrastructure/MongoDbConfig.cs

@@ -1,4 +1,4 @@
-using CoreCoreIntegrationTests;
+using CoreIntegrationTests;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Conventions;
 using System.Threading;

CoreIntegrationTests/Infrastructure/MongoDbDocumentTestBase.cs

@@ -679,7 +679,100 @@ namespace CoreIntegrationTests.Infrastructure
 
         #endregion Project
 
+        #region Max / Min Queries
+
+        [Fact]
+        public async Task GetByMaxAsync()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetByMaxAsync<T>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMax.Id, result.Id);
+        }
+
+        [Fact]
+        public void GetByMax()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetByMax<T>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMax.Id, result.Id);
+        }
+
+        [Fact]
+        public async Task GetByMinAsync()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetByMinAsync<T>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMin.Id, result.Id);
+        }
+
+        [Fact]
+        public void GetByMin()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetByMin<T>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMin.Id, result.Id);
+        }
+
+        #endregion Max / Min Queries
+
         #region Test Utils
+
         [MethodImpl(MethodImplOptions.NoInlining)]
         private string GetCurrentMethod()
         {

CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.cs

@@ -680,6 +680,142 @@ namespace CoreIntegrationTests.Infrastructure
 
         #endregion Project
 
+        #region Max / Min Queries
+
+        [Fact]
+        public async Task GetByMaxAsync()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetByMaxAsync<T, TKey>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMax.Id, result.Id);
+        }
+
+        [Fact]
+        public void GetByMax()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetByMax<T, TKey>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMax.Id, result.Id);
+        }
+
+        [Fact]
+        public void GetMaxValue()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetMaxValue<T, TKey, DateTime>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.False(result == default(DateTime));
+            Assert.Equal(expectedMax.Nested.SomeDate.Date, result.Date);
+        }
+
+        [Fact]
+        public async Task GetMaxValueAsync()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetMaxValueAsync<T, TKey, DateTime>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.False(result == default(DateTime));
+            Assert.Equal(expectedMax.Nested.SomeDate.Date, result.Date);
+        }
+
+        [Fact]
+        public async Task GetByMinAsync()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetByMinAsync<T, TKey>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMin.Id, result.Id);
+        }
+
+        [Fact]
+        public void GetByMin()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e => {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetByMin<T, TKey>(e => e.SomeContent == criteria, e => e.Nested.SomeDate, PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMin.Id, result.Id);
+        }
+
+        #endregion Max / Min Queries
+
         #region Test Utils
         [MethodImpl(MethodImplOptions.NoInlining)]
         private string GetCurrentMethod()

CoreIntegrationTests/Infrastructure/TestClasses.cs

@@ -47,6 +47,8 @@ namespace CoreIntegrationTests.Infrastructure
             Children = new List<Child>();
         }
 
+        public int SomeValue { get; set; }
+
         public string SomeContent { get; set; }
 
         public int GroupingKey { get; set; }

IntegrationTests/Infrastructure/TestRepository.cs

@@ -1,4 +1,9 @@
-using MongoDbGenericRepository;
+using MongoDB.Driver;
+using MongoDbGenericRepository;
+using MongoDbGenericRepository.Models;
+using System;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
 
 namespace IntegrationTests.Infrastructure
 {
@@ -18,5 +23,20 @@ namespace IntegrationTests.Infrastructure
         {
             MongoDbContext.DropCollection<TDocument>(partitionKey);
         }
+
+        /// <summary>
+        /// Gets the max of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <returns></returns>
+        public async Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending)
+            where TDocument : IDocument<TKey>
+            where TKey : System.IEquatable<TKey>
+        {
+            return await GetCollection<TDocument, TKey>().Find(Builders<TDocument>.Filter.Where(filter))
+                                                         .SortByDescending(orderByDescending)
+                                                         .FirstOrDefaultAsync();
+        }
     }
 }

MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.cs

@@ -111,6 +111,47 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         long Count<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument;
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByDescending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        Task<TDocument> GetByMaxAsync<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument;
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByDescending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <returns></returns>
+        TDocument GetByMax<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument;
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        Task<TDocument> GetByMinAsync<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument;
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TDocument GetByMin<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument;
+
         #endregion
 
         #region Read TKey
@@ -159,7 +200,6 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
-
         /// <summary>
         /// Returns a collection cursor.
         /// </summary>
@@ -238,6 +278,78 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+
         #endregion
     }
 

MongoDbGenericRepository/MongoDbGenericRepository.csproj

@@ -17,7 +17,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="MongoDB.Driver" Version="2.5.0" />
+    <PackageReference Include="MongoDB.Driver" Version="2.7.0" />
   </ItemGroup>
 
 </Project>

MongoDbGenericRepository/MongoDbGenericRepository.nuspec

@@ -2,7 +2,7 @@
 <package >
   <metadata>
     <id>MongoDbGenericRepository</id>
-    <version>1.3.6</version>
+    <version>1.3.7</version>
     <title>MongoDb Generic Repository</title>
     <authors>Alexandre Spieser</authors>
     <owners>Alexandre Spieser</owners>
@@ -10,11 +10,11 @@
     <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>Adding support for Id of type ObjectId.</releaseNotes>
+    <releaseNotes>Upgraded dependencies.</releaseNotes>
     <copyright>Copyright 2017 (c) Alexandre Spieser. All rights reserved.</copyright>
     <tags>MongoDb Repository Generic NoSql</tags>
 	<dependencies>
-		<dependency id="MongoDB.Driver" version="2.5.0" />
+		<dependency id="MongoDB.Driver" version="2.7.0" />
 	</dependencies>
   </metadata>
   <files>

MongoDbGenericRepository/ReadOnlyMongoRepository.cs

@@ -123,7 +123,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public async Task<bool> AnyAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
         {
-            var count = await HandlePartitioned<TDocument>(partitionKey).CountAsync(filter);
+            var count = await HandlePartitioned<TDocument>(partitionKey).CountDocumentsAsync(filter);
             return (count > 0);
         }
 
@@ -135,7 +135,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partition key.</param>
         public bool Any<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
         {
-            var count = HandlePartitioned<TDocument>(partitionKey).Count(filter);
+            var count = HandlePartitioned<TDocument>(partitionKey).CountDocuments(filter);
             return (count > 0);
         }
 
@@ -169,7 +169,7 @@ namespace MongoDbGenericRepository
         /// <param name="partitionKey">An optional partitionKey</param>
         public async Task<long> CountAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument
         {
-            return await HandlePartitioned<TDocument>(partitionKey).CountAsync(filter);
+            return await HandlePartitioned<TDocument>(partitionKey).CountDocumentsAsync(filter);
         }
 
         /// <summary>
@@ -180,7 +180,68 @@ namespace MongoDbGenericRepository
         /// <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();
+            return HandlePartitioned<TDocument>(partitionKey).Find(filter).CountDocuments();
+        }
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByDescending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async Task<TDocument> GetByMaxAsync<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument
+        {
+            return await GetCollection<TDocument>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                   .SortByDescending(orderByDescending)
+                                                   .FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByDescending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <returns></returns>
+        public TDocument GetByMax<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument
+        {
+            return GetCollection<TDocument>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                             .SortByDescending(orderByDescending)
+                                             .FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async Task<TDocument> GetByMinAsync<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument
+        {
+            return await GetCollection<TDocument>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                   .SortBy(orderByAscending)
+                                                   .FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public TDocument GetByMin<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument
+        {
+            return GetCollection<TDocument>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                         .SortBy(orderByAscending)
+                                                         .FirstOrDefault();
         }
 
         #endregion
@@ -270,7 +331,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var count = await HandlePartitioned<TDocument, TKey>(partitionKey).CountAsync(filter);
+            var count = await HandlePartitioned<TDocument, TKey>(partitionKey).CountDocumentsAsync(filter);
             return (count > 0);
         }
 
@@ -285,7 +346,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            var count = HandlePartitioned<TDocument, TKey>(partitionKey).Count(filter);
+            var count = HandlePartitioned<TDocument, TKey>(partitionKey).CountDocuments(filter);
             return (count > 0);
         }
 
@@ -328,7 +389,7 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return await HandlePartitioned<TDocument, TKey>(partitionKey).CountAsync(filter);
+            return await HandlePartitioned<TDocument, TKey>(partitionKey).CountDocumentsAsync(filter);
         }
 
         /// <summary>
@@ -342,7 +403,112 @@ namespace MongoDbGenericRepository
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>
         {
-            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).Count();
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).CountDocuments();
+        }
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                                     .SortByDescending(orderByDescending)
+                                                                     .FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by descending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                               .SortByDescending(orderByDescending)
+                                                               .FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                   .SortBy(orderByAscending)
+                                                   .FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                               .SortBy(orderByAscending)
+                                                               .FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public async Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return await GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                                     .SortByDescending(ConvertExpression(maxValueSelector))
+                                                                     .Project(maxValueSelector)
+                                                                     .FirstOrDefaultAsync();
+        }
+
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="filter">A LINQ expression filter.</param>
+        /// <param name="orderByAscending">A property selector to order by ascending.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> orderByDescending, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+
+            return GetCollection<TDocument, TKey>(partitionKey).Find(Builders<TDocument>.Filter.Where(filter))
+                                                               .SortByDescending(ConvertExpression(orderByDescending))
+                                                               .Project(orderByDescending)
+                                                               .FirstOrDefault();
         }
 
         #endregion
@@ -450,6 +616,20 @@ namespace MongoDbGenericRepository
             return GetCollection<TDocument, TKey>();
         }
 
+        /// <summary>
+        /// Converts a LINQ expression of TDocument, TValue to a LINQ expression of TDocument, object
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="expression">The expression to convert</param>
+        protected static Expression<Func<TDocument, object>> ConvertExpression<TDocument, TValue>(Expression<Func<TDocument, TValue>> expression)
+        {
+            var param = expression.Parameters[0];
+            Expression body = expression.Body;
+            var convert = Expression.Convert(body, typeof(object));
+            return Expression.Lambda<Func<TDocument, object>>(convert, param);
+        }
+
         #endregion
 
     }