diff --git a/src/Repository/AsyncQueryableRepository.cs b/src/Repository/AsyncQueryableRepository.cs
index 49d1b9b..d263737 100644
--- a/src/Repository/AsyncQueryableRepository.cs
+++ b/src/Repository/AsyncQueryableRepository.cs
@@ -1,17 +1,640 @@
-using System.Diagnostics.CodeAnalysis;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using eQuantic.Core.Data.EntityFramework.Repository.Read;
+using eQuantic.Core.Data.EntityFramework.Repository.Write;
 using eQuantic.Core.Data.Repository;
 using eQuantic.Core.Data.Repository.Config;
+using eQuantic.Core.Data.Repository.Read;
+using eQuantic.Core.Data.Repository.Write;
+using eQuantic.Linq.Specification;
 
 namespace eQuantic.Core.Data.EntityFramework.Repository;
 
 [ExcludeFromCodeCoverage]
 public class AsyncQueryableRepository<TUnitOfWork, TEntity, TKey> :
-    AsyncRepository<TUnitOfWork, QueryableConfiguration<TEntity>, TEntity, TKey>,
+    QueryableRepository<TUnitOfWork, TEntity, TKey>,
+    IAsyncRepository<TUnitOfWork, QueryableConfiguration<TEntity>, TEntity, TKey>,
     IAsyncQueryableRepository<TUnitOfWork, TEntity, TKey>
-    where TUnitOfWork : IQueryableUnitOfWork
+    where TUnitOfWork : class, IQueryableUnitOfWork
     where TEntity : class, IEntity, new()
 {
+    private readonly IAsyncQueryableReadRepository<TUnitOfWork, TEntity, TKey> _asyncReadRepository;
+    private readonly IAsyncWriteRepository<TUnitOfWork, TEntity> _asyncWriteRepository;
+    private bool _disposed;
+
     public AsyncQueryableRepository(TUnitOfWork unitOfWork) : base(unitOfWork)
     {
+        this._asyncReadRepository = new AsyncQueryableReadRepository<TUnitOfWork, TEntity, TKey>(unitOfWork);
+        this._asyncWriteRepository = new AsyncWriteRepository<TUnitOfWork, TEntity>(unitOfWork);
+    }
+
+    public Task AddAsync(TEntity item)
+    {
+        return this._asyncWriteRepository.AddAsync(item);
+    }
+
+    public Task<IEnumerable<TEntity>> AllMatchingAsync(
+        ISpecification<TEntity> specification,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.AllMatchingAsync(specification, configuration);
+    }
+
+    public Task<IEnumerable<TEntity>> AllMatchingAsync(
+        ISpecification<TEntity> specification,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AllMatchingAsync(specification, configuration, cancellationToken);
+    }
+    public Task<IEnumerable<TEntity>> AllMatchingAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AllMatchingAsync(specification, cancellationToken);
+    }
+    
+    public Task<long> CountAsync(CancellationToken cancellationToken = default)
+    {
+        return this._asyncReadRepository.CountAsync(cancellationToken);
+    }
+
+    public Task<long> CountAsync(
+        ISpecification<TEntity> specification, 
+        CancellationToken cancellationToken = default)
+    {
+        return this._asyncReadRepository.CountAsync(specification, cancellationToken);
+    }
+
+    public Task<long> CountAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        CancellationToken cancellationToken = default)
+    {
+        return this._asyncReadRepository.CountAsync(filter, cancellationToken);
+    }
+
+    public Task<bool> AllAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.AllAsync(specification, configuration);
+    }
+    
+    public Task<bool> AllAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AllAsync(specification, configuration, cancellationToken);
+    }
+    
+    public Task<bool> AllAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AllAsync(specification, cancellationToken);
+    }
+
+    public Task<bool> AllAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.AllAsync(filter, configuration);
+    }
+    
+    public Task<bool> AllAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AllAsync(filter, configuration, cancellationToken);
+    }
+    
+    public Task<bool> AllAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AllAsync(filter, cancellationToken);
+    }
+
+    public Task<bool> AnyAsync(
+        Action<QueryableConfiguration<TEntity>> configuration = default, 
+        CancellationToken cancellationToken = default)
+    {
+        return this._asyncReadRepository.AnyAsync(configuration, cancellationToken);
+    }
+
+    public Task<bool> AnyAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.AnyAsync(specification, configuration);
+    }
+    
+    public Task<bool> AnyAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AnyAsync(specification, configuration, cancellationToken);
+    }
+    
+    public Task<bool> AnyAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AnyAsync(specification, cancellationToken);
+    }
+
+    public Task<bool> AnyAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.AnyAsync(filter, configuration);
+    }
+    
+    public Task<bool> AnyAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AnyAsync(filter, configuration, cancellationToken);
+    }
+    
+    public Task<bool> AnyAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.AnyAsync(filter, cancellationToken);
+    }
+
+    public Task<long> DeleteManyAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken = default)
+    {
+        return this._asyncWriteRepository.DeleteManyAsync(filter, cancellationToken);
+    }
+
+    public Task<long> DeleteManyAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken = default)
+    {
+        return this._asyncWriteRepository.DeleteManyAsync(specification, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetAllAsync(
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetAllAsync(configuration);
+    }
+
+    public Task<IEnumerable<TEntity>> GetAllAsync(
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetAllAsync(configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetAllAsync(
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetAllAsync(cancellationToken);
+    }
+    
+    public Task<TEntity> GetAsync(
+        TKey id, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetAsync(id, configuration);
+    }
+
+    public Task<TEntity> GetAsync(
+        TKey id, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetAsync(id, configuration, cancellationToken);
+    }
+    
+    public Task<TEntity> GetAsync(
+        TKey id,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetAsync(id, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetMappedAsync(filter, map, configuration);
+    }
+    
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetMappedAsync(filter, map, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetMappedAsync(filter, map, cancellationToken);
+    }
+
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetMappedAsync(specification, map, configuration);
+    }
+    
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetMappedAsync(specification, map, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetMappedAsync(specification, map, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetFilteredAsync(
+        Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetFilteredAsync(filter, configuration);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetFilteredAsync(
+        Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetFilteredAsync(filter, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetFilteredAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetFilteredAsync(filter, cancellationToken);
+    }
+
+    public Task<TEntity> GetFirstAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetFirstAsync(filter, configuration);
+    }
+
+    public Task<TEntity> GetFirstAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetFirstAsync(filter, configuration, cancellationToken);
+    }
+    
+    public Task<TEntity> GetFirstAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken = default)
+    {
+        return this._asyncReadRepository.GetFirstAsync(filter, cancellationToken);
+    }
+    
+    public Task<TEntity> GetFirstAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetFirstAsync(specification, configuration);
+    }
+
+    public Task<TEntity> GetFirstAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetFirstAsync(specification, configuration, cancellationToken);
+    }
+    
+    public Task<TEntity> GetFirstAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetFirstAsync(specification, cancellationToken);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetFirstMappedAsync(filter, map, configuration);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetFirstMappedAsync(filter, map, configuration, cancellationToken);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetFirstMappedAsync(filter, map, cancellationToken);
+    }
+
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetFirstMappedAsync(specification, map, configuration);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetFirstMappedAsync(specification, map, configuration, cancellationToken);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetFirstMappedAsync(specification, map, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int limit, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetPagedAsync(limit, configuration);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int limit, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(limit, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int limit,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(limit, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int limit,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetPagedAsync(specification, limit, configuration);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int limit,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(specification, limit, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int limit,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(specification, limit, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int limit,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetPagedAsync(filter, limit, configuration);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int limit,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(filter, limit, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int limit,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(filter, limit, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetPagedAsync(pageIndex, pageSize, configuration);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(pageIndex, pageSize, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int pageIndex, 
+        int pageSize,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(pageIndex, pageSize, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetPagedAsync(specification, pageIndex, pageSize, configuration);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(specification, pageIndex, pageSize, configuration,
+            cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int pageIndex, 
+        int pageSize,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(specification, pageIndex, pageSize,
+            cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetPagedAsync(filter, pageIndex, pageSize, configuration);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(filter, pageIndex, pageSize, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int pageIndex, 
+        int pageSize,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetPagedAsync(filter, pageIndex, pageSize, cancellationToken);
+    }
+
+    public Task<TEntity> GetSingleAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetSingleAsync(filter, configuration);
+    }
+    
+    public Task<TEntity> GetSingleAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetSingleAsync(filter, configuration, cancellationToken);
+    }
+    
+    public Task<TEntity> GetSingleAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetSingleAsync(filter, cancellationToken);
+    }
+
+    public Task<TEntity> GetSingleAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._asyncReadRepository.GetSingleAsync(specification, configuration);
+    }
+    
+    public Task<TEntity> GetSingleAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetSingleAsync(specification, configuration, cancellationToken);
+    }
+    
+    public Task<TEntity> GetSingleAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return this._asyncReadRepository.GetSingleAsync(specification, cancellationToken);
+    }
+
+    public Task MergeAsync(TEntity persisted, TEntity current)
+    {
+        return this._asyncWriteRepository.MergeAsync(persisted, current);
+    }
+
+    public Task ModifyAsync(TEntity item)
+    {
+        return this._asyncWriteRepository.ModifyAsync(item);
+    }
+
+    public Task RemoveAsync(TEntity item)
+    {
+        return this._asyncWriteRepository.RemoveAsync(item);
+    }
+
+    public Task<long> UpdateManyAsync(Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TEntity>> updateFactory, CancellationToken cancellationToken = default)
+    {
+        return this._asyncWriteRepository.UpdateManyAsync(filter, updateFactory, cancellationToken);
+    }
+
+    public Task<long> UpdateManyAsync(ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TEntity>> updateFactory, CancellationToken cancellationToken = default)
+    {
+        return this._asyncWriteRepository.UpdateManyAsync(specification, updateFactory, cancellationToken);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (disposing)
+        {
+            this._asyncReadRepository?.Dispose();
+            this._asyncWriteRepository?.Dispose();
+            UnitOfWork?.Dispose();
+        }
+
+        _disposed = true;
     }
 }
diff --git a/src/Repository/AsyncRepository.cs b/src/Repository/AsyncRepository.cs
deleted file mode 100644
index 2189f3c..0000000
--- a/src/Repository/AsyncRepository.cs
+++ /dev/null
@@ -1,265 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-using eQuantic.Core.Data.EntityFramework.Repository.Read;
-using eQuantic.Core.Data.EntityFramework.Repository.Write;
-using eQuantic.Core.Data.Repository;
-using eQuantic.Core.Data.Repository.Config;
-using eQuantic.Core.Data.Repository.Read;
-using eQuantic.Core.Data.Repository.Write;
-using eQuantic.Linq.Specification;
-
-namespace eQuantic.Core.Data.EntityFramework.Repository;
-
-public class AsyncRepository<TUnitOfWork, TConfig, TEntity, TKey> : Repository<TUnitOfWork, TConfig, TEntity, TKey>,
-    IAsyncRepository<TUnitOfWork, TConfig, TEntity, TKey>
-    where TUnitOfWork : IQueryableUnitOfWork
-    where TEntity : class, IEntity, new()
-    where TConfig : Configuration<TEntity>
-{
-    private readonly IAsyncReadRepository<TUnitOfWork, TConfig, TEntity, TKey> _asyncReadRepository;
-    private readonly IAsyncWriteRepository<TUnitOfWork, TEntity> _asyncWriteRepository;
-    private bool _disposed;
-
-    public AsyncRepository(TUnitOfWork unitOfWork) : base(unitOfWork)
-    {
-        this._asyncReadRepository = new AsyncReadRepository<TUnitOfWork, TConfig, TEntity, TKey>(unitOfWork);
-        this._asyncWriteRepository = new AsyncWriteRepository<TUnitOfWork, TEntity>(unitOfWork);
-    }
-
-    public Task AddAsync(TEntity item)
-    {
-        return this._asyncWriteRepository.AddAsync(item);
-    }
-
-    public Task<IEnumerable<TEntity>> AllMatchingAsync(ISpecification<TEntity> specification,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.AllMatchingAsync(specification, configuration, cancellationToken);
-    }
-
-    public Task<long> CountAsync(CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.CountAsync(cancellationToken);
-    }
-
-    public Task<long> CountAsync(ISpecification<TEntity> specification, CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.CountAsync(specification, cancellationToken);
-    }
-
-    public Task<long> CountAsync(Expression<Func<TEntity, bool>> filter, CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.CountAsync(filter, cancellationToken);
-    }
-
-    public Task<bool> AllAsync(ISpecification<TEntity> specification, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.AllAsync(specification, configuration, cancellationToken);
-    }
-
-    public Task<bool> AllAsync(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.AllAsync(filter, configuration, cancellationToken);
-    }
-
-    public Task<bool> AnyAsync(Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.AnyAsync(configuration, cancellationToken);
-    }
-
-    public Task<bool> AnyAsync(ISpecification<TEntity> specification, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.AnyAsync(specification, configuration, cancellationToken);
-    }
-
-    public Task<bool> AnyAsync(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.AnyAsync(filter, configuration, cancellationToken);
-    }
-
-    public Task<long> DeleteManyAsync(Expression<Func<TEntity, bool>> filter,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncWriteRepository.DeleteManyAsync(filter, cancellationToken);
-    }
-
-    public Task<long> DeleteManyAsync(ISpecification<TEntity> specification,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncWriteRepository.DeleteManyAsync(specification, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetAllAsync(Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetAllAsync(configuration, cancellationToken);
-    }
-
-    public Task<TEntity> GetAsync(TKey id, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetAsync(id, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(Expression<Func<TEntity, bool>> filter,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetMappedAsync(filter, map, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(ISpecification<TEntity> specification,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetMappedAsync(specification, map, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetFilteredAsync(Expression<Func<TEntity, bool>> filter,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetFilteredAsync(filter, configuration, cancellationToken);
-    }
-
-    public Task<TEntity> GetFirstAsync(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetFirstAsync(filter, configuration, cancellationToken);
-    }
-
-    public Task<TEntity> GetFirstAsync(ISpecification<TEntity> specification, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetFirstAsync(specification, configuration, cancellationToken);
-    }
-
-    public Task<TResult> GetFirstMappedAsync<TResult>(Expression<Func<TEntity, bool>> filter,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetFirstMappedAsync(filter, map, configuration, cancellationToken);
-    }
-
-    public Task<TResult> GetFirstMappedAsync<TResult>(ISpecification<TEntity> specification,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetFirstMappedAsync(specification, map, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(int limit, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetPagedAsync(limit, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(ISpecification<TEntity> specification, int limit,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetPagedAsync(specification, limit, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(Expression<Func<TEntity, bool>> filter, int limit,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetPagedAsync(filter, limit, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(int pageIndex, int pageSize,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetPagedAsync(pageIndex, pageSize, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(
-        ISpecification<TEntity> specification, int pageIndex, int pageSize,
-        Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetPagedAsync(specification, pageIndex, pageSize, configuration,
-            cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(
-        Expression<Func<TEntity, bool>> filter, int pageIndex, int pageSize,
-        Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetPagedAsync(filter, pageIndex, pageSize, configuration, cancellationToken);
-    }
-
-    public Task<TEntity> GetSingleAsync(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetSingleAsync(filter, configuration, cancellationToken);
-    }
-
-    public Task<TEntity> GetSingleAsync(ISpecification<TEntity> specification, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return this._asyncReadRepository.GetSingleAsync(specification, configuration, cancellationToken);
-    }
-
-    public Task MergeAsync(TEntity persisted, TEntity current)
-    {
-        return this._asyncWriteRepository.MergeAsync(persisted, current);
-    }
-
-    public Task ModifyAsync(TEntity item)
-    {
-        return this._asyncWriteRepository.ModifyAsync(item);
-    }
-
-    public Task RemoveAsync(TEntity item)
-    {
-        return this._asyncWriteRepository.RemoveAsync(item);
-    }
-
-    public Task<long> UpdateManyAsync(Expression<Func<TEntity, bool>> filter,
-        Expression<Func<TEntity, TEntity>> updateFactory, CancellationToken cancellationToken = default)
-    {
-        return this._asyncWriteRepository.UpdateManyAsync(filter, updateFactory, cancellationToken);
-    }
-
-    public Task<long> UpdateManyAsync(ISpecification<TEntity> specification,
-        Expression<Func<TEntity, TEntity>> updateFactory, CancellationToken cancellationToken = default)
-    {
-        return this._asyncWriteRepository.UpdateManyAsync(specification, updateFactory, cancellationToken);
-    }
-
-    protected override void Dispose(bool disposing)
-    {
-        base.Dispose(disposing);
-
-        if (_disposed)
-        {
-            return;
-        }
-
-        if (disposing)
-        {
-            this._asyncReadRepository?.Dispose();
-            this._asyncWriteRepository?.Dispose();
-            UnitOfWork?.Dispose();
-        }
-
-        _disposed = true;
-    }
-}
-
-public class AsyncRepository<TUnitOfWork, TEntity, TKey> :
-    AsyncRepository<TUnitOfWork, Configuration<TEntity>, TEntity, TKey>, IAsyncRepository<TUnitOfWork, TEntity, TKey>
-    where TUnitOfWork : IQueryableUnitOfWork
-    where TEntity : class, IEntity, new()
-{
-    public AsyncRepository(TUnitOfWork unitOfWork) : base(unitOfWork)
-    {
-    }
-}
diff --git a/src/Repository/DefaultUnitOfWork.cs b/src/Repository/DefaultUnitOfWork.cs
index 06a119c..f626783 100644
--- a/src/Repository/DefaultUnitOfWork.cs
+++ b/src/Repository/DefaultUnitOfWork.cs
@@ -5,7 +5,7 @@
 
 namespace eQuantic.Core.Data.EntityFramework.Repository;
 
-public class DefaultUnitOfWork : UnitOfWork<ISqlUnitOfWork, DbContext>, IDefaultUnitOfWork
+public class DefaultUnitOfWork : UnitOfWork<DbContext>
 {
     public DefaultUnitOfWork(IServiceProvider serviceProvider, DbContext context) : base(serviceProvider, context)
     {
diff --git a/src/Repository/Extensions/ServiceCollectionExtensions.cs b/src/Repository/Extensions/ServiceCollectionExtensions.cs
index 8ec0327..a5dd24d 100644
--- a/src/Repository/Extensions/ServiceCollectionExtensions.cs
+++ b/src/Repository/Extensions/ServiceCollectionExtensions.cs
@@ -11,23 +11,23 @@ namespace eQuantic.Core.Data.EntityFramework.Repository.Extensions;
 public static class ServiceCollectionExtensions
 {
     public static IServiceCollection AddQueryableRepositories<TQueryableUnitOfWork>(this IServiceCollection services)
-        where TQueryableUnitOfWork : class, IDefaultUnitOfWork
+        where TQueryableUnitOfWork : class, IQueryableUnitOfWork
     {
         return AddQueryableRepositories<TQueryableUnitOfWork>(services, _ => { });
     }
 
     public static IServiceCollection AddQueryableRepositories<TUnitOfWorkInterface, TUnitOfWorkImpl>(
         this IServiceCollection services)
-        where TUnitOfWorkInterface : ISqlUnitOfWork<TUnitOfWorkInterface>
-        where TUnitOfWorkImpl : class, ISqlUnitOfWork<TUnitOfWorkInterface>
+        where TUnitOfWorkInterface : IQueryableUnitOfWork
+        where TUnitOfWorkImpl : class, TUnitOfWorkInterface
     {
         return AddQueryableRepositories<TUnitOfWorkInterface, TUnitOfWorkImpl>(services, _ => {});
     }
 
     public static IServiceCollection AddQueryableRepositories<TUnitOfWorkInterface, TUnitOfWorkImpl>(this IServiceCollection services,
         Action<RepositoryOptions> options)
-        where TUnitOfWorkInterface : ISqlUnitOfWork<TUnitOfWorkInterface>
-        where TUnitOfWorkImpl : class, ISqlUnitOfWork<TUnitOfWorkInterface>
+        where TUnitOfWorkInterface : IQueryableUnitOfWork
+        where TUnitOfWorkImpl : class, TUnitOfWorkInterface
     {
         var repoOptions = GetOptions(options);
         var lifetime = repoOptions.GetLifetime();
@@ -40,12 +40,12 @@ public static IServiceCollection AddQueryableRepositories<TUnitOfWorkInterface,
 
     public static IServiceCollection AddQueryableRepositories<TQueryableUnitOfWork>(this IServiceCollection services,
         Action<RepositoryOptions> options)
-        where TQueryableUnitOfWork : class, IDefaultUnitOfWork
+        where TQueryableUnitOfWork : class, IQueryableUnitOfWork
     {
         var repoOptions = GetOptions(options);
         var lifetime = repoOptions.GetLifetime();
         
-        AddUnitOfWork<IDefaultUnitOfWork, TQueryableUnitOfWork>(services, lifetime);
+        AddUnitOfWork<IQueryableUnitOfWork, TQueryableUnitOfWork>(services, lifetime);
         AddGenericRepositories(services, lifetime);
 
         return services;
@@ -53,38 +53,36 @@ public static IServiceCollection AddQueryableRepositories<TQueryableUnitOfWork>(
 
     public static IServiceCollection AddCustomRepositories<TQueryableUnitOfWork>(this IServiceCollection services,
         Action<RepositoryOptions> options)
-        where TQueryableUnitOfWork : class, IDefaultUnitOfWork
+        where TQueryableUnitOfWork : class, IQueryableUnitOfWork
     {
         var repoOptions = GetOptions(options);
         var lifetime = repoOptions.GetLifetime();
         
-        AddUnitOfWork<IDefaultUnitOfWork, TQueryableUnitOfWork>(services, lifetime);
+        AddUnitOfWork<IQueryableUnitOfWork, TQueryableUnitOfWork>(services, lifetime);
         AddRepositories(services, repoOptions);
 
         return services;
     }
 
     private static void AddUnitOfWork<TUnitOfWorkInterface, TUnitOfWorkImpl>(IServiceCollection services, ServiceLifetime lifetime)
-        where TUnitOfWorkInterface : ISqlUnitOfWork
-        where TUnitOfWorkImpl : class, ISqlUnitOfWork
+        where TUnitOfWorkInterface : IQueryableUnitOfWork
+        where TUnitOfWorkImpl : class, IQueryableUnitOfWork
     {
         services.TryAdd(new ServiceDescriptor(typeof(TUnitOfWorkInterface), typeof(TUnitOfWorkImpl), lifetime));
-        services.TryAdd(new ServiceDescriptor(typeof(ISqlUnitOfWork<TUnitOfWorkInterface>), sp => sp.GetRequiredService<TUnitOfWorkInterface>(), lifetime));
-        services.TryAdd(new ServiceDescriptor(typeof(IQueryableUnitOfWork<TUnitOfWorkInterface>), sp => sp.GetRequiredService<TUnitOfWorkInterface>(), lifetime));
-        
+        services.TryAdd(new ServiceDescriptor(typeof(IQueryableUnitOfWork), sp => sp.GetRequiredService<TUnitOfWorkInterface>(), lifetime));
+
         services.TryAdd(new ServiceDescriptor(typeof(ISqlUnitOfWork), sp => sp.GetRequiredService<TUnitOfWorkInterface>(), lifetime));
         services.TryAdd(new ServiceDescriptor(typeof(IQueryableUnitOfWork), sp => sp.GetRequiredService<TUnitOfWorkInterface>(), lifetime));
     }
 
     private static void AddGenericRepositories(IServiceCollection services, ServiceLifetime lifetime)
     {
-        services.TryAdd(new ServiceDescriptor(typeof(Repository<,,>), typeof(Repository<,,>), lifetime));
-        services.TryAdd(new ServiceDescriptor(typeof(AsyncRepository<,,>), typeof(AsyncRepository<,,>), lifetime));
         services.TryAdd(new ServiceDescriptor(typeof(QueryableRepository<,,>), typeof(QueryableRepository<,,>),
             lifetime));
         services.TryAdd(new ServiceDescriptor(typeof(AsyncQueryableRepository<,,>),
             typeof(AsyncQueryableRepository<,,>), lifetime));
     }
+    
     private static void AddRepositories(IServiceCollection services, RepositoryOptions repoOptions)
     {
         var types = repoOptions.GetAssemblies()
diff --git a/src/Repository/QueryableRepository.cs b/src/Repository/QueryableRepository.cs
index 5bab552..bdf398d 100644
--- a/src/Repository/QueryableRepository.cs
+++ b/src/Repository/QueryableRepository.cs
@@ -1,17 +1,244 @@
-using System.Diagnostics.CodeAnalysis;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using eQuantic.Core.Data.EntityFramework.Repository.Read;
+using eQuantic.Core.Data.EntityFramework.Repository.Write;
 using eQuantic.Core.Data.Repository;
 using eQuantic.Core.Data.Repository.Config;
+using eQuantic.Core.Data.Repository.Read;
+using eQuantic.Core.Data.Repository.Write;
+using eQuantic.Linq.Specification;
 
 namespace eQuantic.Core.Data.EntityFramework.Repository;
 
 [ExcludeFromCodeCoverage]
 public class QueryableRepository<TUnitOfWork, TEntity, TKey> :
-    Repository<TUnitOfWork, QueryableConfiguration<TEntity>, TEntity, TKey>,
+    IRepository<TUnitOfWork, QueryableConfiguration<TEntity>, TEntity, TKey>,
     IQueryableRepository<TUnitOfWork, TEntity, TKey>
     where TUnitOfWork : IQueryableUnitOfWork
     where TEntity : class, IEntity, new()
 {
-    public QueryableRepository(TUnitOfWork unitOfWork) : base(unitOfWork)
+    private readonly IQueryableReadRepository<TUnitOfWork, TEntity, TKey> _readRepository;
+    private readonly IWriteRepository<TUnitOfWork, TEntity> _writeRepository;
+    private bool _disposed;
+
+    /// <summary>
+    /// Create a new instance of repository
+    /// </summary>
+    /// <param name="unitOfWork">Associated Unit Of Work</param>
+    public QueryableRepository(TUnitOfWork unitOfWork)
+    {
+        this.UnitOfWork = unitOfWork;
+        this._readRepository = new QueryableReadRepository<TUnitOfWork, TEntity, TKey>(unitOfWork);
+        this._writeRepository = new WriteRepository<TUnitOfWork, TEntity>(unitOfWork);
+    }
+
+    public TUnitOfWork UnitOfWork { get; private set; }
+
+    public void Add(TEntity item)
+    {
+        this._writeRepository.Add(item);
+    }
+
+    public IEnumerable<TEntity> AllMatching(ISpecification<TEntity> specification,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.AllMatching(specification, configuration);
+    }
+
+    public long Count()
+    {
+        return this._readRepository.Count();
+    }
+
+    public long Count(ISpecification<TEntity> specification)
+    {
+        return this._readRepository.Count(specification);
+    }
+
+    public long Count(Expression<Func<TEntity, bool>> filter)
+    {
+        return this._readRepository.Count(filter);
+    }
+
+    public bool All(ISpecification<TEntity> specification, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.All(specification, configuration);
+    }
+
+    public bool All(Expression<Func<TEntity, bool>> filter, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.All(filter, configuration);
+    }
+
+    public bool Any(Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.Any(configuration);
+    }
+
+    public bool Any(ISpecification<TEntity> specification, Action<QueryableConfiguration<TEntity>> configuration = default)
     {
+        return this._readRepository.Any(specification, configuration);
+    }
+
+    public bool Any(Expression<Func<TEntity, bool>> filter, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.Any(filter, configuration);
+    }
+
+    public long DeleteMany(Expression<Func<TEntity, bool>> filter)
+    {
+        return this._writeRepository.DeleteMany(filter);
+    }
+
+    public long DeleteMany(ISpecification<TEntity> specification)
+    {
+        return this._writeRepository.DeleteMany(specification);
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    public TEntity Get(TKey id, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.Get(id, configuration);
+    }
+
+    public IEnumerable<TEntity> GetAll(Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetAll(configuration);
+    }
+
+    public IEnumerable<TResult> GetMapped<TResult>(Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetMapped(filter, map, configuration);
+    }
+
+    public IEnumerable<TResult> GetMapped<TResult>(ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetMapped(specification, map, configuration);
+    }
+
+    public IEnumerable<TEntity> GetFiltered(Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetFiltered(filter, configuration);
+    }
+
+    public TEntity GetFirst(Expression<Func<TEntity, bool>> filter, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetFirst(filter, configuration);
+    }
+
+    public TEntity GetFirst(ISpecification<TEntity> specification, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetFirst(specification, configuration);
+    }
+
+    public TResult GetFirstMapped<TResult>(Expression<Func<TEntity, bool>> filter, Expression<Func<TEntity, TResult>> map, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetFirstMapped(filter, map, configuration);
+    }
+
+    public TResult GetFirstMapped<TResult>(ISpecification<TEntity> specification, Expression<Func<TEntity, TResult>> map, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetFirstMapped(specification, map, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(int limit, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetPaged(limit, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(ISpecification<TEntity> specification, int limit,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetPaged(specification, limit, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(Expression<Func<TEntity, bool>> filter, int limit,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetPaged(filter, limit, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(int pageIndex, int pageSize, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetPaged(pageIndex, pageSize, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(ISpecification<TEntity> specification, int pageIndex, int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetPaged(specification, pageIndex, pageSize, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(Expression<Func<TEntity, bool>> filter, int pageIndex, int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetPaged(filter, pageIndex, pageSize, configuration);
+    }
+
+    public TEntity GetSingle(Expression<Func<TEntity, bool>> filter, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetSingle(filter, configuration);
+    }
+
+    public TEntity GetSingle(ISpecification<TEntity> specification, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return this._readRepository.GetSingle(specification, configuration);
+    }
+
+    public void Merge(TEntity persisted, TEntity current)
+    {
+        this._writeRepository.Merge(persisted, current);
+    }
+
+    public void Modify(TEntity item)
+    {
+        this._writeRepository.Modify(item);
+    }
+
+    public void Remove(TEntity item)
+    {
+        this._writeRepository.Remove(item);
+    }
+
+    public void TrackItem(TEntity item)
+    {
+        this._writeRepository.TrackItem(item);
+    }
+
+    public long UpdateMany(Expression<Func<TEntity, bool>> filter, Expression<Func<TEntity, TEntity>> updateFactory)
+    {
+        return this._writeRepository.UpdateMany(filter, updateFactory);
+    }
+
+    public long UpdateMany(ISpecification<TEntity> specification, Expression<Func<TEntity, TEntity>> updateFactory)
+    {
+        return this._writeRepository.UpdateMany(specification, updateFactory);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (disposing)
+        {
+            this._readRepository?.Dispose();
+            this._writeRepository?.Dispose();
+            UnitOfWork?.Dispose();
+        }
+
+        _disposed = true;
     }
 }
diff --git a/src/Repository/Read/AsyncQueryableReadRepository.cs b/src/Repository/Read/AsyncQueryableReadRepository.cs
index c721d87..5182bb4 100644
--- a/src/Repository/Read/AsyncQueryableReadRepository.cs
+++ b/src/Repository/Read/AsyncQueryableReadRepository.cs
@@ -1,18 +1,690 @@
-using System.Diagnostics.CodeAnalysis;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
 using eQuantic.Core.Data.Repository;
 using eQuantic.Core.Data.Repository.Config;
 using eQuantic.Core.Data.Repository.Read;
+using eQuantic.Linq.Specification;
+using Microsoft.EntityFrameworkCore;
 
 namespace eQuantic.Core.Data.EntityFramework.Repository.Read;
 
 [ExcludeFromCodeCoverage]
 public class AsyncQueryableReadRepository<TUnitOfWork, TEntity, TKey> :
-    AsyncReadRepository<TUnitOfWork, QueryableConfiguration<TEntity>, TEntity, TKey>,
-    IAsyncQueryableReadRepository<TUnitOfWork, TEntity, TKey>
+    QueryableReadRepository<TUnitOfWork, TEntity, TKey>,
+    IAsyncQueryableReadRepository<TUnitOfWork, TEntity, TKey>,
+    IAsyncReadRepository<TUnitOfWork, QueryableConfiguration<TEntity>, TEntity, TKey>
     where TUnitOfWork : class, IQueryableUnitOfWork
     where TEntity : class, IEntity, new()
 {
+    private Set<TEntity> _dbSet;
+
     public AsyncQueryableReadRepository(TUnitOfWork unitOfWork) : base(unitOfWork)
     {
     }
+
+    public Task<IEnumerable<TEntity>> AllMatchingAsync(
+        ISpecification<TEntity> specification,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return AllMatchingAsync(specification, configuration, CancellationToken.None);
+    }
+    
+    public async Task<IEnumerable<TEntity>> AllMatchingAsync(
+        ISpecification<TEntity> specification,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return await GetQueryable(configuration, query =>
+                query
+                    .Where(specification.SatisfiedBy()))
+            .ToListAsync(cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> AllMatchingAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return AllMatchingAsync(specification, _ => { }, cancellationToken);
+    }
+
+    public Task<long> CountAsync(CancellationToken cancellationToken = default)
+    {
+        return GetSet().LongCountAsync(cancellationToken);
+    }
+
+    public Task<long> CountAsync(
+        ISpecification<TEntity> specification, 
+        CancellationToken cancellationToken = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification));
+        }
+
+        return this.CountAsync(specification.SatisfiedBy(), cancellationToken);
+    }
+
+    public Task<long> CountAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken = default)
+    {
+        return GetSet().LongCountAsync(filter, cancellationToken);
+    }
+
+    public Task<bool> AllAsync(
+        ISpecification<TEntity> specification,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return AllAsync(specification, configuration, CancellationToken.None);
+    }
+
+    public Task<bool> AllAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification));
+        }
+
+        return AllAsync(specification.SatisfiedBy(), configuration, cancellationToken);
+    }
+
+    public Task<bool> AllAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return AllAsync(specification, _ => { }, cancellationToken);
+    }
+    
+    public Task<bool> AllAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return AllAsync(filter, configuration, CancellationToken.None);
+    }
+    
+    public Task<bool> AllAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return GetQueryable(configuration, _ => _).AllAsync(filter, cancellationToken);
+    }
+    
+    public Task<bool> AllAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken)
+    {
+        return AllAsync(filter, _ => { }, cancellationToken);
+    }
+
+    public Task<bool> AnyAsync(
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return AnyAsync(configuration, CancellationToken.None);
+    }
+    
+    public Task<bool> AnyAsync(
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return GetQueryable(configuration, _ => _).AnyAsync(cancellationToken);
+    }
+    
+    public Task<bool> AnyAsync(
+        CancellationToken cancellationToken)
+    {
+        return AnyAsync(_ => { }, cancellationToken);
+    }
+
+    public Task<bool> AnyAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return AnyAsync(specification, configuration, CancellationToken.None);
+    }
+    
+    public Task<bool> AnyAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification));
+        }
+
+        return AnyAsync(specification.SatisfiedBy(), configuration, cancellationToken);
+    }
+    
+    public Task<bool> AnyAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return AnyAsync(specification, _ => {}, cancellationToken);
+    }
+
+    public Task<bool> AnyAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return AnyAsync(filter, configuration, CancellationToken.None);
+    }
+    
+    public Task<bool> AnyAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return GetQueryable(configuration, query => query.Where(filter)).AnyAsync(cancellationToken);
+    }
+    
+    public Task<bool> AnyAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken = default)
+    {
+        return AnyAsync(filter, _ => {}, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetAllAsync(
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetAllAsync(configuration, CancellationToken.None);
+    }
+    
+    public async Task<IEnumerable<TEntity>> GetAllAsync(
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return await GetQueryable(configuration, query => query.Where(_ => true))
+            .ToListAsync(cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetAllAsync(
+        CancellationToken cancellationToken = default)
+    {
+        return GetAllAsync(_ => { }, cancellationToken);
+    }
+
+    public Task<TEntity> GetAsync(
+        TKey id, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetAsync(id, configuration, CancellationToken.None);
+    }
+
+    public Task<TEntity> GetAsync(
+        TKey id, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        if (id == null)
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+
+        return GetInternalAsync(id, configuration, cancellationToken);
+    }
+    
+    public Task<TEntity> GetAsync(
+        TKey id,
+        CancellationToken cancellationToken)
+    {
+        return GetAsync(id, _ => {}, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetMappedAsync(filter, map, configuration, CancellationToken.None);
+    }
+    
+    public async Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return await GetQueryable(configuration, query => query.Where(filter))
+            .Select(map)
+            .ToListAsync(cancellationToken);
+    }
+    
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map,
+        CancellationToken cancellationToken)
+    {
+        return GetMappedAsync(filter, map, _ => { }, cancellationToken);
+    }
+
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetMappedAsync(specification, map, configuration, CancellationToken.None);
+    }
+    
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification));
+        }
+
+        return GetMappedAsync(specification.SatisfiedBy(), map, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map,
+        CancellationToken cancellationToken = default)
+    {
+        return GetMappedAsync(specification, map, _ => {}, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetFilteredAsync(
+        Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetFilteredAsync(filter, configuration, CancellationToken.None);
+    }
+    
+    public async Task<IEnumerable<TEntity>> GetFilteredAsync(
+        Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return await GetQueryable(configuration, query => query.Where(filter))
+            .ToListAsync(cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetFilteredAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken)
+    {
+        return GetFilteredAsync(filter, _ => { }, cancellationToken);
+    }
+
+    public Task<TEntity> GetFirstAsync(
+        Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetFirstAsync(filter, configuration, CancellationToken.None);
+    }
+    
+    public async Task<TEntity> GetFirstAsync(
+        Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return await GetQueryable(configuration, query => query.Where(filter))
+            .FirstOrDefaultAsync(cancellationToken);
+    }
+    
+    public Task<TEntity> GetFirstAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken)
+    {
+        return GetFirstAsync(filter, _ => { }, cancellationToken);
+    }
+
+    public Task<TEntity> GetFirstAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetFirstAsync(specification, configuration, CancellationToken.None);
+    }
+
+    public Task<TEntity> GetFirstAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification));
+        }
+
+        return GetFirstAsync(specification.SatisfiedBy(), configuration, cancellationToken);
+    }
+    
+    public Task<TEntity> GetFirstAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return GetFirstAsync(specification, _ => {}, cancellationToken);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetFirstMappedAsync(filter, map, configuration, CancellationToken.None);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        if (filter == null)
+        {
+            throw new ArgumentNullException(nameof(filter), "Filter expression cannot be null");
+        }
+        
+        return GetQueryable(configuration, query => query.Where(filter))
+            .Select(map)
+            .FirstOrDefaultAsync(cancellationToken);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map,
+        CancellationToken cancellationToken)
+    {
+        return GetFirstMappedAsync(filter, map, _ => { }, cancellationToken);
+    }
+
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetFirstMappedAsync(specification, map, configuration, CancellationToken.None);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification));
+        }
+
+        return GetFirstMappedAsync(specification.SatisfiedBy(), map, configuration, cancellationToken);
+    }
+    
+    public Task<TResult> GetFirstMappedAsync<TResult>(
+        ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map,
+        CancellationToken cancellationToken = default)
+    {
+        return GetFirstMappedAsync(specification, map, _ => {}, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int limit, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetPagedAsync(limit, configuration, CancellationToken.None);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int limit, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        return GetPagedAsync((Expression<Func<TEntity, bool>>)null, 1, limit, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int limit,
+        CancellationToken cancellationToken = default)
+    {
+        return GetPagedAsync(limit, _ => {}, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int limit,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetPagedAsync(specification, limit, configuration, CancellationToken.None);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int limit,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification));
+        }
+
+        return GetPagedAsync(specification.SatisfiedBy(), 1, limit, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int limit,
+        CancellationToken cancellationToken)
+    {
+        return GetPagedAsync(specification, limit, _ => {}, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int limit,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetPagedAsync(filter, limit, configuration, CancellationToken.None);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int limit,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return GetPagedAsync(filter, 1, limit, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int limit,
+        CancellationToken cancellationToken)
+    {
+        return GetPagedAsync(filter, limit, _ => {}, cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetPagedAsync(pageIndex, pageSize, configuration,
+            CancellationToken.None);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return GetPagedAsync((Expression<Func<TEntity, bool>>)null, pageIndex, pageSize, configuration,
+            cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        int pageIndex, 
+        int pageSize,
+        CancellationToken cancellationToken)
+    {
+        return GetPagedAsync(pageIndex, pageSize, _ => {},
+            cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetPagedAsync(specification, pageIndex, pageSize, configuration, CancellationToken.None);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int pageIndex, 
+        int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification));
+        }
+
+        return GetPagedAsync(specification.SatisfiedBy(), pageIndex, pageSize, configuration, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        ISpecification<TEntity> specification, 
+        int pageIndex, 
+        int pageSize,
+        CancellationToken cancellationToken)
+    {
+        return GetPagedAsync(specification, pageIndex, pageSize, _ => {}, cancellationToken);
+    }
+    
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int pageIndex,
+        int pageSize, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetPagedAsync(filter, pageIndex, pageSize, configuration, CancellationToken.None);
+    }
+    
+    public async Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int pageIndex,
+        int pageSize, 
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        var query = GetQueryable(configuration, internalQuery =>
+        {
+            if (filter != null)
+            {
+                internalQuery = internalQuery.Where(filter);
+            }
+
+            return internalQuery;
+        });
+
+
+        if (pageSize > 0)
+        {
+            return await query.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync(cancellationToken);
+        }
+
+        return await query.ToListAsync(cancellationToken);
+    }
+
+    public Task<IEnumerable<TEntity>> GetPagedAsync(
+        Expression<Func<TEntity, bool>> filter, 
+        int pageIndex,
+        int pageSize,
+        CancellationToken cancellationToken)
+    {
+        return GetPagedAsync(filter, pageIndex, pageSize, _ => {}, cancellationToken);
+    }
+    
+    public Task<TEntity> GetSingleAsync(
+        Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetSingleAsync(filter, configuration, CancellationToken.None);
+    }
+    
+    public async Task<TEntity> GetSingleAsync(
+        Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration, 
+        CancellationToken cancellationToken)
+    {
+        return await GetQueryable(configuration, query => query.Where(filter))
+            .SingleOrDefaultAsync(cancellationToken);
+    }
+    
+    public Task<TEntity> GetSingleAsync(
+        Expression<Func<TEntity, bool>> filter,
+        CancellationToken cancellationToken)
+    {
+        return GetSingleAsync(filter, _ => { }, cancellationToken);
+    }
+
+    public Task<TEntity> GetSingleAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetSingleAsync(specification, configuration, CancellationToken.None);
+    }
+    
+    public Task<TEntity> GetSingleAsync(
+        ISpecification<TEntity> specification, 
+        Action<QueryableConfiguration<TEntity>> configuration,
+        CancellationToken cancellationToken)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification));
+        }
+
+        return GetSingleAsync(specification.SatisfiedBy(), configuration, cancellationToken);
+    }
+    
+    public Task<TEntity> GetSingleAsync(
+        ISpecification<TEntity> specification,
+        CancellationToken cancellationToken)
+    {
+        return GetSingleAsync(specification, _ => {}, cancellationToken);
+    }
+
+    private async Task<TEntity> GetInternalAsync(TKey id, Action<QueryableConfiguration<TEntity>> configuration = default,
+        CancellationToken cancellationToken = default)
+    {
+        if (configuration == null)
+        {
+            return await GetSet().FindAsync(id, cancellationToken);
+        }
+
+        var idExpression = GetSet().GetExpression(id);
+        return await GetQueryable(configuration, query => query.Where(idExpression))
+            .SingleOrDefaultAsync(cancellationToken);
+    }
+    
+    private IQueryable<TEntity> GetQueryable(Action<QueryableConfiguration<TEntity>> configuration,
+        Func<IQueryable<TEntity>, IQueryable<TEntity>> internalQueryAction)
+    {
+        return GetSet().GetQueryable(configuration, internalQueryAction);
+    }
+    
+    private Set<TEntity> GetSet()
+    {
+        return _dbSet ??= (Set<TEntity>)UnitOfWork.CreateSet<TEntity>();
+    }
 }
diff --git a/src/Repository/Read/AsyncReadRepository.cs b/src/Repository/Read/AsyncReadRepository.cs
deleted file mode 100644
index fcb20ef..0000000
--- a/src/Repository/Read/AsyncReadRepository.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-using eQuantic.Core.Data.Repository;
-using eQuantic.Core.Data.Repository.Config;
-using eQuantic.Core.Data.Repository.Read;
-using eQuantic.Linq.Specification;
-using Microsoft.EntityFrameworkCore;
-
-namespace eQuantic.Core.Data.EntityFramework.Repository.Read;
-
-public class AsyncReadRepository<TUnitOfWork, TConfig, TEntity, TKey> :
-    ReadRepository<TUnitOfWork, TConfig, TEntity, TKey>, IAsyncReadRepository<TUnitOfWork, TConfig, TEntity, TKey>
-    where TUnitOfWork : IQueryableUnitOfWork
-    where TEntity : class, IEntity, new()
-    where TConfig : Configuration<TEntity>
-{
-    private Set<TEntity> _dbSet;
-
-    public AsyncReadRepository(TUnitOfWork unitOfWork) : base(unitOfWork)
-    {
-    }
-
-    public async Task<IEnumerable<TEntity>> AllMatchingAsync(ISpecification<TEntity> specification,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return await GetQueryable(configuration, query =>
-                query
-                    .Where(specification.SatisfiedBy()))
-            .ToListAsync(cancellationToken);
-    }
-
-    public Task<long> CountAsync(CancellationToken cancellationToken = default)
-    {
-        return GetSet().LongCountAsync(cancellationToken);
-    }
-
-    public Task<long> CountAsync(ISpecification<TEntity> specification, CancellationToken cancellationToken = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification));
-        }
-
-        return this.CountAsync(specification.SatisfiedBy(), cancellationToken);
-    }
-
-    public Task<long> CountAsync(Expression<Func<TEntity, bool>> filter, CancellationToken cancellationToken = default)
-    {
-        return GetSet().LongCountAsync(filter, cancellationToken);
-    }
-
-    public Task<bool> AllAsync(ISpecification<TEntity> specification, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification));
-        }
-
-        return this.AllAsync(specification.SatisfiedBy(), configuration, cancellationToken);
-    }
-
-    public Task<bool> AllAsync(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return GetQueryable(configuration, _ => _).AllAsync(filter, cancellationToken);
-    }
-
-    public Task<bool> AnyAsync(Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return GetQueryable(configuration, _ => _).AnyAsync(cancellationToken);
-    }
-
-    public Task<bool> AnyAsync(ISpecification<TEntity> specification, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification));
-        }
-
-        return this.AnyAsync(specification.SatisfiedBy(), configuration, cancellationToken);
-    }
-
-    public Task<bool> AnyAsync(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return GetQueryable(configuration, query => query.Where(filter)).AnyAsync(cancellationToken);
-    }
-
-    public async Task<IEnumerable<TEntity>> GetAllAsync(Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return await GetQueryable(configuration, query => query.Where(_ => true))
-            .ToListAsync(cancellationToken);
-    }
-
-    public Task<TEntity> GetAsync(TKey id, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        if (id == null)
-        {
-            throw new ArgumentNullException(nameof(id));
-        }
-
-        return GetInternalAsync(id, configuration, cancellationToken);
-    }
-
-    public async Task<IEnumerable<TResult>> GetMappedAsync<TResult>(Expression<Func<TEntity, bool>> filter,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return await GetQueryable(configuration, query => query.Where(filter))
-            .Select(map)
-            .ToListAsync(cancellationToken);
-    }
-
-    public Task<IEnumerable<TResult>> GetMappedAsync<TResult>(ISpecification<TEntity> specification,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification));
-        }
-
-        return this.GetMappedAsync(specification.SatisfiedBy(), map, configuration, cancellationToken);
-    }
-
-    private async Task<TEntity> GetInternalAsync(TKey id, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        if (configuration == null)
-        {
-            return await GetSet().FindAsync(id, cancellationToken);
-        }
-
-        var idExpression = GetSet().GetExpression(id);
-        return await GetQueryable(configuration, query => query.Where(idExpression))
-            .SingleOrDefaultAsync(cancellationToken);
-    }
-
-    public async Task<IEnumerable<TEntity>> GetFilteredAsync(Expression<Func<TEntity, bool>> filter,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return await GetQueryable(configuration, query => query.Where(filter))
-            .ToListAsync(cancellationToken);
-    }
-
-    public async Task<TEntity> GetFirstAsync(Expression<Func<TEntity, bool>> filter,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return await GetQueryable(configuration, query => query.Where(filter))
-            .FirstOrDefaultAsync(cancellationToken);
-    }
-
-    public Task<TEntity> GetFirstAsync(ISpecification<TEntity> specification, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification));
-        }
-
-        return GetFirstAsync(specification.SatisfiedBy(), configuration, cancellationToken);
-    }
-
-    public Task<TResult> GetFirstMappedAsync<TResult>(Expression<Func<TEntity, bool>> filter,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        if (filter == null)
-        {
-            throw new ArgumentNullException(nameof(filter), "Filter expression cannot be null");
-        }
-        
-        return GetQueryable(configuration, query => query.Where(filter))
-            .Select(map)
-            .FirstOrDefaultAsync(cancellationToken);
-    }
-
-    public Task<TResult> GetFirstMappedAsync<TResult>(ISpecification<TEntity> specification,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification));
-        }
-
-        return this.GetFirstMappedAsync(specification.SatisfiedBy(), map, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(int limit, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        return GetPagedAsync((Expression<Func<TEntity, bool>>)null, 1, limit, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(ISpecification<TEntity> specification, int limit,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification));
-        }
-
-        return GetPagedAsync(specification.SatisfiedBy(), 1, limit, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(Expression<Func<TEntity, bool>> filter, int limit,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return GetPagedAsync(filter, 1, limit, configuration, cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(int pageIndex, int pageSize,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return GetPagedAsync((Expression<Func<TEntity, bool>>)null, pageIndex, pageSize, configuration,
-            cancellationToken);
-    }
-
-    public Task<IEnumerable<TEntity>> GetPagedAsync(ISpecification<TEntity> specification, int pageIndex, int pageSize,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification));
-        }
-
-        return GetPagedAsync(specification.SatisfiedBy(), pageIndex, pageSize, configuration, cancellationToken);
-    }
-
-    public async Task<IEnumerable<TEntity>> GetPagedAsync(Expression<Func<TEntity, bool>> filter, int pageIndex,
-        int pageSize, Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        var query = GetQueryable(configuration, internalQuery =>
-        {
-            if (filter != null)
-            {
-                internalQuery = internalQuery.Where(filter);
-            }
-
-            return internalQuery;
-        });
-
-
-        if (pageSize > 0)
-        {
-            return await query.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync(cancellationToken);
-        }
-
-        return await query.ToListAsync(cancellationToken);
-    }
-
-    public async Task<TEntity> GetSingleAsync(Expression<Func<TEntity, bool>> filter,
-        Action<TConfig> configuration = default, CancellationToken cancellationToken = default)
-    {
-        return await GetQueryable(configuration, query => query.Where(filter))
-            .SingleOrDefaultAsync(cancellationToken);
-    }
-
-    public Task<TEntity> GetSingleAsync(ISpecification<TEntity> specification, Action<TConfig> configuration = default,
-        CancellationToken cancellationToken = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification));
-        }
-
-        return GetSingleAsync(specification.SatisfiedBy(), configuration, cancellationToken);
-    }
-
-    private IQueryable<TEntity> GetQueryable(Action<TConfig> configuration,
-        Func<IQueryable<TEntity>, IQueryable<TEntity>> internalQueryAction)
-    {
-        return GetSet().GetQueryable(configuration, internalQueryAction);
-    }
-
-    private Set<TEntity> GetSet()
-    {
-        return _dbSet ??= (Set<TEntity>)UnitOfWork.CreateSet<TEntity>();
-    }
-}
diff --git a/src/Repository/Read/QueryableReadRepository.cs b/src/Repository/Read/QueryableReadRepository.cs
index 9b1e09e..6752b25 100644
--- a/src/Repository/Read/QueryableReadRepository.cs
+++ b/src/Repository/Read/QueryableReadRepository.cs
@@ -1,18 +1,320 @@
-using System.Diagnostics.CodeAnalysis;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Linq.Expressions;
 using eQuantic.Core.Data.Repository;
 using eQuantic.Core.Data.Repository.Config;
 using eQuantic.Core.Data.Repository.Read;
+using eQuantic.Linq.Specification;
 
 namespace eQuantic.Core.Data.EntityFramework.Repository.Read;
 
 [ExcludeFromCodeCoverage]
 public class QueryableReadRepository<TUnitOfWork, TEntity, TKey> :
-    ReadRepository<TUnitOfWork, QueryableConfiguration<TEntity>, TEntity, TKey>,
-    IQueryableReadRepository<TUnitOfWork, TEntity, TKey>
+    IQueryableReadRepository<TUnitOfWork, TEntity, TKey>,
+    IReadRepository<TUnitOfWork, QueryableConfiguration<TEntity>, TEntity, TKey>
     where TUnitOfWork : IQueryableUnitOfWork
     where TEntity : class, IEntity, new()
 {
-    public QueryableReadRepository(TUnitOfWork unitOfWork) : base(unitOfWork)
+    private Set<TEntity> _dbSet;
+    private bool _disposed;
+    private const string SpecificationCannotBeNull = "Specification cannot be null";
+    private const string FilterExpressionCannotBeNull = "Filter expression cannot be null";
+    /// <summary>
+    /// Creates a new instance of the read repository
+    /// </summary>
+    /// <param name="unitOfWork">Associated Unit Of Work</param>
+    public QueryableReadRepository(TUnitOfWork unitOfWork)
     {
+        UnitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
+    }
+
+    /// <summary>
+    /// <see cref="IReadRepository{TUnitOfWork, TEntity, TKey}"/>
+    /// </summary>
+    public TUnitOfWork UnitOfWork { get; private set; }
+
+    public IEnumerable<TEntity> AllMatching(ISpecification<TEntity> specification,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
+        }
+
+        return GetQueryable(configuration, query => query.Where(specification.SatisfiedBy()));
+    }
+
+    public long Count()
+    {
+        return GetSet().LongCount();
+    }
+
+    public long Count(ISpecification<TEntity> specification)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
+        }
+
+        return this.Count(specification.SatisfiedBy());
+    }
+
+    public long Count(Expression<Func<TEntity, bool>> filter)
+    {
+        if (filter == null)
+        {
+            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
+        }
+
+        return GetSet().LongCount(filter);
+    }
+
+    public bool All(ISpecification<TEntity> specification, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
+        }
+
+        return this.All(specification.SatisfiedBy());
+    }
+
+    public bool All(Expression<Func<TEntity, bool>> filter, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (filter == null)
+        {
+            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
+        }
+
+        return GetQueryable(configuration, _ => _).All(filter);
+    }
+
+    public bool Any(Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetQueryable(configuration, _ => _).Any();
+    }
+
+    public bool Any(ISpecification<TEntity> specification, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
+        }
+
+        return this.Any(specification.SatisfiedBy());
+    }
+
+    public bool Any(Expression<Func<TEntity, bool>> filter, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (filter == null)
+        {
+            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
+        }
+
+        return GetQueryable(configuration, query => query.Where(filter)).Any();
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    public TEntity Get(TKey id, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (id == null)
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+
+        if (configuration == null)
+        {
+            return GetSet().Find(id);
+        }
+
+        var idExpression = GetSet().GetExpression(id);
+        return GetQueryable(configuration, query => query.Where(idExpression))
+            .SingleOrDefault();
+    }
+
+    public IEnumerable<TEntity> GetAll(Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetQueryable(configuration, query => query);
+    }
+
+    public IEnumerable<TResult> GetMapped<TResult>(Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetQueryable(configuration, query => query.Where(filter)).Select(map);
+    }
+
+    public IEnumerable<TResult> GetMapped<TResult>(ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
+        }
+
+        return this.GetMapped(specification.SatisfiedBy(), map, configuration);
+    }
+
+    public IEnumerable<TEntity> GetFiltered(Expression<Func<TEntity, bool>> filter,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (filter == null)
+        {
+            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
+        }
+
+        return GetQueryable(configuration, query => query.Where(filter));
+    }
+
+    public TEntity GetFirst(Expression<Func<TEntity, bool>> filter, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (filter == null)
+        {
+            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
+        }
+
+        return GetQueryable(configuration, query => query.Where(filter)).FirstOrDefault();
+    }
+
+    public TEntity GetFirst(ISpecification<TEntity> specification, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification),SpecificationCannotBeNull);
+        }
+
+        return GetQueryable(configuration, query => query.Where(specification.SatisfiedBy())).FirstOrDefault();
+    }
+
+    public TResult GetFirstMapped<TResult>(Expression<Func<TEntity, bool>> filter,
+        Expression<Func<TEntity, TResult>> map, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (filter == null)
+        {
+            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
+        }
+        return GetQueryable(configuration, query => query.Where(filter))
+            .Select(map)
+            .FirstOrDefault();
+    }
+
+    public TResult GetFirstMapped<TResult>(ISpecification<TEntity> specification,
+        Expression<Func<TEntity, TResult>> map, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
+        }
+
+        return this.GetFirstMapped(specification.SatisfiedBy(), map, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(int limit, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetPaged((Expression<Func<TEntity, bool>>)null, 1, limit, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(ISpecification<TEntity> specification, int limit,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
+        }
+
+        return GetPaged(specification.SatisfiedBy(), 1, limit, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(Expression<Func<TEntity, bool>> filter, int limit,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetPaged(filter, 1, limit, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(int pageIndex, int pageSize, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        return GetPaged((Expression<Func<TEntity, bool>>)null, pageIndex, pageSize, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(ISpecification<TEntity> specification, int pageIndex, int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
+        }
+
+        return GetPaged(specification.SatisfiedBy(), pageIndex, pageSize, configuration);
+    }
+
+    public IEnumerable<TEntity> GetPaged(Expression<Func<TEntity, bool>> filter, int pageIndex, int pageSize,
+        Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        var query = GetQueryable(configuration, internalQuery =>
+        {
+            if (filter != null)
+            {
+                internalQuery = internalQuery.Where(filter);
+            }
+
+            return internalQuery;
+        });
+        return pageSize > 0 ? query.Skip((pageIndex - 1) * pageSize).Take(pageSize) : query;
+    }
+
+    public TEntity GetSingle(Expression<Func<TEntity, bool>> filter, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (filter == null)
+        {
+            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
+        }
+
+        return GetQueryable(configuration, query => query.Where(filter))
+            .SingleOrDefault();
+    }
+
+    public TEntity GetSingle(ISpecification<TEntity> specification, Action<QueryableConfiguration<TEntity>> configuration = default)
+    {
+        if (specification == null)
+        {
+            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
+        }
+
+        return GetQueryable(configuration, query =>
+                query
+                    .Where(specification.SatisfiedBy()))
+            .SingleOrDefault();
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (disposing)
+        {
+            UnitOfWork?.Dispose();
+        }
+
+        _disposed = true;
+    }
+
+    private IQueryable<TEntity> GetQueryable(Action<QueryableConfiguration<TEntity>> configuration,
+        Func<IQueryable<TEntity>, IQueryable<TEntity>> internalQueryAction)
+    {
+        return GetSet().GetQueryable(configuration, internalQueryAction);
+    }
+
+    private Set<TEntity> GetSet()
+    {
+        return _dbSet ??= (Set<TEntity>)UnitOfWork.CreateSet<TEntity>();
     }
 }
diff --git a/src/Repository/Read/ReadRepository.cs b/src/Repository/Read/ReadRepository.cs
deleted file mode 100644
index 04151c0..0000000
--- a/src/Repository/Read/ReadRepository.cs
+++ /dev/null
@@ -1,317 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using eQuantic.Core.Data.Repository;
-using eQuantic.Core.Data.Repository.Config;
-using eQuantic.Core.Data.Repository.Read;
-using eQuantic.Linq.Specification;
-
-namespace eQuantic.Core.Data.EntityFramework.Repository.Read;
-
-public class ReadRepository<TUnitOfWork, TConfig, TEntity, TKey> : IReadRepository<TUnitOfWork, TConfig, TEntity, TKey>
-    where TUnitOfWork : IQueryableUnitOfWork
-    where TEntity : class, IEntity, new()
-    where TConfig : Configuration<TEntity>
-{
-    private Set<TEntity> _dbSet;
-    private bool _disposed;
-    private const string SpecificationCannotBeNull = "Specification cannot be null";
-    private const string FilterExpressionCannotBeNull = "Filter expression cannot be null";
-    /// <summary>
-    /// Creates a new instance of the read repository
-    /// </summary>
-    /// <param name="unitOfWork">Associated Unit Of Work</param>
-    public ReadRepository(TUnitOfWork unitOfWork)
-    {
-        UnitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
-    }
-
-    /// <summary>
-    /// <see cref="IReadRepository{TUnitOfWork, TEntity, TKey}"/>
-    /// </summary>
-    public TUnitOfWork UnitOfWork { get; private set; }
-
-    public IEnumerable<TEntity> AllMatching(ISpecification<TEntity> specification,
-        Action<TConfig> configuration = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
-        }
-
-        return GetQueryable(configuration, query => query.Where(specification.SatisfiedBy()));
-    }
-
-    public long Count()
-    {
-        return GetSet().LongCount();
-    }
-
-    public long Count(ISpecification<TEntity> specification)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
-        }
-
-        return this.Count(specification.SatisfiedBy());
-    }
-
-    public long Count(Expression<Func<TEntity, bool>> filter)
-    {
-        if (filter == null)
-        {
-            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
-        }
-
-        return GetSet().LongCount(filter);
-    }
-
-    public bool All(ISpecification<TEntity> specification, Action<TConfig> configuration = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
-        }
-
-        return this.All(specification.SatisfiedBy());
-    }
-
-    public bool All(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default)
-    {
-        if (filter == null)
-        {
-            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
-        }
-
-        return GetQueryable(configuration, _ => _).All(filter);
-    }
-
-    public bool Any(Action<TConfig> configuration = default)
-    {
-        return GetQueryable(configuration, _ => _).Any();
-    }
-
-    public bool Any(ISpecification<TEntity> specification, Action<TConfig> configuration = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
-        }
-
-        return this.Any(specification.SatisfiedBy());
-    }
-
-    public bool Any(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default)
-    {
-        if (filter == null)
-        {
-            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
-        }
-
-        return GetQueryable(configuration, query => query.Where(filter)).Any();
-    }
-
-    public void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
-    public TEntity Get(TKey id, Action<TConfig> configuration = default)
-    {
-        if (id == null)
-        {
-            throw new ArgumentNullException(nameof(id));
-        }
-
-        if (configuration == null)
-        {
-            return GetSet().Find(id);
-        }
-
-        var idExpression = GetSet().GetExpression(id);
-        return GetQueryable(configuration, query => query.Where(idExpression))
-            .SingleOrDefault();
-    }
-
-    public IEnumerable<TEntity> GetAll(Action<TConfig> configuration = default)
-    {
-        return GetQueryable(configuration, query => query);
-    }
-
-    public IEnumerable<TResult> GetMapped<TResult>(Expression<Func<TEntity, bool>> filter,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default)
-    {
-        return GetQueryable(configuration, query => query.Where(filter)).Select(map);
-    }
-
-    public IEnumerable<TResult> GetMapped<TResult>(ISpecification<TEntity> specification,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
-        }
-
-        return this.GetMapped(specification.SatisfiedBy(), map, configuration);
-    }
-
-    public IEnumerable<TEntity> GetFiltered(Expression<Func<TEntity, bool>> filter,
-        Action<TConfig> configuration = default)
-    {
-        if (filter == null)
-        {
-            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
-        }
-
-        return GetQueryable(configuration, query => query.Where(filter));
-    }
-
-    public TEntity GetFirst(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default)
-    {
-        if (filter == null)
-        {
-            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
-        }
-
-        return GetQueryable(configuration, query => query.Where(filter)).FirstOrDefault();
-    }
-
-    public TEntity GetFirst(ISpecification<TEntity> specification, Action<TConfig> configuration = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification),SpecificationCannotBeNull);
-        }
-
-        return GetQueryable(configuration, query => query.Where(specification.SatisfiedBy())).FirstOrDefault();
-    }
-
-    public TResult GetFirstMapped<TResult>(Expression<Func<TEntity, bool>> filter,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default)
-    {
-        if (filter == null)
-        {
-            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
-        }
-        return GetQueryable(configuration, query => query.Where(filter))
-            .Select(map)
-            .FirstOrDefault();
-    }
-
-    public TResult GetFirstMapped<TResult>(ISpecification<TEntity> specification,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
-        }
-
-        return this.GetFirstMapped(specification.SatisfiedBy(), map, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(int limit, Action<TConfig> configuration = default)
-    {
-        return GetPaged((Expression<Func<TEntity, bool>>)null, 1, limit, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(ISpecification<TEntity> specification, int limit,
-        Action<TConfig> configuration = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
-        }
-
-        return GetPaged(specification.SatisfiedBy(), 1, limit, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(Expression<Func<TEntity, bool>> filter, int limit,
-        Action<TConfig> configuration = default)
-    {
-        return GetPaged(filter, 1, limit, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(int pageIndex, int pageSize, Action<TConfig> configuration = default)
-    {
-        return GetPaged((Expression<Func<TEntity, bool>>)null, pageIndex, pageSize, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(ISpecification<TEntity> specification, int pageIndex, int pageSize,
-        Action<TConfig> configuration = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
-        }
-
-        return GetPaged(specification.SatisfiedBy(), pageIndex, pageSize, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(Expression<Func<TEntity, bool>> filter, int pageIndex, int pageSize,
-        Action<TConfig> configuration = default)
-    {
-        var query = GetQueryable(configuration, internalQuery =>
-        {
-            if (filter != null)
-            {
-                internalQuery = internalQuery.Where(filter);
-            }
-
-            return internalQuery;
-        });
-        return pageSize > 0 ? query.Skip((pageIndex - 1) * pageSize).Take(pageSize) : query;
-    }
-
-    public TEntity GetSingle(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default)
-    {
-        if (filter == null)
-        {
-            throw new ArgumentNullException(nameof(filter), FilterExpressionCannotBeNull);
-        }
-
-        return GetQueryable(configuration, query => query.Where(filter))
-            .SingleOrDefault();
-    }
-
-    public TEntity GetSingle(ISpecification<TEntity> specification, Action<TConfig> configuration = default)
-    {
-        if (specification == null)
-        {
-            throw new ArgumentNullException(nameof(specification), SpecificationCannotBeNull);
-        }
-
-        return GetQueryable(configuration, query =>
-                query
-                    .Where(specification.SatisfiedBy()))
-            .SingleOrDefault();
-    }
-
-    protected virtual void Dispose(bool disposing)
-    {
-        if (_disposed)
-        {
-            return;
-        }
-
-        if (disposing)
-        {
-            UnitOfWork?.Dispose();
-        }
-
-        _disposed = true;
-    }
-
-    private IQueryable<TEntity> GetQueryable(Action<TConfig> configuration,
-        Func<IQueryable<TEntity>, IQueryable<TEntity>> internalQueryAction)
-    {
-        return GetSet().GetQueryable(configuration, internalQueryAction);
-    }
-
-    private Set<TEntity> GetSet()
-    {
-        return _dbSet ??= (Set<TEntity>)UnitOfWork.CreateSet<TEntity>();
-    }
-}
diff --git a/src/Repository/Repository.cs b/src/Repository/Repository.cs
deleted file mode 100644
index f6325e6..0000000
--- a/src/Repository/Repository.cs
+++ /dev/null
@@ -1,251 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using eQuantic.Core.Data.EntityFramework.Repository.Read;
-using eQuantic.Core.Data.EntityFramework.Repository.Write;
-using eQuantic.Core.Data.Repository;
-using eQuantic.Core.Data.Repository.Config;
-using eQuantic.Core.Data.Repository.Read;
-using eQuantic.Core.Data.Repository.Write;
-using eQuantic.Linq.Specification;
-
-namespace eQuantic.Core.Data.EntityFramework.Repository;
-
-public class Repository<TUnitOfWork, TConfig, TEntity, TKey> : IRepository<TUnitOfWork, TConfig, TEntity, TKey>
-    where TUnitOfWork : IQueryableUnitOfWork
-    where TEntity : class, IEntity, new()
-    where TConfig : Configuration<TEntity>
-{
-    private readonly IReadRepository<TUnitOfWork, TConfig, TEntity, TKey> _readRepository;
-    private readonly IWriteRepository<TUnitOfWork, TEntity> _writeRepository;
-    private bool _disposed;
-
-    /// <summary>
-    /// Create a new instance of repository
-    /// </summary>
-    /// <param name="unitOfWork">Associated Unit Of Work</param>
-    public Repository(TUnitOfWork unitOfWork)
-    {
-        this.UnitOfWork = unitOfWork;
-        this._readRepository = new ReadRepository<TUnitOfWork, TConfig, TEntity, TKey>(unitOfWork);
-        this._writeRepository = new WriteRepository<TUnitOfWork, TEntity>(unitOfWork);
-    }
-
-    public TUnitOfWork UnitOfWork { get; private set; }
-
-    public void Add(TEntity item)
-    {
-        this._writeRepository.Add(item);
-    }
-
-    public IEnumerable<TEntity> AllMatching(ISpecification<TEntity> specification,
-        Action<TConfig> configuration = default)
-    {
-        return this._readRepository.AllMatching(specification, configuration);
-    }
-
-    public long Count()
-    {
-        return this._readRepository.Count();
-    }
-
-    public long Count(ISpecification<TEntity> specification)
-    {
-        return this._readRepository.Count(specification);
-    }
-
-    public long Count(Expression<Func<TEntity, bool>> filter)
-    {
-        return this._readRepository.Count(filter);
-    }
-
-    public bool All(ISpecification<TEntity> specification, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.All(specification, configuration);
-    }
-
-    public bool All(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.All(filter, configuration);
-    }
-
-    public bool Any(Action<TConfig> configuration = default)
-    {
-        return this._readRepository.Any(configuration);
-    }
-
-    public bool Any(ISpecification<TEntity> specification, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.Any(specification, configuration);
-    }
-
-    public bool Any(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.Any(filter, configuration);
-    }
-
-    public long DeleteMany(Expression<Func<TEntity, bool>> filter)
-    {
-        return this._writeRepository.DeleteMany(filter);
-    }
-
-    public long DeleteMany(ISpecification<TEntity> specification)
-    {
-        return this._writeRepository.DeleteMany(specification);
-    }
-
-    public void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
-    public TEntity Get(TKey id, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.Get(id, configuration);
-    }
-
-    public IEnumerable<TEntity> GetAll(Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetAll(configuration);
-    }
-
-    public IEnumerable<TResult> GetMapped<TResult>(Expression<Func<TEntity, bool>> filter,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetMapped(filter, map, configuration);
-    }
-
-    public IEnumerable<TResult> GetMapped<TResult>(ISpecification<TEntity> specification,
-        Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetMapped(specification, map, configuration);
-    }
-
-    public IEnumerable<TEntity> GetFiltered(Expression<Func<TEntity, bool>> filter,
-        Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetFiltered(filter, configuration);
-    }
-
-    public TEntity GetFirst(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetFirst(filter, configuration);
-    }
-
-    public TEntity GetFirst(ISpecification<TEntity> specification, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetFirst(specification, configuration);
-    }
-
-    public TResult GetFirstMapped<TResult>(Expression<Func<TEntity, bool>> filter, Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetFirstMapped(filter, map, configuration);
-    }
-
-    public TResult GetFirstMapped<TResult>(ISpecification<TEntity> specification, Expression<Func<TEntity, TResult>> map, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetFirstMapped(specification, map, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(int limit, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetPaged(limit, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(ISpecification<TEntity> specification, int limit,
-        Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetPaged(specification, limit, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(Expression<Func<TEntity, bool>> filter, int limit,
-        Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetPaged(filter, limit, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(int pageIndex, int pageSize, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetPaged(pageIndex, pageSize, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(ISpecification<TEntity> specification, int pageIndex, int pageSize,
-        Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetPaged(specification, pageIndex, pageSize, configuration);
-    }
-
-    public IEnumerable<TEntity> GetPaged(Expression<Func<TEntity, bool>> filter, int pageIndex, int pageSize,
-        Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetPaged(filter, pageIndex, pageSize, configuration);
-    }
-
-    public TEntity GetSingle(Expression<Func<TEntity, bool>> filter, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetSingle(filter, configuration);
-    }
-
-    public TEntity GetSingle(ISpecification<TEntity> specification, Action<TConfig> configuration = default)
-    {
-        return this._readRepository.GetSingle(specification, configuration);
-    }
-
-    public void Merge(TEntity persisted, TEntity current)
-    {
-        this._writeRepository.Merge(persisted, current);
-    }
-
-    public void Modify(TEntity item)
-    {
-        this._writeRepository.Modify(item);
-    }
-
-    public void Remove(TEntity item)
-    {
-        this._writeRepository.Remove(item);
-    }
-
-    public void TrackItem(TEntity item)
-    {
-        this._writeRepository.TrackItem(item);
-    }
-
-    public long UpdateMany(Expression<Func<TEntity, bool>> filter, Expression<Func<TEntity, TEntity>> updateFactory)
-    {
-        return this._writeRepository.UpdateMany(filter, updateFactory);
-    }
-
-    public long UpdateMany(ISpecification<TEntity> specification, Expression<Func<TEntity, TEntity>> updateFactory)
-    {
-        return this._writeRepository.UpdateMany(specification, updateFactory);
-    }
-
-    protected virtual void Dispose(bool disposing)
-    {
-        if (_disposed)
-        {
-            return;
-        }
-
-        if (disposing)
-        {
-            this._readRepository?.Dispose();
-            this._writeRepository?.Dispose();
-            UnitOfWork?.Dispose();
-        }
-
-        _disposed = true;
-    }
-}
-
-public class Repository<TUnitOfWork, TEntity, TKey> : Repository<TUnitOfWork, Configuration<TEntity>, TEntity, TKey>,
-    IRepository<TUnitOfWork, TEntity, TKey>
-    where TUnitOfWork : IQueryableUnitOfWork
-    where TEntity : class, IEntity, new()
-{
-    public Repository(TUnitOfWork unitOfWork) : base(unitOfWork)
-    {
-    }
-}
diff --git a/src/Repository/UnitOfWork.cs b/src/Repository/UnitOfWork.cs
index 25a0e5f..ff2957b 100644
--- a/src/Repository/UnitOfWork.cs
+++ b/src/Repository/UnitOfWork.cs
@@ -24,50 +24,15 @@ protected UnitOfWork(DbContext context) : base(context)
     internal DbContext GetDbContext() => Context;
 }
 
-public abstract class UnitOfWork<TUnitOfWork, TDbContext> : UnitOfWork<TDbContext>, ISqlUnitOfWork<TUnitOfWork>
-    where TDbContext : DbContext 
-    where TUnitOfWork : ISqlUnitOfWork
-{
-    private readonly IServiceProvider _serviceProvider;
-    
-    protected UnitOfWork(IServiceProvider serviceProvider, TDbContext context) : base(context)
-    {
-        _serviceProvider = serviceProvider;
-    }
-    
-    public virtual IRepository<TUnitOfWork, TEntity, TKey> GetRepository<TEntity, TKey>()
-        where TEntity : class, IEntity, new()
-    {
-        return _serviceProvider.GetRequiredService<Repository<TUnitOfWork, TEntity, TKey>>();
-    }
-
-    public IAsyncRepository<TUnitOfWork, TEntity, TKey> GetAsyncRepository<TEntity, TKey>()
-        where TEntity : class, IEntity, new()
-    {
-        return _serviceProvider.GetRequiredService<AsyncRepository<TUnitOfWork, TEntity, TKey>>();
-    }
-
-    public IQueryableRepository<TUnitOfWork, TEntity, TKey> GetQueryableRepository<TEntity, TKey>()
-        where TEntity : class, IEntity, new()
-    {
-        return _serviceProvider.GetRequiredService<QueryableRepository<TUnitOfWork, TEntity, TKey>>();
-    }
-
-    public IAsyncQueryableRepository<TUnitOfWork, TEntity, TKey> GetAsyncQueryableRepository<TEntity, TKey>()
-        where TEntity : class, IEntity, new()
-    {
-        return _serviceProvider.GetRequiredService<AsyncQueryableRepository<TUnitOfWork, TEntity, TKey>>();
-    }
-}
-
 public abstract class UnitOfWork<TDbContext> : UnitOfWork, ISqlUnitOfWork 
     where TDbContext : DbContext
 {
     private readonly TDbContext _context;
-    
+    private readonly IServiceProvider _serviceProvider;
 
-    protected UnitOfWork(TDbContext context) : base(context)
+    protected UnitOfWork(IServiceProvider serviceProvider, TDbContext context) : base(context)
     {
+        _serviceProvider = serviceProvider;
         _context = context;
     }
 
@@ -269,6 +234,34 @@ public virtual SaveOptions GetSaveOptions()
         return new SaveOptions();
     }
 
+    public virtual IRepository<TUnitOfWork, TEntity, TKey> GetRepository<TUnitOfWork, TEntity, TKey>()
+        where TEntity : class, IEntity, new() where TUnitOfWork : IUnitOfWork
+    {
+        var repo = _serviceProvider.GetRequiredService<IRepository<TUnitOfWork, TEntity, TKey>>();
+        return repo;
+    }
+
+    public IAsyncRepository<TUnitOfWork, TEntity, TKey> GetAsyncRepository<TUnitOfWork, TEntity, TKey>()
+        where TEntity : class, IEntity, new() 
+        where TUnitOfWork : IUnitOfWork
+    {
+        return _serviceProvider.GetRequiredService<IAsyncRepository<TUnitOfWork, TEntity, TKey>>();
+    }
+
+    public IQueryableRepository<TUnitOfWork, TEntity, TKey> GetQueryableRepository<TUnitOfWork, TEntity, TKey>()
+        where TEntity : class, IEntity, new() 
+        where TUnitOfWork : IQueryableUnitOfWork
+    {
+        return _serviceProvider.GetRequiredService<IQueryableRepository<TUnitOfWork, TEntity, TKey>>();
+    }
+
+    public IAsyncQueryableRepository<TUnitOfWork, TEntity, TKey> GetAsyncQueryableRepository<TUnitOfWork, TEntity, TKey>()
+        where TEntity : class, IEntity, new() 
+        where TUnitOfWork : IQueryableUnitOfWork
+    {
+        return _serviceProvider.GetRequiredService<IAsyncQueryableRepository<TUnitOfWork, TEntity, TKey>>();
+    }
+    
     private Data.Repository.ISet<TEntity> InternalCreateSet<TEntity>() where TEntity : class, IEntity, new() =>
         new Set<TEntity>(_context);
 }
diff --git a/src/eQuantic.Core.Data.EntityFramework.csproj b/src/eQuantic.Core.Data.EntityFramework.csproj
index 06509ec..78e81a7 100644
--- a/src/eQuantic.Core.Data.EntityFramework.csproj
+++ b/src/eQuantic.Core.Data.EntityFramework.csproj
@@ -4,7 +4,7 @@
 	<PropertyGroup>
 		<Description>Core Data library for Entity Framework</Description>
 		<AssemblyTitle>eQuantic.Core.Data.EntityFramework</AssemblyTitle>
-		<Version>4.1.3.0</Version>
+		<Version>4.2.0.0</Version>
 		<Authors>eQuantic Systems</Authors>
 		<TargetFrameworks>netstandard2.1;net6.0;net7.0;net8.0</TargetFrameworks>
 		<AssemblyName>eQuantic.Core.Data.EntityFramework</AssemblyName>
@@ -23,15 +23,15 @@
 		<PackageLicenseFile>LICENSE</PackageLicenseFile>
 		<PackageReadmeFile>README.md</PackageReadmeFile>
 		<Copyright>Copyright ©  2016</Copyright>
-		<AssemblyVersion>4.1.3.0</AssemblyVersion>
-		<FileVersion>4.1.3.0</FileVersion>
+		<AssemblyVersion>4.2.0.0</AssemblyVersion>
+		<FileVersion>4.2.0.0</FileVersion>
 		<PackageIcon>Icon.png</PackageIcon>
 		<LangVersion>latest</LangVersion>
 	</PropertyGroup>
 
 	<ItemGroup>
 		<PackageReference Include="eQuantic.Core" Version="1.7.0" />
-		<PackageReference Include="eQuantic.Core.Data" Version="4.1.1" />
+		<PackageReference Include="eQuantic.Core.Data" Version="4.2.0" />
 	</ItemGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.1' ">
@@ -46,7 +46,7 @@
 			<PrivateAssets>all</PrivateAssets>
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 		</PackageReference>
-		<PackageReference Include="Z.EntityFramework.Plus.EFCore" Version="3.101.0" />
+		<PackageReference Include="Z.EntityFramework.Plus.EFCore" Version="3.101.1.3" />
 	</ItemGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'net6.0' ">
@@ -61,7 +61,7 @@
 			<PrivateAssets>all</PrivateAssets>
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 		</PackageReference>
-		<PackageReference Include="Z.EntityFramework.Plus.EFCore" Version="6.101.0" />
+		<PackageReference Include="Z.EntityFramework.Plus.EFCore" Version="6.101.1.3" />
 	</ItemGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'net7.0' ">
@@ -76,7 +76,7 @@
 			<PrivateAssets>all</PrivateAssets>
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 		</PackageReference>
-		<PackageReference Include="Z.EntityFramework.Plus.EFCore" Version="7.101.0" />
+		<PackageReference Include="Z.EntityFramework.Plus.EFCore" Version="7.101.1.3" />
 	</ItemGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'net8.0' ">
@@ -91,7 +91,7 @@
 			<PrivateAssets>all</PrivateAssets>
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 		</PackageReference>
-		<PackageReference Include="Z.EntityFramework.Plus.EFCore" Version="8.101.0" />
+		<PackageReference Include="Z.EntityFramework.Plus.EFCore" Version="8.101.1.3" />
 	</ItemGroup>
 	
 	<ItemGroup>