Merge pull request #31 from KSemenenko/main

KSemenenko · web-flow · commit c66d77e7a674 · 2021-02-26T13:51:26.000+02:00
refactoring
diff --git a/ManagedCode.Repository.AzureTable/AzureTableAdapter.cs b/ManagedCode.Repository.AzureTable/AzureTableAdapter.cs
@@ -8,24 +8,28 @@
 using Humanizer;
 using ManagedCode.Repository.Core;
 using Microsoft.Azure.Cosmos.Table;
+using Microsoft.Extensions.Logging;
 
 namespace ManagedCode.Repository.AzureTable
 {
     public class AzureTableAdapter<T> where T : class, ITableEntity, new()
     {
+        private readonly ILogger _logger;
         private readonly bool _allowTableCreation = true;
         private readonly CloudStorageAccount _cloudStorageAccount;
         private readonly object _sync = new();
         private CloudTableClient _cloudTableClient;
         private bool _tableClientInitialized;
 
-        public AzureTableAdapter(string connectionString)
+        public AzureTableAdapter(ILogger logger, string connectionString)
         {
+            _logger = logger;
             _cloudStorageAccount = CloudStorageAccount.Parse(connectionString);
         }
 
-        public AzureTableAdapter(StorageCredentials tableStorageCredentials, StorageUri tableStorageUri)
+        public AzureTableAdapter(ILogger logger, StorageCredentials tableStorageCredentials, StorageUri tableStorageUri)
         {
+            _logger = logger;
             var cloudStorageAccount = new CloudStorageAccount(tableStorageCredentials, tableStorageUri);
             _cloudTableClient = cloudStorageAccount.CreateCloudTableClient();
         }
diff --git a/ManagedCode.Repository.AzureTable/BaseAzureTableRepository.cs b/ManagedCode.Repository.AzureTable/BaseAzureTableRepository.cs
@@ -14,20 +14,17 @@ public class BaseAzureTableRepository<TId, TItem> : BaseRepository<TId, TItem>
         where TId : TableId
         where TItem : class, IItem<TId>, ITableEntity, new()
     {
-        private readonly ILogger _logger;
         private readonly AzureTableAdapter<TItem> _tableAdapter;
 
-        public BaseAzureTableRepository(ILogger logger, AzureTableRepositoryOptions options)
+        public BaseAzureTableRepository(ILogger logger, AzureTableRepositoryOptions options) : base(logger)
         {
-            _logger = logger;
-
             if (string.IsNullOrEmpty(options.ConnectionString))
             {
-                _tableAdapter = new AzureTableAdapter<TItem>(options.TableStorageCredentials, options.TableStorageUri);
+                _tableAdapter = new AzureTableAdapter<TItem>(logger, options.TableStorageCredentials, options.TableStorageUri);
             }
             else
             {
-                _tableAdapter = new AzureTableAdapter<TItem>(options.ConnectionString);
+                _tableAdapter = new AzureTableAdapter<TItem>(logger, options.ConnectionString);
             }
         }
 
@@ -314,12 +311,12 @@ protected override async Task<int> CountAsyncInternal(CancellationToken token =
             return count;
         }
 
-        protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>> predicate, CancellationToken token = default)
+        protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default)
         {
             var count = 0;
 
             await foreach (var item in _tableAdapter
-                .Query<DynamicTableEntity>(new[] {predicate}, selectExpression: item => new DynamicTableEntity(item.PartitionKey, item.RowKey),
+                .Query<DynamicTableEntity>(predicates, selectExpression: item => new DynamicTableEntity(item.PartitionKey, item.RowKey),
                     cancellationToken: token))
             {
                 count++;
diff --git a/ManagedCode.Repository.AzureTable/ManagedCode.Repository.AzureTable.csproj b/ManagedCode.Repository.AzureTable/ManagedCode.Repository.AzureTable.csproj
@@ -8,7 +8,7 @@
         <Authors>ManagedCode</Authors>
         <PackageLicenseUrl>https://github.com/managed-code-hub/Repository/blob/main/LICENSE</PackageLicenseUrl>
         <RepositoryUrl>https://github.com/managed-code-hub/Repository</RepositoryUrl>
-        <PackageVersion>1.0.5</PackageVersion>
+        <PackageVersion>1.0.7</PackageVersion>
         <Description>Repository for AzureTable</Description>
     </PropertyGroup>
 
diff --git a/ManagedCode.Repository.Core/BaseRepository.cs b/ManagedCode.Repository.Core/BaseRepository.cs
@@ -4,11 +4,19 @@
 using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ManagedCode.Repository.Core
 {
     public abstract class BaseRepository<TId, TItem> : IRepository<TId, TItem> where TItem : IItem<TId>
     {
+        protected readonly ILogger Logger;
+
+        protected BaseRepository(ILogger logger)
+        {
+            Logger = logger;
+        }
+        
         public bool IsInitialized { get; protected set; }
 
         public Task InitializeAsync(CancellationToken token = default)
@@ -385,12 +393,19 @@ public Task<int> CountAsync(Expression<Func<TItem, bool>> predicate, Cancellatio
         {
             Contract.Requires(IsInitialized);
             Contract.Requires(predicate != null);
-            return CountAsyncInternal(predicate, token);
+            return CountAsyncInternal(new []{predicate}, token);
+        }
+        
+        public Task<int> CountAsync(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default)
+        {
+            Contract.Requires(IsInitialized);
+            Contract.Requires(predicates != null);
+            return CountAsyncInternal(predicates, token);
         }
 
         protected abstract Task<int> CountAsyncInternal(CancellationToken token = default);
 
-        protected abstract Task<int> CountAsyncInternal(Expression<Func<TItem, bool>> predicate, CancellationToken token = default);
+        protected abstract Task<int> CountAsyncInternal(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default);
 
         #endregion
     }
diff --git a/ManagedCode.Repository.Core/IRepository.cs b/ManagedCode.Repository.Core/IRepository.cs
@@ -125,5 +125,6 @@ IAsyncEnumerable<TItem> FindAsync(Expression<Func<TItem, bool>>[] predicates,
 
         Task<int> CountAsync(CancellationToken token = default);
         Task<int> CountAsync(Expression<Func<TItem, bool>> predicate, CancellationToken token = default);
+        Task<int> CountAsync(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default);
     }
 }
diff --git a/ManagedCode.Repository.Core/InMemoryRepository.cs b/ManagedCode.Repository.Core/InMemoryRepository.cs
@@ -5,13 +5,18 @@
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ManagedCode.Repository.Core
 {
     public class InMemoryRepository<TId, TItem> : BaseRepository<TId, TItem> where TItem : IItem<TId>
     {
         private readonly Dictionary<TId, TItem> _storage = new();
 
+        public InMemoryRepository(ILogger logger) : base(logger)
+        {
+        }
+        
         protected override Task InitializeAsyncInternal(CancellationToken token = default)
         {
             IsInitialized = true;
@@ -439,15 +444,31 @@ protected override Task<int> CountAsyncInternal(CancellationToken token = defaul
             }
         }
 
-        protected override Task<int> CountAsyncInternal(Expression<Func<TItem, bool>> predicate, CancellationToken token = default)
+        protected override Task<int> CountAsyncInternal(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default)
         {
             lock (_storage)
             {
-                var count = _storage.Values.Count(predicate.Compile());
+                IEnumerable<TItem> items = null;
+
+                foreach (var predicate in predicates)
+                {
+                    if (items == null)
+                    {
+                        items = _storage.Values.Where(predicate.Compile());
+                    }
+                    else
+                    {
+                        items = items.Where(predicate.Compile());
+                    }
+                }
+
+                var count = items.Count();
                 return Task.FromResult(count);
             }
         }
 
         #endregion
+
+
     }
 }
diff --git a/ManagedCode.Repository.Core/ManagedCode.Repository.Core.csproj b/ManagedCode.Repository.Core/ManagedCode.Repository.Core.csproj
@@ -9,7 +9,7 @@
         <PackageProjectUrl>https://github.com/managed-code-hub/Repository</PackageProjectUrl>
         <PackageLicenseUrl>https://github.com/managed-code-hub/Repository/blob/main/LICENSE</PackageLicenseUrl>
         <RepositoryUrl>https://github.com/managed-code-hub/Repository</RepositoryUrl>
-        <PackageVersion>1.0.6</PackageVersion>
+        <PackageVersion>1.0.7</PackageVersion>
         <Description>Base implementation for Repository</Description>
     </PropertyGroup>
 
diff --git a/ManagedCode.Repository.CosmosDB/CosmosDbRepository.cs b/ManagedCode.Repository.CosmosDB/CosmosDbRepository.cs
@@ -16,12 +16,10 @@ public class CosmosDbRepository<TItem> : BaseRepository<string, TItem>, ICosmosD
         where TItem : CosmosDbItem, IItem<string>, new()
     {
         private readonly CosmosDbAdapter<TItem> _cosmosDbAdapter;
-        private readonly ILogger _logger;
         private readonly bool _splitByType;
 
-        public CosmosDbRepository(ILogger logger, [NotNull] CosmosDbRepositoryOptions options)
+        public CosmosDbRepository(ILogger logger, [NotNull] CosmosDbRepositoryOptions options) : base(logger)
         {
-            _logger = logger;
             _splitByType = options.SplitByType;
             _cosmosDbAdapter = new CosmosDbAdapter<TItem>(options.ConnectionString, options.CosmosClientOptions, options.DatabaseName, options.CollectionName);
         }
@@ -690,10 +688,18 @@ protected override async Task<int> CountAsyncInternal(CancellationToken token =
             return await container.GetItemLinqQueryable<TItem>().Where(SplitByType()).CountAsync(token);
         }
 
-        protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>> predicate, CancellationToken token = default)
+        protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default)
         {
             var container = await _cosmosDbAdapter.GetContainer();
-            return await container.GetItemLinqQueryable<TItem>().Where(SplitByType()).Where(predicate).CountAsync(token);
+            var query = container.GetItemLinqQueryable<TItem>().Where(SplitByType());
+
+            foreach (var predicate in predicates)
+            {
+                query = query.Where(predicate);
+            }
+            
+            
+            return await query.CountAsync(token);
         }
 
         #endregion
diff --git a/ManagedCode.Repository.CosmosDB/ManagedCode.Repository.CosmosDB.csproj b/ManagedCode.Repository.CosmosDB/ManagedCode.Repository.CosmosDB.csproj
@@ -8,7 +8,7 @@
         <Authors>ManagedCode</Authors>
         <PackageLicenseUrl>https://github.com/managed-code-hub/Repository/blob/main/LICENSE</PackageLicenseUrl>
         <RepositoryUrl>https://github.com/managed-code-hub/Repository</RepositoryUrl>
-        <PackageVersion>1.0.6</PackageVersion>
+        <PackageVersion>1.0.7</PackageVersion>
         <Description>Repository for CosmosDB</Description>
     </PropertyGroup>
 
diff --git a/ManagedCode.Repository.LiteDB/LiteDbRepository.cs b/ManagedCode.Repository.LiteDB/LiteDbRepository.cs
@@ -14,11 +14,9 @@ namespace ManagedCode.Repository.LiteDB
     public class LiteDbRepository<TId, TItem> : BaseRepository<TId, TItem> where TItem : class, IItem<TId>
     {
         private readonly LiteDatabase _database;
-        private readonly ILogger _logger;
 
-        public LiteDbRepository(ILogger logger, [NotNull] LiteDbRepositoryOptions options)
+        public LiteDbRepository(ILogger logger, [NotNull] LiteDbRepositoryOptions options) : base(logger)
         {
-            _logger = logger;
             if (options.Database != null)
             {
                 _database = options.Database;
@@ -388,10 +386,16 @@ protected override async Task<int> CountAsyncInternal(CancellationToken token =
             return GetDatabase().Count();
         }
 
-        protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>> predicate, CancellationToken token = default)
+        protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default)
         {
             await Task.Yield();
-            return GetDatabase().Count(predicate);
+            var query = GetDatabase().Query();
+
+            foreach (var predicate in predicates)
+            {
+                query = query.Where(predicate);
+            }
+            return query.Count();
         }
 
         #endregion
diff --git a/ManagedCode.Repository.LiteDB/ManagedCode.Repository.LiteDB.csproj b/ManagedCode.Repository.LiteDB/ManagedCode.Repository.LiteDB.csproj
@@ -8,7 +8,7 @@
         <Authors>ManagedCode</Authors>
         <PackageLicenseUrl>https://github.com/managed-code-hub/Repository/blob/main/LICENSE</PackageLicenseUrl>
         <RepositoryUrl>https://github.com/managed-code-hub/Repository</RepositoryUrl>
-        <PackageVersion>1.0.6</PackageVersion>
+        <PackageVersion>1.0.7</PackageVersion>
         <Description>Repository for LiteDB</Description>
     </PropertyGroup>
 
diff --git a/ManagedCode.Repository.Tests/InMemoryRepositoryTests.cs b/ManagedCode.Repository.Tests/InMemoryRepositoryTests.cs
@@ -11,7 +11,7 @@ namespace ManagedCode.Repository.Tests
 {
     public class InMemoryRepositoryTests
     {
-        private readonly IRepository<int, InMemoryItem> _repository = new InMemoryRepository<int, InMemoryItem>();
+        private readonly IRepository<int, InMemoryItem> _repository = new InMemoryRepository<int, InMemoryItem>(null);
 
         public InMemoryRepositoryTests()
         {
@@ -30,7 +30,7 @@ public async Task InitializeAsync()
         [Fact]
         public async Task NotInitializedAsync()
         {
-            IRepository<int, InMemoryItem> localRepository = new InMemoryRepository<int, InMemoryItem>();
+            IRepository<int, InMemoryItem> localRepository = new InMemoryRepository<int, InMemoryItem>(null);
 
             localRepository.IsInitialized.Should().BeFalse();
 

Original file line number	Diff line number	Diff line change
`@@ -8,24 +8,28 @@`
`8`	`8`	`using Humanizer;`
`9`	`9`	`using ManagedCode.Repository.Core;`
`10`	`10`	`using Microsoft.Azure.Cosmos.Table;`
	`11`	`+using Microsoft.Extensions.Logging;`
`11`	`12`
`12`	`13`	`namespace ManagedCode.Repository.AzureTable`
`13`	`14`	`{`
`14`	`15`	`public class AzureTableAdapter<T> where T : class, ITableEntity, new()`
`15`	`16`	`{`
	`17`	`+ private readonly ILogger _logger;`
`16`	`18`	`private readonly bool _allowTableCreation = true;`
`17`	`19`	`private readonly CloudStorageAccount _cloudStorageAccount;`
`18`	`20`	`private readonly object _sync = new();`
`19`	`21`	`private CloudTableClient _cloudTableClient;`
`20`	`22`	`private bool _tableClientInitialized;`
`21`	`23`
`22`		`- public AzureTableAdapter(string connectionString)`
	`24`	`+ public AzureTableAdapter(ILogger logger, string connectionString)`
`23`	`25`	`{`
	`26`	`+ _logger = logger;`
`24`	`27`	`_cloudStorageAccount = CloudStorageAccount.Parse(connectionString);`
`25`	`28`	`}`
`26`	`29`
`27`		`- public AzureTableAdapter(StorageCredentials tableStorageCredentials, StorageUri tableStorageUri)`
	`30`	`+ public AzureTableAdapter(ILogger logger, StorageCredentials tableStorageCredentials, StorageUri tableStorageUri)`
`28`	`31`	`{`
	`32`	`+ _logger = logger;`
`29`	`33`	`var cloudStorageAccount = new CloudStorageAccount(tableStorageCredentials, tableStorageUri);`
`30`	`34`	`_cloudTableClient = cloudStorageAccount.CreateCloudTableClient();`
`31`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,20 +14,17 @@ public class BaseAzureTableRepository<TId, TItem> : BaseRepository<TId, TItem>`
`14`	`14`	`where TId : TableId`
`15`	`15`	`where TItem : class, IItem<TId>, ITableEntity, new()`
`16`	`16`	`{`
`17`		`- private readonly ILogger _logger;`
`18`	`17`	`private readonly AzureTableAdapter<TItem> _tableAdapter;`
`19`	`18`
`20`		`- public BaseAzureTableRepository(ILogger logger, AzureTableRepositoryOptions options)`
	`19`	`+ public BaseAzureTableRepository(ILogger logger, AzureTableRepositoryOptions options) : base(logger)`
`21`	`20`	`{`
`22`		`- _logger = logger;`
`23`		`-`
`24`	`21`	`if (string.IsNullOrEmpty(options.ConnectionString))`
`25`	`22`	`{`
`26`		`- _tableAdapter = new AzureTableAdapter<TItem>(options.TableStorageCredentials, options.TableStorageUri);`
	`23`	`+ _tableAdapter = new AzureTableAdapter<TItem>(logger, options.TableStorageCredentials, options.TableStorageUri);`
`27`	`24`	`}`
`28`	`25`	`else`
`29`	`26`	`{`
`30`		`- _tableAdapter = new AzureTableAdapter<TItem>(options.ConnectionString);`
	`27`	`+ _tableAdapter = new AzureTableAdapter<TItem>(logger, options.ConnectionString);`
`31`	`28`	`}`
`32`	`29`	`}`
`33`	`30`
`@@ -314,12 +311,12 @@ protected override async Task<int> CountAsyncInternal(CancellationToken token =`
`314`	`311`	`return count;`
`315`	`312`	`}`
`316`	`313`
`317`		`- protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>> predicate, CancellationToken token = default)`
	`314`	`+ protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default)`
`318`	`315`	`{`
`319`	`316`	`var count = 0;`
`320`	`317`
`321`	`318`	`await foreach (var item in _tableAdapter`
`322`		`- .Query<DynamicTableEntity>(new[] {predicate}, selectExpression: item => new DynamicTableEntity(item.PartitionKey, item.RowKey),`
	`319`	`+ .Query<DynamicTableEntity>(predicates, selectExpression: item => new DynamicTableEntity(item.PartitionKey, item.RowKey),`
`323`	`320`	`cancellationToken: token))`
`324`	`321`	`{`
`325`	`322`	`count++;`
Original file line number	Diff line number	Diff line change
`@@ -125,5 +125,6 @@ IAsyncEnumerable<TItem> FindAsync(Expression<Func<TItem, bool>>[] predicates,`
`125`	`125`
`126`	`126`	`Task<int> CountAsync(CancellationToken token = default);`
`127`	`127`	`Task<int> CountAsync(Expression<Func<TItem, bool>> predicate, CancellationToken token = default);`
	`128`	`+ Task<int> CountAsync(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default);`
`128`	`129`	`}`
`129`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,18 @@`
`5`	`5`	`using System.Runtime.CompilerServices;`
`6`	`6`	`using System.Threading;`
`7`	`7`	`using System.Threading.Tasks;`
	`8`	`+using Microsoft.Extensions.Logging;`
`8`	`9`
`9`	`10`	`namespace ManagedCode.Repository.Core`
`10`	`11`	`{`
`11`	`12`	`public class InMemoryRepository<TId, TItem> : BaseRepository<TId, TItem> where TItem : IItem<TId>`
`12`	`13`	`{`
`13`	`14`	`private readonly Dictionary<TId, TItem> _storage = new();`
`14`	`15`
	`16`	`+ public InMemoryRepository(ILogger logger) : base(logger)`
	`17`	`+ {`
	`18`	`+ }`
	`19`	`+`
`15`	`20`	`protected override Task InitializeAsyncInternal(CancellationToken token = default)`
`16`	`21`	`{`
`17`	`22`	`IsInitialized = true;`
`@@ -439,15 +444,31 @@ protected override Task<int> CountAsyncInternal(CancellationToken token = defaul`
`439`	`444`	`}`
`440`	`445`	`}`
`441`	`446`
`442`		`- protected override Task<int> CountAsyncInternal(Expression<Func<TItem, bool>> predicate, CancellationToken token = default)`
	`447`	`+ protected override Task<int> CountAsyncInternal(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default)`
`443`	`448`	`{`
`444`	`449`	`lock (_storage)`
`445`	`450`	`{`
`446`		`- var count = _storage.Values.Count(predicate.Compile());`
	`451`	`+ IEnumerable<TItem> items = null;`
	`452`	`+`
	`453`	`+ foreach (var predicate in predicates)`
	`454`	`+ {`
	`455`	`+ if (items == null)`
	`456`	`+ {`
	`457`	`+ items = _storage.Values.Where(predicate.Compile());`
	`458`	`+ }`
	`459`	`+ else`
	`460`	`+ {`
	`461`	`+ items = items.Where(predicate.Compile());`
	`462`	`+ }`
	`463`	`+ }`
	`464`	`+`
	`465`	`+ var count = items.Count();`
`447`	`466`	`return Task.FromResult(count);`
`448`	`467`	`}`
`449`	`468`	`}`
`450`	`469`
`451`	`470`	`#endregion`
	`471`	`+`
	`472`	`+`
`452`	`473`	`}`
`453`	`474`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,12 +16,10 @@ public class CosmosDbRepository<TItem> : BaseRepository<string, TItem>, ICosmosD`
`16`	`16`	`where TItem : CosmosDbItem, IItem<string>, new()`
`17`	`17`	`{`
`18`	`18`	`private readonly CosmosDbAdapter<TItem> _cosmosDbAdapter;`
`19`		`- private readonly ILogger _logger;`
`20`	`19`	`private readonly bool _splitByType;`
`21`	`20`
`22`		`- public CosmosDbRepository(ILogger logger, [NotNull] CosmosDbRepositoryOptions options)`
	`21`	`+ public CosmosDbRepository(ILogger logger, [NotNull] CosmosDbRepositoryOptions options) : base(logger)`
`23`	`22`	`{`
`24`		`- _logger = logger;`
`25`	`23`	`_splitByType = options.SplitByType;`
`26`	`24`	`_cosmosDbAdapter = new CosmosDbAdapter<TItem>(options.ConnectionString, options.CosmosClientOptions, options.DatabaseName, options.CollectionName);`
`27`	`25`	`}`
`@@ -690,10 +688,18 @@ protected override async Task<int> CountAsyncInternal(CancellationToken token =`
`690`	`688`	`return await container.GetItemLinqQueryable<TItem>().Where(SplitByType()).CountAsync(token);`
`691`	`689`	`}`
`692`	`690`
`693`		`- protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>> predicate, CancellationToken token = default)`
	`691`	`+ protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default)`
`694`	`692`	`{`
`695`	`693`	`var container = await _cosmosDbAdapter.GetContainer();`
`696`		`- return await container.GetItemLinqQueryable<TItem>().Where(SplitByType()).Where(predicate).CountAsync(token);`
	`694`	`+ var query = container.GetItemLinqQueryable<TItem>().Where(SplitByType());`
	`695`	`+`
	`696`	`+ foreach (var predicate in predicates)`
	`697`	`+ {`
	`698`	`+ query = query.Where(predicate);`
	`699`	`+ }`
	`700`	`+`
	`701`	`+`
	`702`	`+ return await query.CountAsync(token);`
`697`	`703`	`}`
`698`	`704`
`699`	`705`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,9 @@ namespace ManagedCode.Repository.LiteDB`
`14`	`14`	`public class LiteDbRepository<TId, TItem> : BaseRepository<TId, TItem> where TItem : class, IItem<TId>`
`15`	`15`	`{`
`16`	`16`	`private readonly LiteDatabase _database;`
`17`		`- private readonly ILogger _logger;`
`18`	`17`
`19`		`- public LiteDbRepository(ILogger logger, [NotNull] LiteDbRepositoryOptions options)`
	`18`	`+ public LiteDbRepository(ILogger logger, [NotNull] LiteDbRepositoryOptions options) : base(logger)`
`20`	`19`	`{`
`21`		`- _logger = logger;`
`22`	`20`	`if (options.Database != null)`
`23`	`21`	`{`
`24`	`22`	`_database = options.Database;`
`@@ -388,10 +386,16 @@ protected override async Task<int> CountAsyncInternal(CancellationToken token =`
`388`	`386`	`return GetDatabase().Count();`
`389`	`387`	`}`
`390`	`388`
`391`		`- protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>> predicate, CancellationToken token = default)`
	`389`	`+ protected override async Task<int> CountAsyncInternal(Expression<Func<TItem, bool>>[] predicates, CancellationToken token = default)`
`392`	`390`	`{`
`393`	`391`	`await Task.Yield();`
`394`		`- return GetDatabase().Count(predicate);`
	`392`	`+ var query = GetDatabase().Query();`
	`393`	`+`
	`394`	`+ foreach (var predicate in predicates)`
	`395`	`+ {`
	`396`	`+ query = query.Where(predicate);`
	`397`	`+ }`
	`398`	`+ return query.Count();`
`395`	`399`	`}`
`396`	`400`
`397`	`401`	`#endregion`