diff --git a/README.md b/README.md
index f212a00..4048fcb 100644
--- a/README.md
+++ b/README.md
@@ -118,7 +118,7 @@ public class OrderMapper : IMapper<OrderData, Order>, IMapper<OrderRequest, Orde
 ```
 ### The services
 ```csharp
-public interface IOrderService : ICrudServiceBase<Order, OrderRequest>
+public interface IOrderService : ICrudService<Order, OrderRequest>
 {
     
 }
@@ -182,6 +182,6 @@ or
 
 ```csharp
 ...
-app.MapAllCrud(assembly);
+app.MapAllCrud(opt => opt.FromAssembly(assembly));
 app.Run();
 ```
\ No newline at end of file
diff --git a/src/eQuantic.Core.Api.Crud/Controllers/CrudControllerBase.cs b/src/eQuantic.Core.Api.Crud/Controllers/CrudControllerBase.cs
index 225a546..fd3bd56 100644
--- a/src/eQuantic.Core.Api.Crud/Controllers/CrudControllerBase.cs
+++ b/src/eQuantic.Core.Api.Crud/Controllers/CrudControllerBase.cs
@@ -13,13 +13,13 @@ namespace eQuantic.Core.Api.Crud.Controllers;
 /// <typeparam name="TRequest"></typeparam>
 public abstract class CrudControllerBase<TEntity, TRequest> : ControllerBase, ICrudController<TEntity, TRequest> where TEntity : class, new()
 {
-    private readonly ICrudServiceBase<TEntity, TRequest> _service;
+    private readonly ICrudService<TEntity, TRequest> _service;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="CrudControllerBase{TEntity, TRequest}"/> class
     /// </summary>
     /// <param name="service"></param>
-    protected CrudControllerBase(ICrudServiceBase<TEntity, TRequest> service)
+    protected CrudControllerBase(ICrudService<TEntity, TRequest> service)
     {
         _service = service;
     }
diff --git a/src/eQuantic.Core.Api.Crud/Extensions/WepApplicationExtensions.cs b/src/eQuantic.Core.Api.Crud/Extensions/WepApplicationExtensions.cs
index 6d4ad46..cf05b67 100644
--- a/src/eQuantic.Core.Api.Crud/Extensions/WepApplicationExtensions.cs
+++ b/src/eQuantic.Core.Api.Crud/Extensions/WepApplicationExtensions.cs
@@ -20,16 +20,20 @@ public static class WepApplicationExtensions
     /// Map all CRUD endpoints
     /// </summary>
     /// <param name="app"></param>
-    /// <param name="assembly"></param>
+    /// <param name="options">Map all CRUD options</param>
     /// <returns></returns>
-    public static WebApplication MapAllCrud(this WebApplication app, Assembly assembly)
+    public static WebApplication MapAllCrud(this WebApplication app, Action<AllCrudOptions>? options = null)
     {
+        var allCrudOptions = new AllCrudOptions();
+        options?.Invoke(allCrudOptions);
+        
         var extensionType = typeof(WepApplicationExtensions);
 
+        var assembly = allCrudOptions.GetAssembly() ?? Assembly.GetExecutingAssembly();
         var types = assembly.GetTypes()
             .Where(o =>
                 o is { IsAbstract: false, IsInterface: false } &&
-                o.GetInterfaces().Any(i => i == typeof(ICrudServiceBase)) &&
+                o.GetInterfaces().Any(i => i == typeof(ICrudService)) &&
                 o.GetCustomAttribute<MapCrudEndpointsAttribute>() != null);
 
         foreach (var type in types)
@@ -45,7 +49,7 @@ public static WebApplication MapAllCrud(this WebApplication app, Assembly assemb
 
             var crudInterface = interfaces
                 .FirstOrDefault(o =>
-                    o.GenericTypeArguments.Length > 0 && o.GetGenericTypeDefinition() == typeof(ICrudServiceBase<,>));
+                    o.GenericTypeArguments.Length > 0 && o.GetGenericTypeDefinition() == typeof(ICrudService<,>));
 
             if (crudInterface == null)
             {
@@ -54,7 +58,9 @@ public static WebApplication MapAllCrud(this WebApplication app, Assembly assemb
 
             var entityType = crudInterface.GenericTypeArguments[0];
             var requestType = crudInterface.GenericTypeArguments[1];
-
+            var crudOptions = allCrudOptions.GetOptions().ContainsKey(entityType)
+                ? allCrudOptions.GetOptions()[entityType]
+                : null;
             var method = extensionType.GetMethod(nameof(MapCrud))
                 ?.MakeGenericMethod(entityType, requestType, serviceType);
             method?.Invoke(null, new object?[]
@@ -65,39 +71,62 @@ public static WebApplication MapAllCrud(this WebApplication app, Assembly assemb
 
                     if (crudEndpoints.ReferenceType != null)
                         opt.WithReference(crudEndpoints.ReferenceType);
+
+                    crudOptions?.Invoke(opt);
                 })
             });
         }
 
         return app;
     }
-
+    
     /// <summary>
-    /// Map CRUD endpoints
+    /// Map Readers endpoints
     /// </summary>
     /// <param name="app">The web application</param>
     /// <param name="options">The options</param>
     /// <typeparam name="TEntity"></typeparam>
-    /// <typeparam name="TRequest"></typeparam>
     /// <typeparam name="TService"></typeparam>
     /// <returns></returns>
-    public static WebApplication MapCrud<TEntity, TRequest, TService>(this WebApplication app,
+    public static WebApplication MapReaders<TEntity, TService>(this WebApplication app,
         Action<CrudOptions<TEntity>>? options = null)
         where TEntity : class, new()
-        where TService : ICrudServiceBase<TEntity, TRequest>
+        where TService : IReaderService<TEntity>
     {
         var crudOptions = new CrudOptions<TEntity>();
         options?.Invoke(crudOptions);
 
         if ((crudOptions.Verbs & CrudEndpointVerbs.OnlyGetById) == CrudEndpointVerbs.OnlyGetById)
         {
-            app.MapGetById<TEntity, TRequest, TService>(crudOptions);
+            app.MapGetById<TEntity, TService>(crudOptions);
         }
 
         if ((crudOptions.Verbs & CrudEndpointVerbs.OnlyGetPaged) == CrudEndpointVerbs.OnlyGetPaged)
         {
-            app.MapGetPagedList<TEntity, TRequest, TService>(crudOptions);
+            app.MapGetPagedList<TEntity, TService>(crudOptions);
         }
+        
+        return app;
+    }
+
+    /// <summary>
+    /// Map CRUD endpoints
+    /// </summary>
+    /// <param name="app">The web application</param>
+    /// <param name="options">The options</param>
+    /// <typeparam name="TEntity"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <typeparam name="TService"></typeparam>
+    /// <returns></returns>
+    public static WebApplication MapCrud<TEntity, TRequest, TService>(this WebApplication app,
+        Action<CrudOptions<TEntity>>? options = null)
+        where TEntity : class, new()
+        where TService : ICrudService<TEntity, TRequest>
+    {
+        var crudOptions = new CrudOptions<TEntity>();
+        options?.Invoke(crudOptions);
+
+        app.MapReaders<TEntity, TService>(options);
 
         if ((crudOptions.Verbs & CrudEndpointVerbs.OnlyCreate) == CrudEndpointVerbs.OnlyCreate)
         {
@@ -132,13 +161,13 @@ private static string GetPattern<TEntity>(bool withId = false, Type? referenceTy
         return pattern;
     }
 
-    private static WebApplication MapGetById<TEntity, TRequest, TService>(this WebApplication app,
+    private static WebApplication MapGetById<TEntity, TService>(this WebApplication app,
         CrudOptions<TEntity> options)
         where TEntity : class, new()
-        where TService : ICrudServiceBase<TEntity, TRequest>
+        where TService : IReaderService<TEntity>
     {
         var pattern = GetPattern<TEntity>(true, options.Get.ReferenceType);
-        var handlers = new CrudEndpointHandlers<TEntity, TRequest, TService>(options);
+        var handlers = new ReaderEndpointHandlers<TEntity, TService>(options);
         Delegate handler = options.Get.ReferenceType != null
             ? handlers.GetReferencedById
             : handlers.GetById;
@@ -151,13 +180,13 @@ private static WebApplication MapGetById<TEntity, TRequest, TService>(this WebAp
         return app;
     }
 
-    private static WebApplication MapGetPagedList<TEntity, TRequest, TService>(this WebApplication app,
+    private static WebApplication MapGetPagedList<TEntity, TService>(this WebApplication app,
         CrudOptions<TEntity> options)
         where TEntity : class, new()
-        where TService : ICrudServiceBase<TEntity, TRequest>
+        where TService : IReaderService<TEntity>
     {
         var pattern = GetPattern<TEntity>(false, options.List.ReferenceType);
-        var handlers = new CrudEndpointHandlers<TEntity, TRequest, TService>(options);
+        var handlers = new ReaderEndpointHandlers<TEntity, TService>(options);
         Delegate handler = options.List.ReferenceType != null
             ? handlers.GetReferencedPagedList
             : handlers.GetPagedList;
@@ -172,7 +201,7 @@ private static WebApplication MapGetPagedList<TEntity, TRequest, TService>(this
     private static WebApplication MapCreate<TEntity, TRequest, TService>(this WebApplication app,
         CrudOptions<TEntity> options)
         where TEntity : class, new()
-        where TService : ICrudServiceBase<TEntity, TRequest>
+        where TService : ICrudService<TEntity, TRequest>
     {
         var pattern = GetPattern<TEntity>(false, options.Create.ReferenceType);
         var handlers = new CrudEndpointHandlers<TEntity, TRequest, TService>(options);
@@ -189,7 +218,7 @@ private static WebApplication MapCreate<TEntity, TRequest, TService>(this WebApp
     private static WebApplication MapUpdate<TEntity, TRequest, TService>(this WebApplication app,
         CrudOptions<TEntity> options)
         where TEntity : class, new()
-        where TService : ICrudServiceBase<TEntity, TRequest>
+        where TService : ICrudService<TEntity, TRequest>
     {
         var pattern = GetPattern<TEntity>(true, options.Update.ReferenceType);
         var handlers = new CrudEndpointHandlers<TEntity, TRequest, TService>(options);
@@ -207,7 +236,7 @@ private static WebApplication MapUpdate<TEntity, TRequest, TService>(this WebApp
     private static WebApplication MapDelete<TEntity, TRequest, TService>(this WebApplication app,
         CrudOptions<TEntity> options)
         where TEntity : class, new()
-        where TService : ICrudServiceBase<TEntity, TRequest>
+        where TService : ICrudService<TEntity, TRequest>
     {
         var pattern = GetPattern<TEntity>(true, options.Delete.ReferenceType);
         var handlers = new CrudEndpointHandlers<TEntity, TRequest, TService>(options);
diff --git a/src/eQuantic.Core.Api.Crud/Handlers/CrudEndpointHandlers.cs b/src/eQuantic.Core.Api.Crud/Handlers/CrudEndpointHandlers.cs
index b1bce39..5352d81 100644
--- a/src/eQuantic.Core.Api.Crud/Handlers/CrudEndpointHandlers.cs
+++ b/src/eQuantic.Core.Api.Crud/Handlers/CrudEndpointHandlers.cs
@@ -18,7 +18,7 @@ namespace eQuantic.Core.Api.Crud.Handlers;
 /// <typeparam name="TService"></typeparam>
 public sealed class CrudEndpointHandlers<TEntity, TRequest, TService>
     where TEntity : class, new()
-    where TService : ICrudServiceBase<TEntity, TRequest>
+    where TService : ICrudService<TEntity, TRequest>
 {
     private readonly CrudOptions<TEntity> _options;
 
@@ -30,78 +30,6 @@ public CrudEndpointHandlers(CrudOptions<TEntity> options)
     {
         _options = options;
     }
-    
-    /// <summary>
-    /// Get referenced entity by identifier
-    /// </summary>
-    /// <param name="referenceId"></param>
-    /// <param name="id"></param>
-    /// <param name="service"></param>
-    /// <returns></returns>
-    public async Task<Results<Ok<TEntity>, NotFound>> GetReferencedById(
-        [FromRoute] int referenceId, 
-        [FromRoute] int id, 
-        [FromServices]TService service)
-    {
-        var request = new ItemRequest<int>(referenceId, id);
-        return await GetById(request, service);
-    }
-    
-    /// <summary>
-    /// Get entity by identifier
-    /// </summary>
-    /// <param name="id"></param>
-    /// <param name="service"></param>
-    /// <returns></returns>
-    public async Task<Results<Ok<TEntity>, NotFound>> GetById(
-        [FromRoute] int id, 
-        [FromServices]TService service)
-    {
-        var request = new ItemRequest(id);
-        return await GetById(request, service);
-    }
-
-    /// <summary>
-    /// Get paged list of referenced entity by criteria
-    /// </summary>
-    /// <param name="referenceId"></param>
-    /// <param name="pageIndex"></param>
-    /// <param name="pageSize"></param>
-    /// <param name="filterBy"></param>
-    /// <param name="orderBy"></param>
-    /// <param name="service"></param>
-    /// <returns></returns>
-    public async Task<Ok<PagedListResult<TEntity>>> GetReferencedPagedList(
-        [FromRoute] int referenceId, 
-        [FromQuery] int? pageIndex, 
-        [FromQuery] int? pageSize, 
-        [FromQuery] IFiltering[]? filterBy, 
-        [FromQuery] ISorting[]? orderBy, 
-        [FromServices]TService service)
-    {
-        var request = new PagedListRequest<TEntity,int>(referenceId, pageIndex, pageSize, filterBy, orderBy);
-        return await GetPagedList(request, service);
-    }
-    
-    /// <summary>
-    /// Get paged list of entity by criteria
-    /// </summary>
-    /// <param name="pageIndex"></param>
-    /// <param name="pageSize"></param>
-    /// <param name="filterBy"></param>
-    /// <param name="orderBy"></param>
-    /// <param name="service"></param>
-    /// <returns></returns>
-    public async Task<Ok<PagedListResult<TEntity>>> GetPagedList(
-        [FromQuery] int? pageIndex, 
-        [FromQuery] int? pageSize, 
-        [FromQuery] IFiltering[]? filterBy, 
-        [FromQuery] ISorting[]? orderBy, 
-        [FromServices]TService service)
-    {
-        var request = new PagedListRequest<TEntity>(pageIndex, pageSize, filterBy, orderBy);
-        return await GetPagedList(request, service);
-    }
 
     /// <summary>
     /// Create an entity
@@ -197,23 +125,6 @@ public async Task<Results<Ok, BadRequest>> ReferencedDelete(
         return await Delete(request, service);
     }
     
-    private static async Task<Results<Ok<TEntity>, NotFound>> GetById(ItemRequest request, TService service)
-    {
-        var result = await service.GetByIdAsync(request);
-        if (result != null)
-            return TypedResults.Ok(result);
-
-        return TypedResults.NotFound();
-    }
-
-    private static async Task<Ok<PagedListResult<TEntity>>> GetPagedList(
-        PagedListRequest<TEntity> request,
-        TService service)
-    {
-        var result = await service.GetPagedListAsync(request);
-        return TypedResults.Ok(new PagedListResult<TEntity>(result));
-    }
-    
     private async Task<CreatedAtRoute<int>> Create(
         CreateRequest<TRequest> request, 
         TService service)
diff --git a/src/eQuantic.Core.Api.Crud/Handlers/ReaderEndpointHandlers.cs b/src/eQuantic.Core.Api.Crud/Handlers/ReaderEndpointHandlers.cs
new file mode 100644
index 0000000..8fa3a40
--- /dev/null
+++ b/src/eQuantic.Core.Api.Crud/Handlers/ReaderEndpointHandlers.cs
@@ -0,0 +1,117 @@
+using eQuantic.Core.Api.Crud.Options;
+using eQuantic.Core.Application.Crud.Entities.Requests;
+using eQuantic.Core.Application.Crud.Services;
+using eQuantic.Core.Application.Entities.Results;
+using eQuantic.Linq.Filter;
+using eQuantic.Linq.Sorter;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.AspNetCore.Mvc;
+
+namespace eQuantic.Core.Api.Crud.Handlers;
+
+public class ReaderEndpointHandlers<TEntity, TService>
+    where TEntity : class, new()
+    where TService : IReaderService<TEntity>
+{
+    private readonly CrudOptions<TEntity> _options;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ReaderEndpointHandlers{TEntity, TService}"/> class
+    /// </summary>
+    /// <param name="options"></param>
+    public ReaderEndpointHandlers(CrudOptions<TEntity> options)
+    {
+        _options = options;
+    }
+    
+    /// <summary>
+    /// Get referenced entity by identifier
+    /// </summary>
+    /// <param name="referenceId"></param>
+    /// <param name="id"></param>
+    /// <param name="service"></param>
+    /// <returns></returns>
+    public async Task<Results<Ok<TEntity>, NotFound>> GetReferencedById(
+        [FromRoute] int referenceId, 
+        [FromRoute] int id, 
+        [FromServices]TService service)
+    {
+        var request = new ItemRequest<int>(referenceId, id);
+        return await GetById(request, service);
+    }
+    
+    /// <summary>
+    /// Get entity by identifier
+    /// </summary>
+    /// <param name="id"></param>
+    /// <param name="service"></param>
+    /// <returns></returns>
+    public async Task<Results<Ok<TEntity>, NotFound>> GetById(
+        [FromRoute] int id, 
+        [FromServices]TService service)
+    {
+        var request = new ItemRequest(id);
+        return await GetById(request, service);
+    }
+
+    /// <summary>
+    /// Get paged list of referenced entity by criteria
+    /// </summary>
+    /// <param name="referenceId"></param>
+    /// <param name="pageIndex"></param>
+    /// <param name="pageSize"></param>
+    /// <param name="filterBy"></param>
+    /// <param name="orderBy"></param>
+    /// <param name="service"></param>
+    /// <returns></returns>
+    public async Task<Ok<PagedListResult<TEntity>>> GetReferencedPagedList(
+        [FromRoute] int referenceId, 
+        [FromQuery] int? pageIndex, 
+        [FromQuery] int? pageSize, 
+        [FromQuery] IFiltering[]? filterBy, 
+        [FromQuery] ISorting[]? orderBy, 
+        [FromServices]TService service)
+    {
+        var request = new PagedListRequest<TEntity,int>(referenceId, pageIndex, pageSize, filterBy, orderBy);
+        return await GetPagedList(request, service);
+    }
+    
+    /// <summary>
+    /// Get paged list of entity by criteria
+    /// </summary>
+    /// <param name="pageIndex"></param>
+    /// <param name="pageSize"></param>
+    /// <param name="filterBy"></param>
+    /// <param name="orderBy"></param>
+    /// <param name="service"></param>
+    /// <returns></returns>
+    public async Task<Ok<PagedListResult<TEntity>>> GetPagedList(
+        [FromQuery] int? pageIndex, 
+        [FromQuery] int? pageSize, 
+        [FromQuery] IFiltering[]? filterBy, 
+        [FromQuery] ISorting[]? orderBy, 
+        [FromServices]TService service)
+    {
+        var request = new PagedListRequest<TEntity>(pageIndex, pageSize, filterBy, orderBy);
+        return await GetPagedList(request, service);
+    }
+    
+    private static async Task<Results<Ok<TEntity>, NotFound>> GetById(ItemRequest request, TService service)
+    {
+        var result = await service.GetByIdAsync(request);
+        if (result != null)
+            return TypedResults.Ok(result);
+
+        return TypedResults.NotFound();
+    }
+
+    private static async Task<Ok<PagedListResult<TEntity>>> GetPagedList(
+        PagedListRequest<TEntity> request,
+        TService service)
+    {
+        var result = await service.GetPagedListAsync(request);
+        return TypedResults.Ok(new PagedListResult<TEntity>(result));
+    }
+
+}
\ No newline at end of file
diff --git a/src/eQuantic.Core.Api.Crud/Options/AllCrudOptions.cs b/src/eQuantic.Core.Api.Crud/Options/AllCrudOptions.cs
new file mode 100644
index 0000000..ed7203b
--- /dev/null
+++ b/src/eQuantic.Core.Api.Crud/Options/AllCrudOptions.cs
@@ -0,0 +1,39 @@
+using System.Reflection;
+
+namespace eQuantic.Core.Api.Crud.Options;
+
+public class AllCrudOptions
+{
+    private Assembly? _assembly = null;
+    private readonly Dictionary<Type, Action<ICrudOptions>> _options = new();
+
+    public AllCrudOptions FromAssembly(Assembly assembly)
+    {
+        _assembly = assembly;
+        return this;
+    }
+    
+    public EntityCrudOptions<TEntity> For<TEntity>()
+    {
+        return new EntityCrudOptions<TEntity>(this);
+    }
+
+    internal Assembly? GetAssembly() => _assembly;
+    internal Dictionary<Type, Action<ICrudOptions>> GetOptions() => _options;
+    
+    public class EntityCrudOptions<TEntity>
+    {
+        private readonly AllCrudOptions _allCrudOptions;
+
+        public EntityCrudOptions(AllCrudOptions allCrudOptions)
+        {
+            _allCrudOptions = allCrudOptions;
+        }
+
+        public AllCrudOptions UseOptions(Action<ICrudOptions> options)
+        {
+            _allCrudOptions._options.Add(typeof(TEntity), options);
+            return _allCrudOptions;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/eQuantic.Core.Api.Crud/eQuantic.Core.Api.Crud.csproj b/src/eQuantic.Core.Api.Crud/eQuantic.Core.Api.Crud.csproj
index 1a95bcd..8d3f865 100644
--- a/src/eQuantic.Core.Api.Crud/eQuantic.Core.Api.Crud.csproj
+++ b/src/eQuantic.Core.Api.Crud/eQuantic.Core.Api.Crud.csproj
@@ -6,9 +6,9 @@
         <Authors>eQuantic Systems</Authors>
         <RootNamespace>eQuantic.Core.Api.Crud</RootNamespace>
         <AssemblyTitle>eQuantic.Core.Api.Crud</AssemblyTitle>
-        <AssemblyVersion>1.0.8.0</AssemblyVersion>
-        <FileVersion>1.0.8.0</FileVersion>
-        <Version>1.0.8.0</Version>
+        <AssemblyVersion>1.0.9.0</AssemblyVersion>
+        <FileVersion>1.0.9.0</FileVersion>
+        <Version>1.0.9.0</Version>
         <TargetFramework>net7.0</TargetFramework>
         
         <PackageId>eQuantic.Core.Api.Crud</PackageId>
@@ -45,7 +45,7 @@
         <None Include="Icon_dialog.png" Pack="true" PackagePath="Icon_dialog.png" />
         <None Include="Icon_list.png" Pack="true" PackagePath="Icon_list.png" />
         <None Include="../../LICENSE" Pack="true" PackagePath="" />
-        <None Include="../../README.md" Pack="true" PackagePath=""/>
+        <None Include="../../README.md" Pack="true" PackagePath="" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/eQuantic.Core.Api.Sample/Program.cs b/src/eQuantic.Core.Api.Sample/Program.cs
index ce53f7f..78f7274 100644
--- a/src/eQuantic.Core.Api.Sample/Program.cs
+++ b/src/eQuantic.Core.Api.Sample/Program.cs
@@ -45,6 +45,6 @@
 app.UseHttpsRedirection();
 app.UseRouting();
 app.MapControllers();
-app.MapAllCrud(assembly);
+app.MapAllCrud(opt => opt.FromAssembly(assembly));
 
 app.Run();
\ No newline at end of file
diff --git a/src/eQuantic.Core.Api.Sample/Services/ChildExampleService.cs b/src/eQuantic.Core.Api.Sample/Services/ChildExampleService.cs
index 13d4163..3dc5260 100644
--- a/src/eQuantic.Core.Api.Sample/Services/ChildExampleService.cs
+++ b/src/eQuantic.Core.Api.Sample/Services/ChildExampleService.cs
@@ -6,7 +6,7 @@
 
 namespace eQuantic.Core.Api.Sample.Services;
 
-public interface IChildExampleService : ICrudServiceBase<ChildExample, ChildExampleRequest> {}
+public interface IChildExampleService : ICrudService<ChildExample, ChildExampleRequest> {}
 
 [MapCrudEndpoints(ReferenceType = typeof(Example))]
 public class ChildExampleService : CrudServiceBase<ChildExample, ChildExampleRequest, ChildExampleData, UserData>, IChildExampleService
diff --git a/src/eQuantic.Core.Api.Sample/Services/ExampleService.cs b/src/eQuantic.Core.Api.Sample/Services/ExampleService.cs
index 64c1658..9b84e6a 100644
--- a/src/eQuantic.Core.Api.Sample/Services/ExampleService.cs
+++ b/src/eQuantic.Core.Api.Sample/Services/ExampleService.cs
@@ -6,7 +6,7 @@
 
 namespace eQuantic.Core.Api.Sample.Services;
 
-public interface IExampleService : ICrudServiceBase<Example, ExampleRequest> {}
+public interface IExampleService : ICrudService<Example, ExampleRequest> {}
 
 [MapCrudEndpoints]
 public class ExampleService : CrudServiceBase<Example, ExampleRequest, ExampleData, UserData>, IExampleService
diff --git a/src/eQuantic.Core.Api.Sample/eQuantic.Core.Api.Sample.csproj b/src/eQuantic.Core.Api.Sample/eQuantic.Core.Api.Sample.csproj
index bf228fa..a5abb5c 100644
--- a/src/eQuantic.Core.Api.Sample/eQuantic.Core.Api.Sample.csproj
+++ b/src/eQuantic.Core.Api.Sample/eQuantic.Core.Api.Sample.csproj
@@ -12,7 +12,7 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="eQuantic.Core.Data.EntityFramework" Version="4.0.0" />
+        <PackageReference Include="eQuantic.Core.Data.EntityFramework" Version="4.0.1" />
         <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="7.0.9" />
         <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.9">
             <PrivateAssets>all</PrivateAssets>
diff --git a/src/eQuantic.Core.Api/eQuantic.Core.Api.csproj b/src/eQuantic.Core.Api/eQuantic.Core.Api.csproj
index 66a6d52..f3f1777 100644
--- a/src/eQuantic.Core.Api/eQuantic.Core.Api.csproj
+++ b/src/eQuantic.Core.Api/eQuantic.Core.Api.csproj
@@ -6,9 +6,9 @@
         <Authors>eQuantic Systems</Authors>
         <RootNamespace>eQuantic.Core.Api</RootNamespace>
         <AssemblyTitle>eQuantic.Core.Api</AssemblyTitle>
-        <AssemblyVersion>1.0.8.0</AssemblyVersion>
-        <FileVersion>1.0.8.0</FileVersion>
-        <Version>1.0.8.0</Version>
+        <AssemblyVersion>1.0.9.0</AssemblyVersion>
+        <FileVersion>1.0.9.0</FileVersion>
+        <Version>1.0.9.0</Version>
         <TargetFramework>net7.0</TargetFramework>
 
         <PackageId>eQuantic.Core.Api</PackageId>
diff --git a/src/eQuantic.Core.Application.Crud/Services/CrudServiceBase.cs b/src/eQuantic.Core.Application.Crud/Services/CrudServiceBase.cs
index acf652e..1e28aee 100644
--- a/src/eQuantic.Core.Application.Crud/Services/CrudServiceBase.cs
+++ b/src/eQuantic.Core.Application.Crud/Services/CrudServiceBase.cs
@@ -1,91 +1,19 @@
 using eQuantic.Core.Application.Crud.Entities.Requests;
 using eQuantic.Core.Application.Entities.Data;
 using eQuantic.Core.Application.Exceptions;
-using eQuantic.Core.Collections;
 using eQuantic.Core.Data.Repository;
-using eQuantic.Core.Data.Repository.Sql;
 using eQuantic.Linq.Filter;
-using eQuantic.Linq.Filter.Extensions;
-using eQuantic.Linq.Sorter.Extensions;
 using eQuantic.Linq.Specification;
 using eQuantic.Mapper;
 
 namespace eQuantic.Core.Application.Crud.Services;
 
-public abstract class CrudServiceBase<TEntity, TRequest, TDataEntity, TUser> : ICrudServiceBase<TEntity, TRequest>
+public abstract class CrudServiceBase<TEntity, TRequest, TDataEntity, TUser> : ReaderServiceBase<TEntity, TDataEntity>, ICrudService<TEntity, TRequest>
     where TEntity : class, new()
     where TDataEntity : EntityDataBase, new()
 {
-    protected IDefaultUnitOfWork UnitOfWork { get; }
-    protected IMapperFactory MapperFactory { get; }
-    protected IAsyncQueryableRepository<ISqlUnitOfWork, TDataEntity, int> Repository { get; }
-
-    protected CrudServiceBase(IDefaultUnitOfWork unitOfWork, IMapperFactory mapperFactory)
-    {
-        UnitOfWork = unitOfWork;
-        MapperFactory = mapperFactory;
-        Repository = unitOfWork.GetAsyncQueryableRepository<TDataEntity, int>();
-    }
-
-    public async Task<TEntity?> GetByIdAsync(ItemRequest request, CancellationToken cancellationToken = default)
-    {
-        var item = await Repository.GetAsync(request.Id, opt =>
-        {
-            opt.WithProperties(OnGetProperties());
-        }, cancellationToken);
-
-        if (item == null)
-        {
-            throw new EntityNotFoundException<int>(request.Id);
-        }
-        
-        if (request is IReferencedRequest<int> referencedRequest && item is IWithReferenceId<TDataEntity, int> referencedItem)
-        {
-            if (referencedItem.GetReferenceId() != referencedRequest.ReferenceId)
-            {
-                throw new InvalidReferenceException<int>(referencedRequest.ReferenceId);
-            }
-        }
-        
-        var result = OnMapEntity(item);
-
-        await OnBeforeGetByIdAsync(item, result, cancellationToken);
-        return result;
-    }
-
-    public async Task<IPagedEnumerable<TEntity>?> GetPagedListAsync(PagedListRequest<TEntity> request,
-        CancellationToken cancellationToken = default)
+    protected CrudServiceBase(IDefaultUnitOfWork unitOfWork, IMapperFactory mapperFactory) : base(unitOfWork, mapperFactory)
     {
-        var filtering = request.Filtering
-            .Cast<TDataEntity>(opt => opt.ExcludeUnmapped()).ToList();
-
-        SetReferenceFiltering(request, filtering);
-
-        var sorting = request.Sorting
-            .Cast<TDataEntity>(opt => opt.ExcludeUnmapped());
-
-        Specification<TDataEntity> specification = filtering.Any()
-            ? new EntityFilterSpecification<TDataEntity>(filtering.ToArray())
-            : new TrueSpecification<TDataEntity>();
-
-        var count = await Repository.CountAsync(specification, cancellationToken);
-        var pagedList = (await Repository.GetPagedAsync(specification, request.PageIndex, request.PageSize,
-                config =>
-                {
-                    config
-                        .WithSorting(sorting)
-                        .WithProperties(OnGetProperties());
-                }, cancellationToken))
-            .ToList();
-        
-        var list = pagedList
-            .Select(dataEntity => OnMapEntity(dataEntity)!)
-            .Where(item => item != null)
-            .ToList();
-
-        await OnBeforeGetPagedListAsync(pagedList, list, cancellationToken);
-
-        return new PagedList<TEntity>(list, count) { PageIndex = request.PageIndex, PageSize = request.PageSize };
     }
     
     public async Task<int> CreateAsync(CreateRequest<TRequest> request, CancellationToken cancellationToken = default)
@@ -109,7 +37,7 @@ public async Task<int> CreateAsync(CreateRequest<TRequest> request, Cancellation
         }
 
         await Repository.AddAsync(item);
-        await Repository.UnitOfWork.CommitAsync();
+        await Repository.UnitOfWork.CommitAsync(cancellationToken);
         await OnBeforeCreateAsync(item, cancellationToken);
         
         return item.Id;
@@ -133,7 +61,7 @@ public async Task<bool> UpdateAsync(UpdateRequest<TRequest> request, Cancellatio
         }
 
         await Repository.ModifyAsync(item);
-        await Repository.UnitOfWork.CommitAsync();
+        await Repository.UnitOfWork.CommitAsync(cancellationToken);
         await OnBeforeUpdateAsync(item, cancellationToken);
         
         return true;
@@ -157,40 +85,18 @@ public async Task<bool> DeleteAsync(ItemRequest request, CancellationToken cance
             await Repository.RemoveAsync(item);
         }
 
-        await Repository.UnitOfWork.CommitAsync();
+        await Repository.UnitOfWork.CommitAsync(cancellationToken);
         await OnBeforeDeleteAsync(item, cancellationToken);
         
         return true;
     }
 
-    protected virtual string[] OnGetProperties()
-    {
-        return Array.Empty<string>();
-    }
-    
-    protected virtual TEntity? OnMapEntity(TDataEntity dataEntity)
-    {
-        var mapper = MapperFactory.GetMapper<TDataEntity, TEntity>();
-        return mapper?.Map(dataEntity);
-    }
-
     protected virtual TDataEntity? OnMapRequest(TRequest? request, TDataEntity? dataEntity = null)
     {
         var mapper = MapperFactory.GetMapper<TRequest, TDataEntity>();
         return mapper?.Map(request, dataEntity);
     }
-    
-    protected virtual Task OnBeforeGetByIdAsync(TDataEntity? dataEntity, TEntity? entity, CancellationToken cancellationToken = default)
-    {
-        return Task.CompletedTask;
-    }
 
-    protected virtual Task OnBeforeGetPagedListAsync(IEnumerable<TDataEntity> dataEntityList,
-        IEnumerable<TEntity> entityList, CancellationToken cancellationToken = default)
-    {
-        return Task.CompletedTask;
-    }
-    
     protected virtual Task OnAfterCreateAsync(TDataEntity? dataEntity, CancellationToken cancellationToken = default)
     {
         return Task.CompletedTask;
@@ -248,18 +154,4 @@ protected virtual Task OnBeforeDeleteAsync(TDataEntity? dataEntity, Cancellation
 
         return filterByRef;
     }
-
-    private static void SetReferenceFiltering<TAnyRequest>(TAnyRequest request,
-        ICollection<IFiltering<TDataEntity>> filtering)
-    {
-        var filterByRef = GetReferenceFiltering(request);
-
-        if (filterByRef == null)
-            return;
-
-        if (filtering.All(f => f.ColumnName != filterByRef.ColumnName))
-        {
-            filtering.Add(filterByRef);
-        }
-    }
 }
\ No newline at end of file
diff --git a/src/eQuantic.Core.Application.Crud/Services/ICrudServiceBase.cs b/src/eQuantic.Core.Application.Crud/Services/ICrudService.cs
similarity index 72%
rename from src/eQuantic.Core.Application.Crud/Services/ICrudServiceBase.cs
rename to src/eQuantic.Core.Application.Crud/Services/ICrudService.cs
index 881d780..6eafccf 100644
--- a/src/eQuantic.Core.Application.Crud/Services/ICrudServiceBase.cs
+++ b/src/eQuantic.Core.Application.Crud/Services/ICrudService.cs
@@ -4,15 +4,25 @@
 
 namespace eQuantic.Core.Application.Crud.Services;
 
-public interface ICrudServiceBase : IApplicationService
+public interface IReaderService : IApplicationService
 {
+    
 }
 
-public interface ICrudServiceBase<TEntity, TRequest> : ICrudServiceBase
+public interface IReaderService<TEntity> : IReaderService
     where TEntity : class, new()
 {
     Task<TEntity?> GetByIdAsync(ItemRequest request, CancellationToken cancellationToken = default);
     Task<IPagedEnumerable<TEntity>?> GetPagedListAsync(PagedListRequest<TEntity> request, CancellationToken cancellationToken = default);
+}
+
+public interface ICrudService : IReaderService
+{
+}
+
+public interface ICrudService<TEntity, TRequest> : ICrudService, IReaderService<TEntity>
+    where TEntity : class, new()
+{
     Task<int> CreateAsync(CreateRequest<TRequest> request, CancellationToken cancellationToken = default);
     Task<bool> UpdateAsync(UpdateRequest<TRequest> request, CancellationToken cancellationToken = default);
     Task<bool> DeleteAsync(ItemRequest request, CancellationToken cancellationToken = default);
diff --git a/src/eQuantic.Core.Application.Crud/Services/ReaderServiceBase.cs b/src/eQuantic.Core.Application.Crud/Services/ReaderServiceBase.cs
new file mode 100644
index 0000000..a88ba9b
--- /dev/null
+++ b/src/eQuantic.Core.Application.Crud/Services/ReaderServiceBase.cs
@@ -0,0 +1,141 @@
+using eQuantic.Core.Application.Crud.Entities.Requests;
+using eQuantic.Core.Application.Entities.Data;
+using eQuantic.Core.Application.Exceptions;
+using eQuantic.Core.Collections;
+using eQuantic.Core.Data.Repository;
+using eQuantic.Core.Data.Repository.Sql;
+using eQuantic.Linq.Filter;
+using eQuantic.Linq.Filter.Extensions;
+using eQuantic.Linq.Sorter.Extensions;
+using eQuantic.Linq.Specification;
+using eQuantic.Mapper;
+
+namespace eQuantic.Core.Application.Crud.Services;
+
+public abstract class ReaderServiceBase<TEntity, TDataEntity> : IReaderService<TEntity>
+    where TEntity : class, new()
+    where TDataEntity : EntityDataBase, new()
+{
+    protected IDefaultUnitOfWork UnitOfWork { get; }
+    protected IMapperFactory MapperFactory { get; }
+    protected IAsyncQueryableRepository<ISqlUnitOfWork, TDataEntity, int> Repository { get; }
+
+    protected ReaderServiceBase(IDefaultUnitOfWork unitOfWork, IMapperFactory mapperFactory)
+    {
+        UnitOfWork = unitOfWork;
+        MapperFactory = mapperFactory;
+        Repository = unitOfWork.GetAsyncQueryableRepository<TDataEntity, int>();
+    }
+
+    public async Task<TEntity?> GetByIdAsync(ItemRequest request, CancellationToken cancellationToken = default)
+    {
+        var item = await Repository.GetAsync(request.Id, opt =>
+        {
+            opt.WithProperties(OnGetProperties());
+        }, cancellationToken);
+
+        if (item == null)
+        {
+            throw new EntityNotFoundException<int>(request.Id);
+        }
+        
+        if (request is IReferencedRequest<int> referencedRequest && item is IWithReferenceId<TDataEntity, int> referencedItem)
+        {
+            if (referencedItem.GetReferenceId() != referencedRequest.ReferenceId)
+            {
+                throw new InvalidReferenceException<int>(referencedRequest.ReferenceId);
+            }
+        }
+        
+        var result = OnMapEntity(item);
+
+        await OnBeforeGetByIdAsync(item, result, cancellationToken);
+        return result;
+    }
+
+    public async Task<IPagedEnumerable<TEntity>?> GetPagedListAsync(PagedListRequest<TEntity> request,
+        CancellationToken cancellationToken = default)
+    {
+        var filtering = request.Filtering
+            .Cast<TDataEntity>(opt => opt.ExcludeUnmapped()).ToList();
+
+        SetReferenceFiltering(request, filtering);
+
+        var sorting = request.Sorting
+            .Cast<TDataEntity>(opt => opt.ExcludeUnmapped());
+
+        Specification<TDataEntity> specification = filtering.Any()
+            ? new EntityFilterSpecification<TDataEntity>(filtering.ToArray())
+            : new TrueSpecification<TDataEntity>();
+
+        var count = await Repository.CountAsync(specification, cancellationToken);
+        var pagedList = (await Repository.GetPagedAsync(specification, request.PageIndex, request.PageSize,
+                config =>
+                {
+                    config
+                        .WithSorting(sorting)
+                        .WithProperties(OnGetProperties());
+                }, cancellationToken))
+            .ToList();
+        
+        var list = pagedList
+            .Select(dataEntity => OnMapEntity(dataEntity)!)
+            .Where(item => item != null)
+            .ToList();
+
+        await OnBeforeGetPagedListAsync(pagedList, list, cancellationToken);
+
+        return new PagedList<TEntity>(list, count) { PageIndex = request.PageIndex, PageSize = request.PageSize };
+    }
+    
+    protected virtual string[] OnGetProperties()
+    {
+        return Array.Empty<string>();
+    }
+    
+    protected virtual TEntity? OnMapEntity(TDataEntity dataEntity)
+    {
+        var mapper = MapperFactory.GetMapper<TDataEntity, TEntity>();
+        return mapper?.Map(dataEntity);
+    }
+
+    protected virtual Task OnBeforeGetByIdAsync(TDataEntity? dataEntity, TEntity? entity, CancellationToken cancellationToken = default)
+    {
+        return Task.CompletedTask;
+    }
+
+    protected virtual Task OnBeforeGetPagedListAsync(IEnumerable<TDataEntity> dataEntityList,
+        IEnumerable<TEntity> entityList, CancellationToken cancellationToken = default)
+    {
+        return Task.CompletedTask;
+    }
+
+    private static IFiltering<TDataEntity>? GetReferenceFiltering<TAnyRequest>(TAnyRequest request)
+    {
+        if (request is not IReferencedRequest<int> referencedRequest)
+            return null;
+
+        var dataEntity = new TDataEntity();
+        if (dataEntity is not IWithReferenceId<TDataEntity, int> referencedDataEntity)
+            return null;
+
+        referencedDataEntity.SetReferenceId(referencedRequest.ReferenceId);
+        var filterByRef = referencedDataEntity.GetReferenceFiltering();
+
+        return filterByRef;
+    }
+
+    private static void SetReferenceFiltering<TAnyRequest>(TAnyRequest request,
+        ICollection<IFiltering<TDataEntity>> filtering)
+    {
+        var filterByRef = GetReferenceFiltering(request);
+
+        if (filterByRef == null)
+            return;
+
+        if (filtering.All(f => f.ColumnName != filterByRef.ColumnName))
+        {
+            filtering.Add(filterByRef);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/eQuantic.Core.Application.Crud/eQuantic.Core.Application.Crud.csproj b/src/eQuantic.Core.Application.Crud/eQuantic.Core.Application.Crud.csproj
index 98c052c..b5eda3f 100644
--- a/src/eQuantic.Core.Application.Crud/eQuantic.Core.Application.Crud.csproj
+++ b/src/eQuantic.Core.Application.Crud/eQuantic.Core.Application.Crud.csproj
@@ -6,9 +6,9 @@
         <Authors>eQuantic Systems</Authors>
         <RootNamespace>eQuantic.Core.Application.Crud</RootNamespace>
         <AssemblyTitle>eQuantic.Core.Application.Crud</AssemblyTitle>
-        <AssemblyVersion>1.0.8.0</AssemblyVersion>
-        <FileVersion>1.0.8.0</FileVersion>
-        <Version>1.0.8.0</Version>
+        <AssemblyVersion>1.0.9.0</AssemblyVersion>
+        <FileVersion>1.0.9.0</FileVersion>
+        <Version>1.0.9.0</Version>
         <TargetFrameworks>netstandard2.1;net7.0</TargetFrameworks>
         
         <PackageId>eQuantic.Core.Application.Crud</PackageId>
@@ -37,7 +37,7 @@
 
     <ItemGroup>
         <PackageReference Include="eQuantic.Linq" Version="1.1.3" />
-        <PackageReference Include="eQuantic.Mapper" Version="1.1.3" />
+        <PackageReference Include="eQuantic.Mapper" Version="1.1.4" />
         <PackageReference Include="Humanizer" Version="2.14.1" />
         <PackageReference Include="Microsoft.AspNetCore.Mvc.Core" Version="2.2.5" />
     </ItemGroup>
@@ -52,6 +52,6 @@
         <None Include="Icon_dialog.png" Pack="true" PackagePath="Icon_dialog.png" />
         <None Include="Icon_list.png" Pack="true" PackagePath="Icon_list.png" />
         <None Include="../../LICENSE" Pack="true" PackagePath="" />
-        <None Include="../../README.md" Pack="true" PackagePath=""/>
+        <None Include="../../README.md" Pack="true" PackagePath="" />
     </ItemGroup>
 </Project>
diff --git a/src/eQuantic.Core.Application/Entities/Results/ErrorResult.cs b/src/eQuantic.Core.Application/Entities/Results/ErrorResult.cs
index 14a8a3c..534fa5d 100644
--- a/src/eQuantic.Core.Application/Entities/Results/ErrorResult.cs
+++ b/src/eQuantic.Core.Application/Entities/Results/ErrorResult.cs
@@ -2,7 +2,7 @@ namespace eQuantic.Core.Application.Entities.Results;
 
 public class ErrorResult
 {
-    public string Message { get; set; }
+    public string? Message { get; set; }
     public string? Details { get; set; }
     
     public ErrorResult()
diff --git a/src/eQuantic.Core.Application/eQuantic.Core.Application.csproj b/src/eQuantic.Core.Application/eQuantic.Core.Application.csproj
index 6d5e13a..0943bf5 100644
--- a/src/eQuantic.Core.Application/eQuantic.Core.Application.csproj
+++ b/src/eQuantic.Core.Application/eQuantic.Core.Application.csproj
@@ -6,9 +6,9 @@
         <Authors>eQuantic Systems</Authors>
         <RootNamespace>eQuantic.Core.Application</RootNamespace>
         <AssemblyTitle>eQuantic.Core.Application</AssemblyTitle>
-        <AssemblyVersion>1.0.8.0</AssemblyVersion>
-        <FileVersion>1.0.8.0</FileVersion>
-        <Version>1.0.8.0</Version>
+        <AssemblyVersion>1.0.9.0</AssemblyVersion>
+        <FileVersion>1.0.9.0</FileVersion>
+        <Version>1.0.9.0</Version>
         <TargetFrameworks>netstandard2.1;net7.0</TargetFrameworks>
         
         <PackageId>eQuantic.Core.Application</PackageId>
@@ -36,7 +36,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="eQuantic.Core.Data" Version="4.0.0" />
+        <PackageReference Include="eQuantic.Core.Data" Version="4.0.1" />
     </ItemGroup>
 
     <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.1' ">