bump to 2.5.2

- Introduced Action<TEntity>-based UpdateAsync method for more flexible updates
- Updated TDto-based UpdateAsync to delegate to the new method
- Reduced code duplication and Mapper dependency
- Preserved existing Create, Read, and Delete functionality

DigitalData.Core.API/BasicCRUDControllerBase.cs

@@ -1,15 +1,15 @@
-using DigitalData.Core.Abstractions;
-using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.Abstraction.Application;
 using Microsoft.AspNetCore.Mvc;
 
 namespace DigitalData.Core.API
 {
     [ApiController]
     [Route("api/[controller]")]
+    [Obsolete("Use MediatR")]
     public class BasicCRUDControllerBase<TCRUDService, TDto, TEntity, TId> : CRUDControllerBase<TCRUDService, TDto, TDto, TDto, TEntity, TId>
         where TCRUDService : ICRUDService<TDto, TDto, TEntity, TId>
-        where TDto : class, IUnique<TId>
-        where TEntity : class, IUnique<TId>
+        where TDto : class
+        where TEntity : class
     {
         public BasicCRUDControllerBase(ILogger logger, TCRUDService service) : base(logger, service)
         {

DigitalData.Core.API/CRUDControllerBase.cs

@@ -1,7 +1,6 @@
-using DigitalData.Core.Abstractions;
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
 using Microsoft.AspNetCore.Mvc;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
 
 namespace DigitalData.Core.API
 {
@@ -15,12 +14,13 @@ namespace DigitalData.Core.API
     /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
     [ApiController]
     [Route("api/[controller]")]
+    [Obsolete("Use MediatR")]
     public class CRUDControllerBase<TCRUDService, TCreateDto, TReadDto, TUpdateDto, TEntity, TId> : ControllerBase
         where TCRUDService : ICRUDService<TCreateDto, TReadDto, TEntity, TId>
         where TCreateDto : class
         where TReadDto : class
-        where TUpdateDto : class, IUnique<TId>
-        where TEntity : class, IUnique<TId>
+        where TUpdateDto : class
+        where TEntity : class
     {
         protected readonly ILogger _logger;
         protected readonly TCRUDService _service;
@@ -46,10 +46,10 @@ namespace DigitalData.Core.API
         [HttpPost]
         public virtual async Task<IActionResult> Create(TCreateDto createDto)
         {
-            return await _service.CreateAsync(createDto).ThenAsync<TId, IActionResult>(
-                Success: id =>
+            return await _service.CreateAsync(createDto).ThenAsync<TReadDto, IActionResult>(
+                Success: dto =>
                 {
-                    var createdResource = new { Id = id };
+                    var createdResource = new { Id = dto.GetId() };
                     var actionName = nameof(GetById);
                     var routeValues = new { id = createdResource.Id };
                     return CreatedAtAction(actionName, routeValues, createdResource);

DigitalData.Core.API/CRUDControllerBaseWithErrorHandling.cs

@@ -1,7 +1,6 @@
-using DigitalData.Core.Abstractions;
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
 using Microsoft.AspNetCore.Mvc;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
 
 namespace DigitalData.Core.API
 {
@@ -16,12 +15,13 @@ namespace DigitalData.Core.API
     /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
     [ApiController]
     [Route("api/[controller]")]
+    [Obsolete("Use MediatR")]
     public class CRUDControllerBaseWithErrorHandling<TCRUDService, TCreateDto, TReadDto, TUpdateDto, TEntity, TId> : ControllerBase
         where TCRUDService : ICRUDService<TCreateDto, TReadDto, TEntity, TId>
         where TCreateDto : class
         where TReadDto : class
-        where TUpdateDto : class, IUnique<TId>
-        where TEntity : class, IUnique<TId>
+        where TUpdateDto : class
+        where TEntity : class
     {
         protected readonly ILogger _logger;
         protected readonly TCRUDService _service;
@@ -49,10 +49,10 @@ namespace DigitalData.Core.API
         {
             try
             {
-                return await _service.CreateAsync(createDto).ThenAsync<TId, IActionResult>(
-                                Success: id =>
+                return await _service.CreateAsync(createDto).ThenAsync<TReadDto, IActionResult>(
+                                Success: dto =>
                                 {
-                                    var createdResource = new { Id = id };
+                                    var createdResource = new { Id = dto.GetId() };
                                     var actionName = nameof(GetById);
                                     var routeValues = new { id = createdResource.Id };
                                     return CreatedAtAction(actionName, routeValues, createdResource);

DigitalData.Core.API/CSPMiddleware.cs

@@ -1,47 +1,46 @@
-namespace DigitalData.Core.API
+namespace DigitalData.Core.API;
+
+/// <summary>
+/// Middleware to add Content Security Policy (CSP) headers to the HTTP response.
+/// </summary>
+public class CSPMiddleware
 {
+    private readonly RequestDelegate _next;
+    private readonly string _policy;
+
     /// <summary>
-    /// Middleware to add Content Security Policy (CSP) headers to the HTTP response.
+    /// Initializes a new instance of the <see cref="CSPMiddleware"/> class.
     /// </summary>
-    public class CSPMiddleware
+    /// <param name="next">The next middleware in the request pipeline.</param>
+    /// <param name="policy">The CSP policy string with placeholders for nonces.</param>
+    public CSPMiddleware(RequestDelegate next, string policy)
     {
-        private readonly RequestDelegate _next;
-        private readonly string _policy;
+        _next = next;
+        _policy = policy;
+    }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="CSPMiddleware"/> class.
-        /// </summary>
-        /// <param name="next">The next middleware in the request pipeline.</param>
-        /// <param name="policy">The CSP policy string with placeholders for nonces.</param>
-        public CSPMiddleware(RequestDelegate next, string policy)
+    /// <summary>
+    /// Invokes the middleware to add the CSP header to the response.
+    /// </summary>
+    /// <param name="context">The HTTP context.</param>
+    /// <returns>A task that represents the completion of request processing.</returns>
+    public async Task Invoke(HttpContext context)
+    {
+        // Generate a nonce (number used once) for inline scripts and styles
+        var nonce = Convert.ToBase64String(Guid.NewGuid().ToByteArray());
+
+        // Store the nonce in the context items for later use
+        context.Items["csp-nonce"] = nonce;
+
+        // Add the CSP header to the response
+        context.Response.OnStarting(() =>
         {
-            _next = next;
-            _policy = policy;
-        }
+            context.Response.Headers.Append("Content-Security-Policy",
+                string.Format(_policy, nonce));
+            return Task.CompletedTask;
+        });
 
-        /// <summary>
-        /// Invokes the middleware to add the CSP header to the response.
-        /// </summary>
-        /// <param name="context">The HTTP context.</param>
-        /// <returns>A task that represents the completion of request processing.</returns>
-        public async Task Invoke(HttpContext context)
-        {
-            // Generate a nonce (number used once) for inline scripts and styles
-            var nonce = Convert.ToBase64String(Guid.NewGuid().ToByteArray());
-
-            // Store the nonce in the context items for later use
-            context.Items["csp-nonce"] = nonce;
-
-            // Add the CSP header to the response
-            context.Response.OnStarting(() =>
-            {
-                context.Response.Headers.Add("Content-Security-Policy",
-                    string.Format(_policy, nonce));
-                return Task.CompletedTask;
-            });
-
-            // Call the next middleware in the pipeline
-            await _next(context);
-        }
+        // Call the next middleware in the pipeline
+        await _next(context);
     }
 }

DigitalData.Core.API/ControllerExtensions.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.DTO;
+using DigitalData.Core.Abstraction.Application.DTO;
 using Microsoft.AspNetCore.Mvc;
 using System.Text;
 

DigitalData.Core.API/DIExtensions.cs

@@ -1,53 +1,50 @@
-using Microsoft.AspNetCore.Builder;
-using System.Configuration;
+namespace DigitalData.Core.API;
 
-namespace DigitalData.Core.API
+/// <summary>
+/// Provides extension methods for adding middleware to the application's request pipeline.
+/// </summary>
+public static class DIExtensions
 {
     /// <summary>
-    /// Provides extension methods for adding middleware to the application's request pipeline.
+    /// Adds the <see cref="CSPMiddleware"/> to the application's request pipeline to include 
+    /// Content Security Policy (CSP) headers in the HTTP response.
     /// </summary>
-    public static class DIExtensions
-    {
-        /// <summary>
-        /// Adds the <see cref="CSPMiddleware"/> to the application's request pipeline to include 
-        /// Content Security Policy (CSP) headers in the HTTP response.
-        /// </summary>
-        /// <param name="app">The application builder.</param>
-        /// <param name="policy">
-        /// The CSP policy string with placeholders. The first format parameter {0} will be replaced 
-        /// by the nonce value.
-        /// </param>
-        /// <returns>The application builder with the CSP middleware added.</returns>
-        public static IApplicationBuilder UseCSPMiddleware(this IApplicationBuilder app, string policy)
-            => app.UseMiddleware<CSPMiddleware>(policy);
+    /// <param name="app">The application builder.</param>
+    /// <param name="policy">
+    /// The CSP policy string with placeholders. The first format parameter {0} will be replaced 
+    /// by the nonce value.
+    /// </param>
+    /// <returns>The application builder with the CSP middleware added.</returns>
+    public static IApplicationBuilder UseCSPMiddleware(this IApplicationBuilder app, string policy)
+        => app.UseMiddleware<CSPMiddleware>(policy);
 
-        /// <summary>
-        /// Checks if the DiP (Development in Production) mode is enabled for the WebApplicationBuilder.
-        /// </summary>
-        /// <param name="builder">The WebApplicationBuilder instance.</param>
-        /// <returns>True if DiP mode is enabled; otherwise, false.</returns>
-        public static bool IsDiP(this WebApplicationBuilder builder) => builder.Configuration.GetValue<bool>("DiPMode");
+    /// <summary>
+    /// Checks if the DiP (Development in Production) mode is enabled for the WebApplicationBuilder.
+    /// </summary>
+    /// <param name="builder">The WebApplicationBuilder instance.</param>
+    /// <returns>True if DiP mode is enabled; otherwise, false.</returns>
+    public static bool IsDiP(this WebApplicationBuilder builder) => builder.Configuration.GetValue<bool>("DiPMode");
 
-        /// <summary>
-        /// Checks if the DiP (Development in Production) mode is enabled for the WebApplication.
-        /// </summary>
-        /// <param name="app">The WebApplication instance.</param>
-        /// <returns>True if DiP mode is enabled; otherwise, false.</returns>
-        public static bool IsDiP(this WebApplication app) => app.Configuration.GetValue<bool>("DiPMode");
+    /// <summary>
+    /// Checks if the DiP (Development in Production) mode is enabled for the WebApplication.
+    /// </summary>
+    /// <param name="app">The WebApplication instance.</param>
+    /// <returns>True if DiP mode is enabled; otherwise, false.</returns>
+    public static bool IsDiP(this WebApplication app) => app.Configuration.GetValue<bool>("DiPMode");
 
-        /// <summary>
-        /// Checks if the environment is Development or DiP (Development in Production) mode is enabled for the WebApplicationBuilder.
-        /// </summary>
-        /// <param name="builder">The WebApplicationBuilder instance.</param>
-        /// <returns>True if the environment is Development or DiP mode is enabled; otherwise, false.</returns>
-        public static bool IsDevOrDiP(this WebApplicationBuilder builder) => builder.Environment.IsDevelopment() || builder.IsDiP();
+    /// <summary>
+    /// Checks if the environment is Development or DiP (Development in Production) mode is enabled for the WebApplicationBuilder.
+    /// </summary>
+    /// <param name="builder">The WebApplicationBuilder instance.</param>
+    /// <returns>True if the environment is Development or DiP mode is enabled; otherwise, false.</returns>
+    public static bool IsDevOrDiP(this WebApplicationBuilder builder) => builder.Environment.IsDevelopment() || builder.IsDiP();
 
-        /// <summary>
-        /// Checks if the environment is Development or DiP (Development in Production) mode is enabled for the WebApplication.
-        /// </summary>
-        /// <param name="app">The WebApplication instance.</param>
-        /// <returns>True if the environment is Development or DiP mode is enabled; otherwise, false.</returns>
-        public static bool IsDevOrDiP(this WebApplication app) => app.Environment.IsDevelopment() || app.IsDiP();
+    /// <summary>
+    /// Checks if the environment is Development or DiP (Development in Production) mode is enabled for the WebApplication.
+    /// </summary>
+    /// <param name="app">The WebApplication instance.</param>
+    /// <returns>True if the environment is Development or DiP mode is enabled; otherwise, false.</returns>
+    public static bool IsDevOrDiP(this WebApplication app) => app.Environment.IsDevelopment() || app.IsDiP();
 
 		/// <summary>
 		/// Configures the services with options from the specified section of the appsettings.json file.
@@ -65,5 +62,4 @@ namespace DigitalData.Core.API
 			builder.Services.Configure<T>(section);
 			return builder;
 		}
-	}
-}
+	}

DigitalData.Core.API/DigitalData.Core.API.csproj

@@ -8,7 +8,7 @@
     <OutputType>Library</OutputType>
     <Description>This package provides a comprehensive set of API controllers and related utilities for the DigitalData.Core library. It includes generic CRUD controllers, localization extensions, middleware for security policies, and application model conventions.</Description>
     <PackageId>DigitalData.Core.API</PackageId>
-    <Version>2.1.1</Version>
+    <Version>2.2.1</Version>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
     <Product>DigitalData.Core.API</Product>
@@ -16,8 +16,8 @@
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <PackageTags>digital data core api</PackageTags>
     <PackageIcon>core_icon.png</PackageIcon>
-    <AssemblyVersion>2.1.1</AssemblyVersion>
-    <FileVersion>2.1.1</FileVersion>
+    <AssemblyVersion>2.2.1</AssemblyVersion>
+    <FileVersion>2.2.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -32,8 +32,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
-    <ProjectReference Include="..\DigitalData.Core.DTO\DigitalData.Core.DTO.csproj" />
+    <ProjectReference Include="..\DigitalData.Core.Application\DigitalData.Core.Application.csproj" />
+    <ProjectReference Include="..\DigitalData.Core.Exceptions\DigitalData.Core.Exceptions.csproj" />
   </ItemGroup>
 
   <ItemGroup>

DigitalData.Core.API/ReadControllerBase.cs

@@ -1,6 +1,6 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
 using Microsoft.AspNetCore.Mvc;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
 
 namespace DigitalData.Core.API
 {
@@ -12,6 +12,7 @@ namespace DigitalData.Core.API
     /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
     [ApiController]
     [Route("api/[controller]")]
+    [Obsolete("Use MediatR")]
     public class ReadControllerBase<TReadService, TReadDto, TEntity, TId> : ControllerBase
         where TReadService : IReadService<TReadDto, TEntity, TId>
         where TReadDto : class

DigitalData.Core.API/ReadControllerBaseWithErrorHandling.cs

@@ -1,5 +1,5 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
 using Microsoft.AspNetCore.Mvc;
 
 namespace DigitalData.Core.API
@@ -13,6 +13,7 @@ namespace DigitalData.Core.API
     /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
     [ApiController]
     [Route("api/[controller]")]
+    [Obsolete("Use MediatR")]
     public class ReadControllerBaseWithErrorHandling<TReadService, TReadDto, TEntity, TId> : ControllerBase
         where TReadService : IReadService<TReadDto, TEntity, TId>
         where TReadDto : class

DigitalData.Core.Abstraction.Application/DTO/BaseDto.cs

@@ -0,0 +1,19 @@
+#if NET
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents a base Data Transfer Object (DTO) with an identifier.
+/// </summary>
+/// <typeparam name="TId">The type of the identifier.</typeparam>
+/// <param name="Id">The identifier of the DTO.</param>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public record BaseDTO<TId>(TId Id) where TId : notnull
+{
+	/// <summary>
+	/// Returns the hash code for this instance, based on the identifier.
+	/// This override ensures that the hash code is derived consistently from the identifier.
+	/// </summary>
+	/// <returns>A hash code for the current object, derived from the identifier.</returns>
+	public override int GetHashCode() => Id.GetHashCode();
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/CookieConsentSettings.cs

@@ -0,0 +1,75 @@
+#if NET
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents settings related to user cookie consent dialogs. Designed to be serialized into JSON format for use with JavaScript frontend libraries,
+/// such as the bootstrap-cookie-consent-settings at the GitHub repository: https://github.com/shaack/bootstrap-cookie-consent-settings
+/// </summary>
+public class CookieConsentSettings
+{
+    /// <summary>
+    /// URL to the privacy policy page.
+    /// </summary>
+    public string? PrivacyPolicyUrl { get; set; }
+
+    /// <summary>
+    /// URL to the legal notice page.
+    /// </summary>
+    public string? LegalNoticeUrl { get; set; }
+
+    /// <summary>
+    /// URL to the content of the dialog box.
+    /// </summary>
+    public string? ContentURL { get; set; }
+
+    /// <summary>
+    /// CSS class for the 'Agree' button.
+    /// </summary>
+    public string? ButtonAgreeClass { get; set; }
+
+    /// <summary>
+    /// CSS class for the 'Don't Agree' button.
+    /// </summary>
+    public string? ButtonDontAgreeClass { get; set; }
+
+    /// <summary>
+    /// CSS class for the 'Save' button.
+    /// </summary>
+    public string? ButtonSaveClass { get; set; }
+
+    /// <summary>
+    /// Language in which the modal is displayed.
+    /// </summary>
+    public string? Lang { get; set; }
+
+    /// <summary>
+    /// Default language for the modal if the user's browser language is not supported.
+    /// </summary>
+    public string? DefaultLang { get; set; }
+
+    /// <summary>
+    /// Name of the cookie used to store the consent status.
+    /// </summary>
+    public string? CookieName { get; set; }
+
+    /// <summary>
+    /// Number of days the cookie will be stored.
+    /// </summary>
+    public int CookieStorageDays { get; set; }
+
+    /// <summary>
+    /// Identifier for the modal dialog element.
+    /// </summary>
+    public string? ModalId { get; set; }
+
+    /// <summary>
+    /// Indicates whether to also store the settings in the browser's localStorage.
+    /// </summary>
+    public bool AlsoUseLocalStorage { get; set; }
+
+    /// <summary>
+    /// List of categories for cookie consent.
+    /// </summary>
+    public List<string>? Categories { get; set; }
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/DIExtensions.cs

@@ -0,0 +1,36 @@
+#if NET
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using System.Configuration;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Provides extension methods for dependency injection.
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public static class DIExtensions
+{
+    /// <summary>
+    /// Adds the <see cref="CookieConsentSettings"/> to the service collection.
+    /// </summary>
+    /// <param name="services">The service collection to add the settings to.</param>
+    /// <returns>The updated service collection.</returns>
+    /// <exception cref="ConfigurationErrorsException">
+    /// Thrown if the 'CookieConsentSettings' section is missing or improperly configured in appsettings.json.
+    /// </exception>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static IServiceCollection AddCookieConsentSettings(this IServiceCollection services)
+    {
+        services.AddSingleton(sp =>
+        {
+            var configuration = sp.GetRequiredService<IConfiguration>();
+            var settings = configuration.GetSection("CookieConsentSettings").Get<CookieConsentSettings>();
+            return settings is null
+                ? throw new ConfigurationErrorsException("The 'CookieConsentSettings' section is missing or improperly configured in appsettings.json.")
+                : settings;
+        });
+        return services;
+    }
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/DTOExtensions.cs

@@ -0,0 +1,395 @@
+#if NET
+using Microsoft.Extensions.Logging;
+using System.Text;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Provides extension methods for data transfer objects (DTOs).
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public static class DTOExtensions
+{
+    /// <summary>
+    /// Adds a single message to the result, if not null.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the message to.</param>
+    /// <param name="message">The message to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Message<T>(this T result, string? message) where T : Result
+    {
+        if (message is not null)
+            result.Messages.Add(message);
+        return result;
+    }
+
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    internal static IEnumerable<T> FilterNull<T>(this IEnumerable<T?> list)
+    {
+        foreach (var item in list)
+            if (item is not null)
+                yield return item;
+    }
+
+    /// <summary>
+    /// Adds multiple messages to the result, after removing nulls.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the messages to.</param>
+    /// <param name="messages">The messages to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Message<T>(this T result, params string?[] messages) where T : Result
+    {
+        result.Messages.AddRange(messages.FilterNull());
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a collection of messages to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the messages to.</param>
+    /// <param name="messages">The collection of messages to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Message<T>(this T result, IEnumerable<string?> messages) where T : Result
+    {
+        result.Messages.AddRange(messages.FilterNull());
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a notice to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notice to.</param>
+    /// <param name="notice">The notice to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, Notice notice) where T : Result
+    {
+        result.Notices.Add(notice);
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a collection of notices to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notices to.</param>
+    /// <param name="notices">The collection of notices to add.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, IEnumerable<Notice> notices) where T : Result
+    {
+        result.Notices.AddRange(notices);
+        return result;
+    }
+
+    /// <summary>
+    /// Adds notices with a specific log level and flags to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notices to.</param>
+    /// <param name="level">The log level of the notices.</param>
+    /// <param name="flags">The flags associated with the notices.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, LogLevel level, params Enum[] flags) where T : Result
+    {
+        var notices = flags.Select(flag => new Notice()
+        {
+            Flag = flag,
+            Level = level
+        });
+        result.Notices.AddRange(notices);
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a notice with a specific log level, flag, and messages to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notice to.</param>
+    /// <param name="level">The log level of the notice.</param>
+    /// <param name="flag">The flag associated with the notice.</param>
+    /// <param name="messages">The messages to add to the notice.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, LogLevel level, Enum flag, params string?[] messages) where T : Result
+    {
+        result.Notices.Add(new Notice()
+        {
+            Flag = flag,
+            Level = level,
+            Messages = messages.FilterNull().ToList()
+        });
+        return result;
+    }
+
+    /// <summary>
+    /// Adds a notice with a specific log level and messages to the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the result.</typeparam>
+    /// <param name="result">The result to add the notice to.</param>
+    /// <param name="level">The log level of the notice.</param>
+    /// <param name="messages">The messages to add to the notice.</param>
+    /// <returns>The updated result.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static T Notice<T>(this T result, LogLevel level, params string[] messages) where T : Result
+    {
+        result.Notices.Add(new Notice()
+        {
+            Flag = null,
+            Level = level,
+            Messages = messages.FilterNull().ToList()
+        });
+        return result;
+    }
+
+    /// <summary>
+    /// Checks if any notice has the specified flag.
+    /// </summary>
+    /// <param name="notices">The collection of notices to check.</param>
+    /// <param name="flag">The flag to check for.</param>
+    /// <returns>True if any notice has the specified flag; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static bool HasFlag(this IEnumerable<Notice> notices, Enum flag) => notices.Any(n => n.Flag?.ToString() == flag.ToString());
+
+    /// <summary>
+    /// Checks if any notice has any of the specified flags.
+    /// </summary>
+    /// <param name="notices">The collection of notices to check.</param>
+    /// <param name="flags">The flags to check for.</param>
+    /// <returns>True if any notice has any of the specified flags; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static bool HasAnyFlag(this IEnumerable<Notice> notices, params Enum[] flags) => flags.Any(f => notices.HasFlag(f));
+
+    /// <summary>
+    /// Executes a function based on the success or failure of the task result, 
+    /// without using result data.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a result to evaluate.</param>
+    /// <param name="Success">The function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static I? Then<I>(this Result result, Func<I> Success)
+    {
+        return result.IsSuccess ? Success() : default;
+    }
+
+    /// <summary>
+    /// Executes a function based on the success or failure of the task result,
+    /// using the data in the result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a data result to evaluate.</param>
+    /// <param name="Success">The function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I?> ThenAsync<I>(this Result result, Func<Task<I>> SuccessAsync)
+    {
+        return result.IsSuccess ? await SuccessAsync() : default;
+    }
+
+    /// <summary>
+    /// Executes a function based on the success or failure of the result.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="result">The result to evaluate.</param>
+    /// <param name="Success">The function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static I Then<I>(this Result result, Func<I> Success, Func<List<string>, List<Notice>, I> Fail)
+    {
+        return result.IsSuccess ? Success() : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of the result.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="result">The result to evaluate.</param>
+    /// <param name="SuccessAsync">The asynchronous function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<I>(this Result result, Func<Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
+    {
+        return result.IsSuccess ? await SuccessAsync() : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Executes a function based on the success or failure of the data result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="result">The data result to evaluate.</param>
+    /// <param name="Success">The function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static I Then<T, I>(this DataResult<T> result, Func<T, I> Success, Func<List<string>, List<Notice>, I> Fail)
+    {
+        return result.IsSuccess ? Success(result.Data) : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of the data result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="result">The data result to evaluate.</param>
+    /// <param name="SuccessAsync">The asynchronous function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<T, I>(this DataResult<T> result, Func<T, Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
+    {
+        return result.IsSuccess ? await SuccessAsync(result.Data) : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of a task returning a result.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a result to evaluate.</param>
+    /// <param name="Success">The function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<I>(this Task<Result> tResult, Func<I> Success, Func<List<string>, List<Notice>, I> Fail)
+    {
+        Result result = await tResult;
+        return result.IsSuccess ? Success() : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of a task returning a result.
+    /// </summary>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a result to evaluate.</param>
+    /// <param name="SuccessAsync">The asynchronous function to execute if the result is successful.</param>
+    /// <param name="Fail">The function to execute if the result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<I>(this Task<Result> tResult, Func<Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
+    {
+        Result result = await tResult;
+        return result.IsSuccess ? await SuccessAsync() : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of a task returning a data result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a data result to evaluate.</param>
+    /// <param name="Success">The function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<T, I>(this Task<DataResult<T>> tResult, Func<T, I> Success, Func<List<string>, List<Notice>, I> Fail)
+    {
+        DataResult<T> result = await tResult;
+        return result.IsSuccess ? Success(result.Data) : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Asynchronously executes a function based on the success or failure of a task returning a data result.
+    /// </summary>
+    /// <typeparam name="T">The type of the data in the result.</typeparam>
+    /// <typeparam name="I">The type of the return value.</typeparam>
+    /// <param name="tResult">The task returning a data result to evaluate.</param>
+    /// <param name="SuccessAsync">The asynchronous function to execute if the data result is successful.</param>
+    /// <param name="Fail">The function to execute if the data result is a failure.</param>
+    /// <returns>The result of the executed function.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static async Task<I> ThenAsync<T, I>(this Task<DataResult<T>> tResult, Func<T, Task<I>> SuccessAsync, Func<List<string>, List<Notice>, I> Fail)
+    {
+        DataResult<T> result = await tResult;
+        return result.IsSuccess ? await SuccessAsync(result.Data) : Fail(result.Messages, result.Notices);
+    }
+
+    /// <summary>
+    /// Joins the values into a single string with optional start, separator, and end strings.
+    /// </summary>
+    /// <typeparam name="T">The type of the values.</typeparam>
+    /// <param name="values">The values to join.</param>
+    /// <param name="start">The starting string.</param>
+    /// <param name="separator">The separator string.</param>
+    /// <param name="end">The ending string.</param>
+    /// <returns>The joined string.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static string Join<T>(this IEnumerable<T> values, string start = "", string seperator = ". ", string end = ".")
+        => new StringBuilder(start).Append(string.Join(seperator, values)).Append(end).ToString();
+
+    /// <summary>
+    /// Logs the notices using the specified logger.
+    /// </summary>
+    /// <param name="logger">The logger to use.</param>
+    /// <param name="notices">The collection of notices to log.</param>
+    /// <param name="start">The starting string for each notice.</param>
+    /// <param name="separator">The separator string for messages in each notice.</param>
+    /// <param name="end">The ending string for each notice.</param>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static void LogNotice(this ILogger logger, IEnumerable<Notice> notices, string start = ": ", string seperator = ". ", string end = ".\n")
+    {
+        foreach (LogLevel level in Enum.GetValues(typeof(LogLevel)))
+        {
+            var logNotices = notices.Where(n => n.Level == level);
+
+            if (!logNotices.Any())
+                continue;
+
+            var sb = new StringBuilder();
+            foreach (Notice notice in logNotices)
+            {
+                if (notice.Flag is not null)
+                    sb.Append(notice.Flag);
+
+                if (notice.Messages.Any())
+                    sb.Append(start).Append(string.Join(seperator, notice.Messages)).AppendLine(end);
+                else sb.Append(end);
+            }
+            logger.Log(level, sb.ToString());
+        }
+    }
+
+    /// <summary>
+    /// Logs the notices from a result using the specified logger.
+    /// </summary>
+    /// <param name="logger">The logger to use.</param>
+    /// <param name="result">The result containing the notices to log.</param>
+    /// <param name="start">The starting string for each notice.</param>
+    /// <param name="separator">The separator string for messages in each notice.</param>
+    /// <param name="end">The ending string for each notice.</param>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static void LogNotice(this ILogger logger, Result result, string start = ": ", string seperator = ". ", string end = ".\n")
+        => logger.LogNotice(notices: result.Notices, start: start, seperator: seperator, end: end);
+
+    /// <summary>
+    /// Determines if the data result is right (true).
+    /// </summary>
+    /// <param name="bResult">The data result to evaluate.</param>
+    /// <returns>True if the data result is true; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static bool IsRight(this DataResult<bool> bResult) => bResult.Data;
+
+    /// <summary>
+    /// Determines if the data result is wrong (false).
+    /// </summary>
+    /// <param name="bResult">The data result to evaluate.</param>
+    /// <returns>True if the data result is false; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static bool IsWrong(this DataResult<bool> bResult) => !bResult.Data;
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/DataResult.cs

@@ -0,0 +1,30 @@
+#if NET
+using System.Text.Json.Serialization;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents a result of an operation that includes data, inheriting from <see cref="Result"/>.
+/// </summary>
+/// <typeparam name="T">The type of the data included in the result.</typeparam>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public class DataResult<T> : Result
+{
+    /// <summary>
+    /// Gets or sets the data included in the result. This property is required.
+    /// It will be ignored during JSON serialization if the value is null.
+    /// </summary>
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public required T Data { get; set; }
+
+    /// <summary>
+    /// Converts the current <see cref="DataResult{T}"/> to a failed <see cref="DataResult{I}"/>,
+    /// preserving the messages and notices.
+    /// </summary>
+    /// <typeparam name="I">The type of the data in the new failed result.</typeparam>
+    /// <returns>A failed <see cref="DataResult{I}"/> with the current messages and notices.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public DataResult<I> ToFail<I>() => Fail<I>().Message(Messages).Notice(Notices);
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/Flag.cs

@@ -0,0 +1,52 @@
+#if NET
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Defines flags that indicate specific types of status or conditions in a service operation.
+/// These flags help in categorizing and identifying specific circumstances or issues that may arise during execution.
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public enum Flag
+{
+    /// <summary>
+    /// Indicates a security breach or vulnerability has been detected during the service operation.
+    /// </summary>
+    SecurityBreach,
+
+    /// <summary>
+    /// Indicates a potential issue with data integrity during the service operation.
+    /// This flag is used when data may have been altered, corrupted, or is otherwise unreliable,
+    /// which could impact the accuracy or trustworthiness of the operation's results.
+    /// </summary>
+    DataIntegrityIssue,
+
+    /// <summary>
+    /// Indicates that either a security breach, a data integrity issue, or both have been detected during the service operation.
+    /// This flag is used when it is not sure whether the problem is security or data integrity. In this case, data integrity should be checked first.
+    /// </summary>
+    SecurityBreachOrDataIntegrity,
+
+    /// <summary>
+    /// Indicates a possible security breach during the service operation.
+    /// </summary>
+    PossibleSecurityBreach,
+
+    /// <summary>
+    /// Indicates a possible issue with data integrity during the service operation.
+    /// This flag is used when there is a suspicion of data alteration, corruption, or unreliability.
+    /// </summary>
+    PossibleDataIntegrityIssue,
+
+    /// <summary>
+    /// Indicates that either a possible security breach, a possible data integrity issue, or both have been detected during the service operation.
+    /// This flag is used when it is uncertain whether the issue is related to security, data integrity, or both.
+    /// </summary>
+    PossibleSecurityBreachOrDataIntegrity,
+
+    /// <summary>
+    /// Indicates that the requested resource or operation could not be found.
+    /// This flag is used when the specified item or condition does not exist or is unavailable.
+    /// </summary>
+    NotFound
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/Notice.cs

@@ -0,0 +1,30 @@
+#if NET
+using Microsoft.Extensions.Logging;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents a notice for logging purposes, containing a flag, log level, and associated messages.
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public class Notice
+{
+    /// <summary>
+    /// Gets or sets an optional flag associated with the notice.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public Enum? Flag { get; init; } = null;
+
+    /// <summary>
+    /// Gets or sets the log level for the notice.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public LogLevel Level { get; init; } = LogLevel.None;
+
+    /// <summary>
+    /// Gets a list of messages associated with the notice.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public List<string> Messages { get; init; } = new();
+}
+#endif

DigitalData.Core.Abstraction.Application/DTO/Result.cs

@@ -0,0 +1,110 @@
+#if NET
+using System.Text.Json.Serialization;
+
+namespace DigitalData.Core.Abstraction.Application.DTO;
+
+/// <summary>
+/// Represents the result of an operation, containing information about its success or failure,
+/// messages for the client, and notices for logging.
+/// </summary>
+[Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+public class Result
+{
+    /// <summary>
+    /// Gets or sets a value indicating whether the operation was successful.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public bool IsSuccess { get; set; } = false;
+
+    /// <summary>
+    /// Gets a value indicating whether the operation failed.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public bool IsFailed => !IsSuccess;
+
+    /// <summary>
+    /// Gets a list of messages intended for the client.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public List<string> Messages { get; init; } = new();
+
+    /// <summary>
+    /// Gets a list of notices intended for logging purposes. This property is ignored during JSON serialization.
+    /// </summary>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    [JsonIgnore]
+    public List<Notice> Notices = new();
+
+    /// <summary>
+    /// Creates a <see cref="DataResult{T}"/> with the specified data.
+    /// </summary>
+    /// <typeparam name="T">The type of the data.</typeparam>
+    /// <param name="data">The data to include in the result.</param>
+    /// <returns>A new <see cref="DataResult{T}"/> instance.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public DataResult<T> Data<T>(T data) => new()
+    {
+        IsSuccess = IsSuccess,
+        Messages = Messages,
+        Notices = Notices,
+        Data = data
+    };
+
+    /// <summary>
+    /// Checks if any notice has the specified flag.
+    /// </summary>
+    /// <param name="flag">The flag to check.</param>
+    /// <returns>True if any notice has the specified flag; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public bool HasFlag(Enum flag) => Notices.Any(n => n.Flag?.ToString() == flag.ToString());
+
+    /// <summary>
+    /// Checks if any notice has any of the specified flags.
+    /// </summary>
+    /// <param name="flags">The flags to check.</param>
+    /// <returns>True if any notice has any of the specified flags; otherwise, false.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public bool HasAnyFlag(params Enum[] flags) => flags.Any(HasFlag);
+
+    /// <summary>
+    /// Creates a new successful <see cref="Result"/>.
+    /// </summary>
+    /// <returns>A new successful <see cref="Result"/>.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static Result Success() => new() { IsSuccess = true };
+
+    /// <summary>
+    /// Creates a new failed <see cref="Result"/>.
+    /// </summary>
+    /// <returns>A new failed <see cref="Result"/>.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static Result Fail() => new() { IsSuccess = false };
+
+    /// <summary>
+    /// Creates a new successful <see cref="DataResult{T}"/> with the specified data.
+    /// </summary>
+    /// <typeparam name="T">The type of the data.</typeparam>
+    /// <param name="data">The data to include in the result.</param>
+    /// <returns>A new successful <see cref="DataResult{T}"/> with the specified data.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public static DataResult<T> Success<T>(T data) => new()
+    {
+        IsSuccess = true,
+        Data = data
+    };
+
+    /// <summary>
+    /// Creates a new failed <see cref="DataResult{T}"/> with no data.
+    /// </summary>
+    /// <typeparam name="T">The type of the data.</typeparam>
+    /// <returns>A new failed <see cref="DataResult{T}"/> with no data.</returns>
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+#pragma warning disable CS8601 // Possible null reference assignment.
+    public static DataResult<T> Fail<T>() => new()
+    {
+        IsSuccess = false,
+        Data = default
+    };
+#pragma warning restore CS8601 // Possible null reference assignment.
+}
+#endif

DigitalData.Core.Abstraction.Application/DigitalData.Core.Abstraction.Application.csproj

@@ -0,0 +1,79 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net462;net7.0;net8.0;net9.0</TargetFrameworks>
+    <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+	  <Description>This package defines the abstraction layer for the DigitalData.Core.Application module, providing interfaces and contracts for application services, repositories, and infrastructure components in alignment with Clean Architecture principles.</Description>
+	  <PackageId>DigitalData.Core.Abstraction.Application</PackageId>
+    <Authors>Digital Data GmbH</Authors>
+    <Company>Digital Data GmbH</Company>
+    <Product>DigitalData.Core.Abstraction.Application</Product>
+    <Copyright>Copyright 2025</Copyright>
+    <PackageIcon>core_icon.png</PackageIcon>
+    <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
+    <PackageTags>digital data core application clean architecture abstraction</PackageTags>
+    <Version>1.5.0</Version>
+    <AssemblyVersion>1.5.0</AssemblyVersion>
+    <FileVersion>1.5.0</FileVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\Assets\core_icon.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+  <!-- disable for net462 -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net462'">
+	<Nullable>disable</Nullable>
+	<ImplicitUsings>disable</ImplicitUsings>
+	<LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+
+  <!-- enable for net7 and more -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net7.0' Or '$(TargetFramework)' == 'net8.0' Or '$(TargetFramework)' == 'net9.0'">
+	<Nullable>enable</Nullable>
+	<ImplicitUsings>enable</ImplicitUsings>
+	<LangVersion>latest</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Localization.Abstractions" Version="7.0.16" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="7.0.0" />
+    <PackageReference Include="System.DirectoryServices.AccountManagement" Version="7.0.1" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.5.1" />
+    <PackageReference Include="System.Security.Cryptography.Cng" Version="5.0.0" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
+	<PackageReference Include="AutoMapper" Version="10.1.1" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+	<PackageReference Include="AutoMapper" Version="13.0.1" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.1" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="9.0.5" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
+  </ItemGroup>
+	
+</Project>

DigitalData.Core.Abstraction.Application/EntityExtensions.cs

@@ -0,0 +1,96 @@
+#if NET
+namespace DigitalData.Core.Abstraction.Application;
+
+/// <summary>
+/// Provides extension methods for retrieving the value of an 'Id' property from objects.
+/// </summary>
+public static class EntityExtensions
+{
+    /// <summary>
+    /// Attempts to retrieve the value of the 'Id' property from the specified object.
+    /// </summary>
+    /// <typeparam name="TId">The expected type of the 'Id' property.</typeparam>
+    /// <param name="obj">The object from which to retrieve the 'Id' property.</param>
+    /// <returns>
+    /// The value of the 'Id' property if it exists and is of type <typeparamref name="TId"/>; otherwise, <c>default</c>.
+    /// </returns>
+    public static TId? GetIdOrDefault<TId>(this object? obj)
+    {
+        var prop = obj?.GetType().GetProperty("Id");
+        return prop is not null && prop.GetValue(obj) is TId id ? id : default;
+    }
+
+    /// <summary>
+    /// Retrieves the value of the 'Id' property from the specified object, or throws an exception if not found or of the wrong type.
+    /// </summary>
+    /// <typeparam name="TId">The expected type of the 'Id' property.</typeparam>
+    /// <param name="obj">The object from which to retrieve the 'Id' property.</param>
+    /// <returns>The value of the 'Id' property.</returns>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if the object does not have a readable 'Id' property of type <typeparamref name="TId"/>.
+    /// </exception>
+    public static TId GetId<TId>(this object? obj)
+        => obj.GetIdOrDefault<TId>()
+        ?? throw new InvalidOperationException($"The object of type '{obj?.GetType().FullName ?? "null"}' does not have a readable 'Id' property of type '{typeof(TId).FullName}'.");
+
+    /// <summary>
+    /// Tries to retrieve the value of the 'Id' property from the specified object.
+    /// </summary>
+    /// <typeparam name="TId">The expected type of the 'Id' property.</typeparam>
+    /// <param name="obj">The object from which to retrieve the 'Id' property.</param>
+    /// <param name="id">When this method returns, contains the value of the 'Id' property if found; otherwise, the default value for the type.</param>
+    /// <returns>
+    /// <c>true</c> if the 'Id' property was found and is of type <typeparamref name="TId"/>; otherwise, <c>false</c>.
+    /// </returns>
+    public static bool TryGetId<TId>(object? obj, out TId id)
+    {
+#pragma warning disable CS8601
+        id = obj.GetIdOrDefault<TId>();
+#pragma warning restore CS8601
+        return id is not null;
+    }
+
+    /// <summary>
+    /// Attempts to retrieve the value of the 'Id' property from the specified object.
+    /// </summary>
+    /// <param name="obj">The object from which to retrieve the 'Id' property.</param>
+    /// <returns>
+    /// The value of the 'Id' property if it exists; otherwise, <c>null</c>.
+    /// </returns>
+    public static object? GetIdOrDefault(this object? obj)
+    {
+        var prop = obj?.GetType().GetProperty("Id");
+        return prop?.GetValue(obj);
+    }
+
+    /// <summary>
+    /// Retrieves the value of the 'Id' property from the specified object, or throws an exception if not found.
+    /// </summary>
+    /// <param name="obj">The object from which to retrieve the 'Id' property.</param>
+    /// <returns>The value of the 'Id' property.</returns>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if the object does not have a readable 'Id' property.
+    /// </exception>
+    public static object GetId(this object? obj)
+        => obj.GetIdOrDefault()
+        ?? throw new InvalidOperationException($"The object of type '{obj?.GetType().FullName ?? "null"}' does not have a readable 'Id' property.");
+
+    /// <summary>
+    /// Tries to retrieve the value of the 'Id' property from the specified object.
+    /// </summary>
+    /// <param name="obj">The object from which to retrieve the 'Id' property.</param>
+    /// <param name="id">
+    /// When this method returns, contains the value of the 'Id' property if found; otherwise, <c>null</c>.
+    /// </param>
+    /// <returns>
+    /// <c>true</c> if the 'Id' property was found; otherwise, <c>false</c>.
+    /// </returns>
+    public static bool TryGetId(object? obj, out object id)
+    {
+#pragma warning disable CS8601
+        id = obj.GetIdOrDefault();
+#pragma warning restore CS8601
+        return id is not null;
+    }
+}
+#endif

DigitalData.Core.Abstraction.Application/IBasicCRUDService.cs

@@ -1,6 +1,5 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-
-namespace DigitalData.Core.Abstractions.Application
+#if NET
+namespace DigitalData.Core.Abstraction.Application
 {
     /// <summary>
     /// Implements a simplified CRUD service interface that uses a single Data Transfer Object (DTO) type for all CRUD operations,
@@ -15,8 +14,10 @@ namespace DigitalData.Core.Abstractions.Application
     /// This interface is useful for entities that do not require different DTOs for different operations,
     /// allowing for a more concise and maintainable codebase when implementing services for such entities.
     /// </remarks>
+    [Obsolete("Use MediatR")]
     public interface IBasicCRUDService<TDto, TEntity, TId> : ICRUDService<TDto, TDto, TEntity, TId>
-        where TDto : class, IUnique<TId> where TEntity : class, IUnique<TId>
+        where TDto : class where TEntity : class
     {
     }
-}
+}
+#endif

DigitalData.Core.Abstraction.Application/ICRUDService.cs

@@ -0,0 +1,26 @@
+#if NET
+using DigitalData.Core.Abstraction.Application.DTO;
+
+namespace DigitalData.Core.Abstraction.Application;
+
+[Obsolete("Use MediatR")]
+public interface ICRUDService<TCreateDto, TReadDto, TEntity, TId> : IReadService<TReadDto, TEntity, TId>
+    where TCreateDto : class where TReadDto : class where TEntity : class
+{
+    /// <summary>
+    /// Asynchronously creates a new entity based on the provided <paramref name="createDto"/> and returns the identifier of the created entity wrapped in a <see cref="DataResult{TId}"/>.
+    /// The <see cref="DataResult{TId}"/> contains the identifier of the newly created entity on success or an error message on failure.
+    /// </summary>
+    /// <param name="createDto">The data transfer object containing the information for the new entity.</param>
+    /// <returns>A task representing the asynchronous operation, with a <see cref="DataResult{TId}"/> containing the identifier of the created entity or an error message.</returns>
+    Task<DataResult<TReadDto>> CreateAsync(TCreateDto createDto);
+
+    /// <summary>
+    /// Updates an existing entity based on the provided updateDTO and returns the result wrapped in an IServiceMessage,
+    /// indicating the success or failure of the operation, including the error messages on failure.
+    /// </summary>
+    /// <param name="updateDto">The updateDTO with updated values for the entity.</param>
+    /// <returns>An Result indicating the outcome of the update operation, with an appropriate message.</returns>
+    Task<Result> UpdateAsync<TUpdateDto>(TUpdateDto updateDto);
+}
+#endif

DigitalData.Core.Abstraction.Application/IDirectorySearchService.cs

@@ -0,0 +1,96 @@
+#if NET
+using DigitalData.Core.Abstraction.Application.DTO;
+using System.DirectoryServices;
+
+namespace DigitalData.Core.Abstraction.Application;
+
+[Obsolete("Use DigitalData.ActiveDirectory")]
+public interface IDirectorySearchService
+{
+    public string ServerName { get; }
+
+    public string Root { get; }
+
+    string SearchRootPath { get; }
+
+    Dictionary<string, string> CustomSearchFilters { get; }
+
+    /// <summary>
+    /// Creates the connections to the server and returns a Boolean value that specifies
+    /// whether the specified username and password are valid.
+    /// </summary>
+    /// <param name="userName">The username that is validated on the server. See the Remarks section
+    /// for more information on the format of userName.</param>
+    /// <param name="password">The password that is validated on the server.</param>
+    /// <returns>True if the credentials are valid; otherwise, false.</returns>
+    bool ValidateCredentials(string userName, string password);
+
+    /// <summary>
+    /// Creates the connections to the server asynchronously and returns a Boolean value that specifies
+    /// whether the specified username and password are valid.
+    /// </summary>
+    /// <param name="userName">The username that is validated on the server. See the Remarks section
+    /// for more information on the format of userName.</param>
+    /// <param name="password">The password that is validated on the server.</param>
+    /// <returns>True if the credentials are valid; otherwise, false.</returns>
+    Task<bool> ValidateCredentialsAsync(string userName, string password);
+
+    /// <summary>
+    /// Finds all directory entries matching the specified filter.
+    /// </summary>
+    /// <param name="searchRoot">The search root.</param>
+    /// <param name="filter">The search filter.</param>
+    /// <param name="searchScope">The search scope.</param>
+    /// <param name="sizeLimit">The size limit.</param>
+    /// <param name="properties">The properties to load.</param>
+    /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
+    DataResult<IEnumerable<ResultPropertyCollection>> FindAll(DirectoryEntry searchRoot, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
+
+    /// <summary>
+    /// Finds all directory entries matching the specified filter asynchronously.
+    /// </summary>
+    /// <param name="searchRoot">The search root.</param>
+    /// <param name="filter">The search filter.</param>
+    /// <param name="searchScope">The search scope.</param>
+    /// <param name="sizeLimit">The size limit.</param>
+    /// <param name="properties">The properties to load.</param>
+    /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
+    Task<DataResult<IEnumerable<ResultPropertyCollection>>> FindAllAsync(DirectoryEntry searchRoot, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
+
+    /// <summary>
+    /// Finds all directory entries matching the specified filter, using the user cache.
+    /// </summary>
+    /// <param name="username">The username.</param>
+    /// <param name="filter">The search filter.</param>
+    /// <param name="searchScope">The search scope.</param>
+    /// <param name="sizeLimit">The size limit.</param>
+    /// <param name="properties">The properties to load.</param>
+    /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
+    DataResult<IEnumerable<ResultPropertyCollection>> FindAllByUserCache(string username, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
+
+    /// <summary>
+    /// Finds all directory entries matching the specified filter asynchronously, using the user cache.
+    /// </summary>
+    /// <param name="username">The username.</param>
+    /// <param name="filter">The search filter.</param>
+    /// <param name="searchScope">The search scope.</param>
+    /// <param name="sizeLimit">The size limit.</param>
+    /// <param name="properties">The properties to load.</param>
+    /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
+    Task<DataResult<IEnumerable<ResultPropertyCollection>>> FindAllByUserCacheAsync(string username, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
+
+    /// <summary>
+    /// Sets the search root in the cache.
+    /// </summary>
+    /// <param name="username">The directory entry username.</param>
+    /// <param name="password">The directory entry password.</param>
+    void SetSearchRootCache(string username, string password);
+
+    /// <summary>
+    /// Gets the search root from the cache.
+    /// </summary>
+    /// <param name="username">The directory entry username.</param>
+    /// <returns>The cached <see cref="DirectoryEntry"/> if found; otherwise, null.</returns>
+    DirectoryEntry? GetSearchRootCache(string username);
+}
+#endif

DigitalData.Core.Abstraction.Application/IJWTService.cs

@@ -0,0 +1,42 @@
+#if NET
+using Microsoft.IdentityModel.Tokens;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Cryptography;
+
+namespace DigitalData.Core.Abstraction.Application;
+
+/// <summary>
+/// Defines the operations for JWT service handling claims of type <typeparamref name="TClaimValue"/>.
+/// </summary>
+public interface IJWTService<TClaimValue>
+{
+    /// <summary>
+    /// Generates a symmetric security key with the specified byte size.
+    /// </summary>
+    /// <param name="byteSize">The size of the security key in bytes. Default is 32 bytes.</param>
+    /// <returns>A new instance of <see cref="SymmetricSecurityKey"/>.</returns>
+    public static SymmetricSecurityKey GenerateSecurityKey(int byteSize = 32)
+    {
+        using var rng = RandomNumberGenerator.Create();
+        var randomBytes = new byte[byteSize];
+        rng.GetBytes(randomBytes);
+        var securityKey = new SymmetricSecurityKey(randomBytes);
+
+        return securityKey;
+    }
+
+    /// <summary>
+    /// Generates a token based on the specified claim value.
+    /// </summary>
+    /// <param name="claimValue">The claim value to encode in the token.</param>
+    /// <returns>A JWT as a string.</returns>
+    string GenerateToken(TClaimValue claimValue);
+
+    /// <summary>
+    /// Reads and validates a security token from a string representation.
+    /// </summary>
+    /// <param name="token">The JWT to read.</param>
+    /// <returns>A <see cref="JwtSecurityToken"/> if the token is valid; otherwise, null.</returns>
+    JwtSecurityToken? ReadSecurityToken(string token);
+}
+#endif

DigitalData.Core.Abstraction.Application/IReadService.cs

@@ -0,0 +1,40 @@
+#if NET
+using DigitalData.Core.Abstraction.Application.DTO;
+
+namespace DigitalData.Core.Abstraction.Application;
+
+[Obsolete("Use MediatR")]
+public interface IReadService<TReadDto, TEntity, TId>
+    where TReadDto : class where TEntity : class
+{
+    /// <summary>
+    /// Retrieves an entity by its identifier and returns its readDTO representation wrapped in an IServiceResult,
+    /// including the readDTO on success or null and an error message on failure.
+    /// </summary>
+    /// <param name="id">The identifier of the entity to retrieve.</param>
+    /// <returns>An DataResult containing the readDTO representing the found entity or null, with an appropriate message.</returns>
+    Task<DataResult<TReadDto>> ReadByIdAsync(TId id);
+
+    /// <summary>
+    /// Retrieves all entities and returns their readDTO representations wrapped in an IServiceResult,
+    /// including a collection of readDTOs on success or an error message on failure.
+    /// </summary>
+    /// <returns>An DataResult containing a collection of readDTOs representing all entities or an error message.</returns>
+    Task<DataResult<IEnumerable<TReadDto>>> ReadAllAsync();
+
+    /// <summary>
+    /// Deletes an entity by its identifier and returns the result wrapped in an IServiceMessage,
+    /// indicating the success or failure of the operation, including the error messages on failure.
+    /// </summary>
+    /// <param name="id">The identifier of the entity to delete.</param>
+    /// <returns>An Result indicating the outcome of the delete operation, with an appropriate message.</returns>
+    Task<Result> DeleteAsyncById(TId id);
+
+    /// <summary>
+    /// Asynchronously checks if an entity with the specified identifier exists within the data store.
+    /// </summary>
+    /// <param name="id">The identifier of the entity to check.</param>
+    /// <returns>A task that represents the asynchronous operation. The task result contains a boolean value indicating whether the entity exists.</returns>
+    Task<bool> HasEntity(TId id);
+}
+#endif

DigitalData.Core.Abstraction.Application/Repository/ICRUDRepository.cs

@@ -1,11 +1,13 @@
-namespace DigitalData.Core.Abstractions.Infrastructure
+#if NET
+namespace DigitalData.Core.Abstraction.Application.Repository
 {
     /// <summary>
     /// Defines the contract for CRUD operations on a repository for entities of type TEntity.
     /// </summary>
     /// <typeparam name="TEntity">The type of the entity this repository works with.</typeparam>
     /// <typeparam name="TId">The type of the identifier for the entity.</typeparam>
-    public interface ICRUDRepository<TEntity, TId> where TEntity : class, IUnique<TId>
+    [Obsolete("Use IRepository")]
+    public interface ICRUDRepository<TEntity, TId> where TEntity : class
     {
         /// <summary>
         /// Adds a new entity to the repository.
@@ -59,4 +61,5 @@
         /// </remarks>
         Task<int> CountAsync(TId id);
     }
-}
+}
+#endif

DigitalData.Core.Abstraction.Application/Repository/IEntityMapper.cs

@@ -1,4 +1,7 @@
-namespace DigitalData.Core.Abstractions.Infrastructure
+#if NETFRAMEWORK
+using System.Collections.Generic;
+#endif
+namespace DigitalData.Core.Abstraction.Application.Repository
 {
     /// <summary>
     /// Defines methods for mapping between entities and Data Transfer Objects (DTOs).

DigitalData.Core.Abstraction.Application/Repository/IRepository.cs

@@ -0,0 +1,113 @@
+using System.Linq.Expressions;
+#if NETFRAMEWORK
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Linq;
+#endif
+
+namespace DigitalData.Core.Abstraction.Application.Repository
+#if NET
+    ;
+#elif NETFRAMEWORK
+    {
+#endif
+
+    public interface IRepository<TEntity>
+    {
+        #region Create
+#if NET
+    public
+#endif
+        Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default);
+        #endregion Create
+
+        #region Read
+#if NET
+    public
+#endif
+        IQueryable<TEntity> Query { get; }
+
+#if NET
+    public
+#endif
+        IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression);
+
+#if NET
+    public
+#endif
+        IEnumerable<TEntity> GetAll();
+
+#if NET
+    public
+#endif
+        Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancel = default);
+        #endregion Read
+
+        #region Update
+#if NET
+    public
+#endif
+        Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task UpdateAsync(Action<TEntity> modification, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task UpdateAsync(Action<TEntity> modification, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+        #endregion Update
+
+        #region Delete
+#if NET
+    public
+#endif
+        Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task DeleteAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default);
+        #endregion Delete
+
+        #region Obsolete
+        [Obsolete("Use CreateAsync, UpdateAsync or DeleteAsync")]
+#if NET
+    public
+#endif
+        IQueryable<TEntity> Read();
+
+        [Obsolete("Use IRepository<TEntity>.Where")]
+#if NET
+    public
+#endif
+        IQueryable<TEntity> ReadOnly();
+        #endregion
+    }
+#if NETFRAMEWORK
+    }
+#endif

DigitalData.Core.Abstraction.Application/Repository/ServiceProviderExtensions.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+#if NETFRAMEWORK
+using System;
+#endif
+
+namespace DigitalData.Core.Abstraction.Application.Repository
+{
+    public static class ServiceProviderExtensions
+    {
+        public static IRepository<TEntity> Repository<TEntity>(this IServiceProvider serviceProvider)
+        {
+            return serviceProvider.GetRequiredService<IRepository<TEntity>>();
+        }
+    }
+}

DigitalData.Core.Abstractions/Application/ICRUDService.cs

@@ -1,25 +0,0 @@
-using DigitalData.Core.DTO;
-
-namespace DigitalData.Core.Abstractions.Application
-{
-    public interface ICRUDService<TCreateDto, TReadDto, TEntity, TId> : IReadService<TReadDto, TEntity, TId>
-        where TCreateDto : class where TReadDto : class where TEntity : class, IUnique<TId>
-    {
-        /// <summary>
-        /// Asynchronously creates a new entity based on the provided <paramref name="createDto"/> and returns the identifier of the created entity wrapped in a <see cref="DataResult{TId}"/>.
-        /// The <see cref="DataResult{TId}"/> contains the identifier of the newly created entity on success or an error message on failure.
-        /// </summary>
-        /// <param name="createDto">The data transfer object containing the information for the new entity.</param>
-        /// <returns>A task representing the asynchronous operation, with a <see cref="DataResult{TId}"/> containing the identifier of the created entity or an error message.</returns>
-        Task<DataResult<TId>> CreateAsync(TCreateDto createDto);
-
-
-        /// <summary>
-        /// Updates an existing entity based on the provided updateDTO and returns the result wrapped in an IServiceMessage,
-        /// indicating the success or failure of the operation, including the error messages on failure.
-        /// </summary>
-        /// <param name="updateDto">The updateDTO with updated values for the entity.</param>
-        /// <returns>An Result indicating the outcome of the update operation, with an appropriate message.</returns>
-        Task<Result> UpdateAsync<TUpdateDto>(TUpdateDto updateDto) where TUpdateDto : IUnique<TId>;
-    }
-}

DigitalData.Core.Abstractions/Application/IDirectorySearchService.cs

@@ -1,94 +0,0 @@
-using DigitalData.Core.DTO;
-using System.DirectoryServices;
-
-namespace DigitalData.Core.Abstractions.Application
-{
-    public interface IDirectorySearchService
-    {
-        public string ServerName { get; }
-
-        public string Root { get; }
-
-        string SearchRootPath { get; }
-
-        Dictionary<string, string> CustomSearchFilters { get; }
-
-        /// <summary>
-        /// Creates the connections to the server and returns a Boolean value that specifies
-        /// whether the specified username and password are valid.
-        /// </summary>
-        /// <param name="userName">The username that is validated on the server. See the Remarks section
-        /// for more information on the format of userName.</param>
-        /// <param name="password">The password that is validated on the server.</param>
-        /// <returns>True if the credentials are valid; otherwise, false.</returns>
-        bool ValidateCredentials(string userName, string password);
-
-        /// <summary>
-        /// Creates the connections to the server asynchronously and returns a Boolean value that specifies
-        /// whether the specified username and password are valid.
-        /// </summary>
-        /// <param name="userName">The username that is validated on the server. See the Remarks section
-        /// for more information on the format of userName.</param>
-        /// <param name="password">The password that is validated on the server.</param>
-        /// <returns>True if the credentials are valid; otherwise, false.</returns>
-        Task<bool> ValidateCredentialsAsync(string userName, string password);
-
-        /// <summary>
-        /// Finds all directory entries matching the specified filter.
-        /// </summary>
-        /// <param name="searchRoot">The search root.</param>
-        /// <param name="filter">The search filter.</param>
-        /// <param name="searchScope">The search scope.</param>
-        /// <param name="sizeLimit">The size limit.</param>
-        /// <param name="properties">The properties to load.</param>
-        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
-        DataResult<IEnumerable<ResultPropertyCollection>> FindAll(DirectoryEntry searchRoot, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
-
-        /// <summary>
-        /// Finds all directory entries matching the specified filter asynchronously.
-        /// </summary>
-        /// <param name="searchRoot">The search root.</param>
-        /// <param name="filter">The search filter.</param>
-        /// <param name="searchScope">The search scope.</param>
-        /// <param name="sizeLimit">The size limit.</param>
-        /// <param name="properties">The properties to load.</param>
-        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
-        Task<DataResult<IEnumerable<ResultPropertyCollection>>> FindAllAsync(DirectoryEntry searchRoot, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
-
-        /// <summary>
-        /// Finds all directory entries matching the specified filter, using the user cache.
-        /// </summary>
-        /// <param name="username">The username.</param>
-        /// <param name="filter">The search filter.</param>
-        /// <param name="searchScope">The search scope.</param>
-        /// <param name="sizeLimit">The size limit.</param>
-        /// <param name="properties">The properties to load.</param>
-        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
-        DataResult<IEnumerable<ResultPropertyCollection>> FindAllByUserCache(string username, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
-
-        /// <summary>
-        /// Finds all directory entries matching the specified filter asynchronously, using the user cache.
-        /// </summary>
-        /// <param name="username">The username.</param>
-        /// <param name="filter">The search filter.</param>
-        /// <param name="searchScope">The search scope.</param>
-        /// <param name="sizeLimit">The size limit.</param>
-        /// <param name="properties">The properties to load.</param>
-        /// <returns>A <see cref="DataResult{T}"/> containing the results.</returns>
-        Task<DataResult<IEnumerable<ResultPropertyCollection>>> FindAllByUserCacheAsync(string username, string filter, SearchScope searchScope = SearchScope.Subtree, int sizeLimit = 5000, params string[] properties);
-
-        /// <summary>
-        /// Sets the search root in the cache.
-        /// </summary>
-        /// <param name="username">The directory entry username.</param>
-        /// <param name="password">The directory entry password.</param>
-        void SetSearchRootCache(string username, string password);
-
-        /// <summary>
-        /// Gets the search root from the cache.
-        /// </summary>
-        /// <param name="username">The directory entry username.</param>
-        /// <returns>The cached <see cref="DirectoryEntry"/> if found; otherwise, null.</returns>
-        DirectoryEntry? GetSearchRootCache(string username);
-    }
-}

DigitalData.Core.Abstractions/Application/IJWTService.cs

@@ -1,41 +0,0 @@
-using Microsoft.IdentityModel.Tokens;
-using System.IdentityModel.Tokens.Jwt;
-using System.Security.Cryptography;
-
-namespace DigitalData.Core.Application
-{
-    /// <summary>
-    /// Defines the operations for JWT service handling claims of type <typeparamref name="TClaimValue"/>.
-    /// </summary>
-    public interface IJWTService<TClaimValue>
-    {
-        /// <summary>
-        /// Generates a symmetric security key with the specified byte size.
-        /// </summary>
-        /// <param name="byteSize">The size of the security key in bytes. Default is 32 bytes.</param>
-        /// <returns>A new instance of <see cref="SymmetricSecurityKey"/>.</returns>
-        public static SymmetricSecurityKey GenerateSecurityKey(int byteSize = 32)
-        {
-            using var rng = RandomNumberGenerator.Create();
-            var randomBytes = new byte[byteSize];
-            rng.GetBytes(randomBytes);
-            var securityKey = new SymmetricSecurityKey(randomBytes);
-
-            return securityKey;
-        }
-
-        /// <summary>
-        /// Generates a token based on the specified claim value.
-        /// </summary>
-        /// <param name="claimValue">The claim value to encode in the token.</param>
-        /// <returns>A JWT as a string.</returns>
-        string GenerateToken(TClaimValue claimValue);
-
-        /// <summary>
-        /// Reads and validates a security token from a string representation.
-        /// </summary>
-        /// <param name="token">The JWT to read.</param>
-        /// <returns>A <see cref="JwtSecurityToken"/> if the token is valid; otherwise, null.</returns>
-        JwtSecurityToken? ReadSecurityToken(string token);
-    }
-}

DigitalData.Core.Abstractions/Application/IReadService.cs

@@ -1,38 +0,0 @@
-using DigitalData.Core.DTO;
-
-namespace DigitalData.Core.Abstractions.Application
-{
-    public interface IReadService<TReadDto, TEntity, TId>
-        where TReadDto : class where TEntity : class
-    {
-        /// <summary>
-        /// Retrieves an entity by its identifier and returns its readDTO representation wrapped in an IServiceResult,
-        /// including the readDTO on success or null and an error message on failure.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to retrieve.</param>
-        /// <returns>An DataResult containing the readDTO representing the found entity or null, with an appropriate message.</returns>
-        Task<DataResult<TReadDto>> ReadByIdAsync(TId id);
-
-        /// <summary>
-        /// Retrieves all entities and returns their readDTO representations wrapped in an IServiceResult,
-        /// including a collection of readDTOs on success or an error message on failure.
-        /// </summary>
-        /// <returns>An DataResult containing a collection of readDTOs representing all entities or an error message.</returns>
-        Task<DataResult<IEnumerable<TReadDto>>> ReadAllAsync();
-        
-        /// <summary>
-        /// Deletes an entity by its identifier and returns the result wrapped in an IServiceMessage,
-        /// indicating the success or failure of the operation, including the error messages on failure.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to delete.</param>
-        /// <returns>An Result indicating the outcome of the delete operation, with an appropriate message.</returns>
-        Task<Result> DeleteAsyncById(TId id);
-
-        /// <summary>
-        /// Asynchronously checks if an entity with the specified identifier exists within the data store.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to check.</param>
-        /// <returns>A task that represents the asynchronous operation. The task result contains a boolean value indicating whether the entity exists.</returns>
-        Task<bool> HasEntity(TId id);
-    }
-}

DigitalData.Core.Abstractions/ConfigurationExtension.cs

@@ -0,0 +1,31 @@
+#if NET
+using Microsoft.Extensions.Configuration;
+
+namespace DigitalData.Core.Abstractions;
+
+/// <summary>
+/// Extension methods for the <see cref="IConfiguration"/> interface, providing 
+/// additional functionality for retrieving configuration values with default behavior.
+/// </summary>
+public static class ConfigurationExtension
+{
+    /// <summary>
+    /// Retrieves a configuration value for the specified key, or returns a default value 
+    /// of type <typeparamref name="T"/> if the configuration is not found or the key is null.
+    /// </summary>
+    /// <typeparam name="T">The type of the object to retrieve from the configuration.</typeparam>
+    /// <param name="configuration">The <see cref="IConfiguration"/> instance.</param>
+    /// <param name="key">The optional key to look for in the configuration. If null, the method 
+    /// retrieves the root configuration.</param>
+    /// <returns>
+    /// An instance of <typeparamref name="T"/> populated from the configuration values, or 
+    /// a new instance of <typeparamref name="T"/> if no matching configuration is found.
+    /// </returns>
+    public static T GetOrDefault<T>(this IConfiguration configuration, string? key = null)
+        where T : new()
+        => (key is null
+            ? configuration.Get<T>()
+            : configuration.GetSection(key).Get<T>())
+        ?? new T();
+}
+#endif

DigitalData.Core.Abstractions/DeferredServiceProvider.cs

@@ -0,0 +1,42 @@
+#if NET
+namespace DigitalData.Core.Abstractions;
+
+/// <summary>
+/// A deferred implementation of <see cref="IServiceProvider"/> that allows the <see cref="IServiceProvider"/> instance 
+/// to be provided at a later time via a factory callback.
+/// </summary>
+/// <remarks>
+/// This is particularly useful when service registration requires an <see cref="IServiceProvider"/> instance,
+/// but the service provider is not yet available at registration time. 
+/// By using <see cref="DeferredServiceProvider"/>, a service can safely resolve dependencies once
+/// the application's service provider has been built, ensuring a single consistent scope.
+/// </remarks>
+public class DeferredServiceProvider : IServiceProvider
+{
+    private Lazy<IServiceProvider>? _serviceProvider;
+
+    /// <summary>
+    /// Sets the factory that will be used to lazily initialize the <see cref="IServiceProvider"/> instance.
+    /// </summary>
+    public Func<IServiceProvider> Factory
+    {
+        set => _serviceProvider = new(value);
+    }
+
+    /// <summary>
+    /// Retrieves the requested service object from the deferred <see cref="IServiceProvider"/>.
+    /// </summary>
+    /// <param name="serviceType">The type of service object to retrieve.</param>
+    /// <returns>The requested service object, or <c>null</c> if the service is not available.</returns>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if the service provider factory has not been set before calling <see cref="GetService"/>.
+    /// </exception>
+    public object? GetService(Type serviceType)
+    {
+        if (_serviceProvider is null)
+            throw new InvalidOperationException("The service provider has not been initialized. Make sure 'Factory' is set before calling 'GetService'.");
+
+        return _serviceProvider.Value.GetService(serviceType);
+    }
+}
+#endif

DigitalData.Core.Abstractions/DigitalData.Core.Abstractions.csproj

@@ -1,15 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFrameworks>net7.0;net8.0;net9.0</TargetFrameworks>
+		<TargetFrameworks>net462;net7.0;net8.0;net9.0</TargetFrameworks>
 		<ImplicitUsings>enable</ImplicitUsings>
-		<Nullable>enable</Nullable>
 		<!-- NuGet Package Metadata -->
 		<PackageId>DigitalData.Core.Abstractions</PackageId>
 		<Authors>Digital Data GmbH</Authors>
 		<Company>Digital Data GmbH</Company>
 		<Product>DigitalData.Core.Abstractions</Product>
-		<Description>This package contains abstractions for the DigitalData.Core library, developed according to the principles of Clean Architecture. It promotes separation of concerns and enables independent core logic.</Description>
+		<Description>This package contains abstractions for the DigitalData.Core library.</Description>
 		<PackageTags>digital data core abstractions clean architecture</PackageTags>
 		<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
 		<Copyright>Copyright 2024</Copyright>
@@ -17,28 +16,53 @@
 		<RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
 		<PackAsTool>False</PackAsTool>
 		<PackageIcon>core_icon.png</PackageIcon>
-		<Version>3.4.3</Version>
-		<AssemblyVersion>3.4.3</AssemblyVersion>
-		<FileVersion>3.4.3</FileVersion>
+		<Version>4.3.0</Version>
+		<AssemblyVersion>4.3.0</AssemblyVersion>
+		<FileVersion>4.3.0</FileVersion>
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <None Include="..\..\nuget-package-icons\core_icon.png">
-	    <Pack>True</Pack>
-	    <PackagePath>\</PackagePath>
-	  </None>
+		<None Include="..\Assets\core_icon.png">
+			<Pack>True</Pack>
+			<PackagePath>\</PackagePath>
+		</None>
 	</ItemGroup>
 
-	<ItemGroup>
-		<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
-		<PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="7.0.4" />
-		<PackageReference Include="System.DirectoryServices" Version="7.0.1" />
-		<PackageReference Include="System.DirectoryServices.AccountManagement" Version="7.0.1" />
-		<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.5.1" />
-	</ItemGroup>
+	<!-- disable for net462 -->
+	<PropertyGroup Condition="'$(TargetFramework)' == 'net462'">
+		<Nullable>disable</Nullable>
+		<ImplicitUsings>disable</ImplicitUsings>
+		<LangVersion>7.3</LangVersion>
+	</PropertyGroup>
 
-	<ItemGroup>
-	  <ProjectReference Include="..\DigitalData.Core.DTO\DigitalData.Core.DTO.csproj" />
+	<!-- enable for net7 and more -->
+	<PropertyGroup Condition="'$(TargetFramework)' == 'net7.0' Or '$(TargetFramework)' == 'net8.0' Or '$(TargetFramework)' == 'net9.0'">
+		<Nullable>enable</Nullable>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<LangVersion>latest</LangVersion>
+	</PropertyGroup>
+
+	<ItemGroup Condition="'$(TargetFramework)' == 'net462'">
+	  <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+	  <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="7.0.0" />
 	</ItemGroup>
+	
+    <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+      <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
+      <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="7.0.4" />
+      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    </ItemGroup>
+	
+    <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+      <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.1" />
+      <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.5" />
+      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.1" />
+    </ItemGroup>
+	
+    <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+      <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="9.0.5" />
+      <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.5" />
+      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
+    </ItemGroup>
 
 </Project>

DigitalData.Core.Abstractions/Factory.cs

@@ -0,0 +1,142 @@
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections;
+#if NETFRAMEWORK
+using System;
+using System.Collections.Generic;
+#endif
+
+namespace DigitalData.Core.Abstractions
+{
+    public class Factory : IServiceProvider, IServiceCollection
+    {
+        public static readonly Factory Shared = new Factory();
+
+        private readonly IServiceCollection _serviceCollection = new ServiceCollection();
+        private readonly Lazy<IServiceProvider> _lazyServiceProvider;
+
+        private bool IsBuilt => _lazyServiceProvider.IsValueCreated;
+
+        private PostBuildBehavior _pbBehavior = PostBuildBehavior.ThrowException;
+
+        public Factory BehaveOnPostBuild(PostBuildBehavior postBuildBehavior)
+        {
+            _pbBehavior = postBuildBehavior;
+            return this;
+        }
+
+        public Factory()
+        {
+            _lazyServiceProvider = new Lazy<IServiceProvider>(() => _serviceCollection.BuildServiceProvider());
+        }
+
+        #region Service Provider
+        public object
+#if NET
+            ?
+#endif
+            GetService(Type serviceType)
+        {
+            return _lazyServiceProvider.Value.GetService(serviceType);
+        }
+
+        public IServiceScopeFactory ScopeFactory => this.GetRequiredService<IServiceScopeFactory>();
+        #endregion
+
+        #region Service Collection
+        public int Count => _serviceCollection.Count;
+
+        public bool IsReadOnly => _serviceCollection.IsReadOnly;
+
+        public ServiceDescriptor this[int index]
+        {
+            get => _serviceCollection[index];
+            set
+            {
+                if (EnsureBuilt())
+                    return;
+                _serviceCollection[index] = value;
+            }
+        }
+
+        public int IndexOf(ServiceDescriptor item)
+        {
+            return _serviceCollection.IndexOf(item);
+        }
+
+        public void Insert(int index, ServiceDescriptor item)
+        {
+            if (EnsureBuilt())
+                return;
+            _serviceCollection.Insert(index, item);
+        }
+
+        public void RemoveAt(int index)
+        {
+            if (EnsureBuilt())
+                return;
+            _serviceCollection.RemoveAt(index);
+        }
+
+        public void Add(ServiceDescriptor item)
+        {
+            if (EnsureBuilt())
+                return;
+            _serviceCollection.Add(item);
+        }
+
+        public void Clear()
+        {
+            if (EnsureBuilt())
+                return;
+            _serviceCollection.Clear();
+        }
+
+        public bool Contains(ServiceDescriptor item)
+        {
+            return _serviceCollection.Contains(item);
+        }
+
+        public void CopyTo(ServiceDescriptor[] array, int arrayIndex)
+        {
+            _serviceCollection.CopyTo(array, arrayIndex);
+        }
+
+        public bool Remove(ServiceDescriptor item)
+        {
+            if (EnsureBuilt())
+                return false;
+            return _serviceCollection.Remove(item);
+        }
+
+        public IEnumerator<ServiceDescriptor> GetEnumerator()
+        {
+            return _serviceCollection.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return (_serviceCollection as IEnumerable).GetEnumerator();
+        }
+        #endregion
+
+        #region Helpers
+        private bool EnsureBuilt()
+        {
+            if (IsBuilt)
+            {
+                return _pbBehavior == PostBuildBehavior.ThrowException
+                    ? throw new InvalidOperationException("Service provider has already been built. No further service modifications are allowed.")
+                    : true;
+            }
+            else
+                return false;
+        }
+        #endregion
+    }
+
+    public enum PostBuildBehavior
+    {
+        ThrowException,
+        Ignore
+    }
+}

DigitalData.Core.Abstractions/IUnique.cs

@@ -1,7 +0,0 @@
-namespace DigitalData.Core.Abstractions
-{
-    public interface IUnique<T>
-    {
-        public T Id { get; }
-    }
-}

DigitalData.Core.Abstractions/Infrastructure/Extensions.cs

@@ -1,34 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Abstractions.Infrastructure;
-
-public static class Extensions
-{
-    #region Create
-    public static Task<TEntity> CreateAsync<TEntity, TDto>(this IRepository<TEntity> repository, TDto dto, CancellationToken ct = default)
-    {
-        var entity = repository.Mapper.Map(dto);
-        return repository.CreateAsync(entity, ct);
-    }
-
-    public static Task<IEnumerable<TEntity>> CreateAsync<TEntity, TDto>(this IRepository<TEntity> repository, IEnumerable<TDto> dtos, CancellationToken ct = default)
-    {
-        var entities = dtos.Select(dto => repository.Mapper.Map(dto));
-        return repository.CreateAsync(entities, ct);
-    }
-    #endregion
-
-    #region Read
-    public static async Task<TEntity?> ReadFirstOrDefaultAsync<TEntity>(this IRepository<TEntity> repository, Expression<Func<TEntity, bool>>? expression = null)
-        => (await repository.ReadAllAsync(expression)).FirstOrDefault();
-
-    public static async Task<TEntity> ReadFirstAsync<TEntity>(this IRepository<TEntity> repository, Expression<Func<TEntity, bool>>? expression = null)
-        => (await repository.ReadAllAsync(expression)).First();
-
-    public static async Task<TEntity?> ReadSingleOrDefaultAsync<TEntity>(this IRepository<TEntity> repository, Expression<Func<TEntity, bool>>? expression = null)
-        => (await repository.ReadAllAsync(expression)).SingleOrDefault();
-
-    public static async Task<TEntity> ReadSingleAsync<TEntity>(this IRepository<TEntity> repository, Expression<Func<TEntity, bool>>? expression = null)
-        => (await repository.ReadAllAsync(expression)).Single();
-    #endregion
-}

DigitalData.Core.Abstractions/Infrastructure/IRepository.cs

@@ -1,24 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.Core.Abstractions.Infrastructure;
-
-public interface IRepository<TEntity>
-{
-    public IEntityMapper<TEntity> Mapper { get; }
-
-    public Task<TEntity> CreateAsync(TEntity entity, CancellationToken ct = default);
-
-    public Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken ct = default);
-    
-    public Task<IEnumerable<TEntity>> ReadAllAsync(Expression<Func<TEntity, bool>>? expression = null, CancellationToken ct = default);
-
-    public Task<TEntity?> ReadOrDefaultAsync(Expression<Func<TEntity, bool>> expression, bool single = true, CancellationToken ct = default);
-
-    public Task<IEnumerable<TDto>> ReadAllAsync<TDto>(Expression<Func<TEntity, bool>>? expression = null, CancellationToken ct = default);
-
-    public Task<TDto?> ReadOrDefaultAsync<TDto>(Expression<Func<TEntity, bool>> expression, bool single = true, CancellationToken ct = default);
-
-    public Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken ct = default);
-
-    public Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken ct = default);
-}

DigitalData.Core.Abstractions/Interfaces/IDto.cs

@@ -0,0 +1,18 @@
+namespace DigitalData.Core.Abstractions.Interfaces
+#if NET
+    ;
+#elif NETFRAMEWORK
+    {
+#endif
+
+/// <summary>
+/// Ensures that extension methods are handled securely
+/// </summary>
+/// <typeparam name="Entity"></typeparam>
+public interface IDto<Entity> where Entity : IEntity
+{
+}
+
+#if NETFRAMEWORK
+    }
+#endif

DigitalData.Core.Abstractions/Interfaces/IEntity.cs

@@ -0,0 +1,17 @@
+namespace DigitalData.Core.Abstractions.Interfaces
+#if NET
+    ;
+#elif NETFRAMEWORK
+    {
+#endif
+
+/// <summary>
+/// Ensures that extension methods are handled securely
+/// </summary>
+public interface IEntity
+{
+}
+
+#if NETFRAMEWORK
+    }
+#endif

DigitalData.Core.Abstractions/ServiceProviderExtensions.cs

@@ -0,0 +1,33 @@
+#if NET
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace DigitalData.Core.Abstractions;
+
+/// <summary>
+/// Extension methods for <see cref="IServiceProvider"/> to retrieve configuration options.
+/// </summary>
+public static class ServiceProviderExtensions
+{
+    /// <summary>
+    /// Retrieves an instance of <typeparamref name="TOptions"/> from the <see cref="IServiceProvider"/>.
+    /// If the options are not registered, returns null.
+    /// </summary>
+    /// <typeparam name="TOptions">The type of the options to retrieve.</typeparam>
+    /// <param name="service">The service provider instance.</param>
+    /// <returns>An instance of <typeparamref name="TOptions"/> or null if not found.</returns>
+    public static TOptions? GetOptions<TOptions>(this IServiceProvider service) where TOptions : class
+        => service.GetService<IOptions<TOptions>>()?.Value;
+
+    /// <summary>
+    /// Retrieves an instance of <typeparamref name="TOptions"/> from the <see cref="IServiceProvider"/>.
+    /// Throws an exception if the options are not registered.
+    /// </summary>
+    /// <typeparam name="TOptions">The type of the options to retrieve.</typeparam>
+    /// <param name="service">The service provider instance.</param>
+    /// <returns>An instance of <typeparamref name="TOptions"/>.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the options are not registered.</exception>
+    public static TOptions GetRequiredOptions<TOptions>(this IServiceProvider service) where TOptions : class
+        => service.GetRequiredService<IOptions<TOptions>>().Value;
+}
+#endif

DigitalData.Core.Abstractions/ServiceResultExtensions.cs

@@ -1,13 +0,0 @@
-namespace DigitalData.Core.Abstractions
-{
-    public static class ServiceResultExtensions
-    {
-        public static bool Try<T>(this T? nullableResult, out T result)
-        {
-#pragma warning disable CS8601 // Possible null reference assignment.
-            result = nullableResult;
-#pragma warning restore CS8601 // Possible null reference assignment.
-            return nullableResult is not null;
-        }
-    }
-}

DigitalData.Core.Application/BasicCRUDService.cs

@@ -1,7 +1,6 @@
 using AutoMapper;
-using DigitalData.Core.Abstractions;
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.Abstractions.Infrastructure;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.Repository;
 
 namespace DigitalData.Core.Application
 {
@@ -18,9 +17,10 @@ namespace DigitalData.Core.Application
     /// reducing the need for multiple DTOs and simplifying the data mapping process. It leverages AutoMapper for object mapping
     /// and a culture-specific translation service for any necessary text translations, ensuring a versatile and internationalized approach to CRUD operations.
     /// </remarks>
+    [Obsolete("Use MediatR")]
     public class BasicCRUDService<TCRUDRepository, TDto, TEntity, TId> :
         CRUDService<TCRUDRepository, TDto, TDto, TEntity, TId>, IBasicCRUDService<TDto, TEntity, TId>
-         where TCRUDRepository : ICRUDRepository<TEntity, TId> where TDto : class, IUnique<TId> where TEntity : class, IUnique<TId>
+         where TCRUDRepository : ICRUDRepository<TEntity, TId> where TDto : class where TEntity : class
     {
         /// <summary>
         /// Initializes a new instance of the BasicCRUDService with the specified repository, translation service, and AutoMapper configuration.

DigitalData.Core.Application/CRUDService.cs

@@ -1,9 +1,8 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.Abstractions.Infrastructure;
-using AutoMapper;
-using DigitalData.Core.DTO;
-using DigitalData.Core.Abstractions;
+using AutoMapper;
 using Microsoft.Extensions.Logging;
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Abstraction.Application;
 
 namespace DigitalData.Core.Application
 {
@@ -14,8 +13,10 @@ namespace DigitalData.Core.Application
     /// <typeparam name="TReadDto">The DTO type for read operations.</typeparam>
     /// <typeparam name="TEntity">The entity type.</typeparam>
     /// <typeparam name="TId">The type of the identifier for the entity.</typeparam>
+    /// 
+    [Obsolete("Use MediatR")]
     public class CRUDService<TCRUDRepository, TCreateDto, TReadDto, TEntity, TId> : ReadService<TCRUDRepository, TReadDto, TEntity, TId>, ICRUDService<TCreateDto, TReadDto, TEntity, TId>
-        where TCRUDRepository : ICRUDRepository<TEntity, TId> where TCreateDto : class where TReadDto : class where TEntity : class, IUnique<TId>
+        where TCRUDRepository : ICRUDRepository<TEntity, TId> where TCreateDto : class where TReadDto : class where TEntity : class
     {
 
         /// <summary>
@@ -32,11 +33,12 @@ namespace DigitalData.Core.Application
         /// </summary>
         /// <param name="createDto">The DTO to create an entity from.</param>
         /// <returns>A service result indicating success or failure, including the entity DTO.</returns>
-        public virtual async Task<DataResult<TId>> CreateAsync(TCreateDto createDto)
+        public virtual async Task<DataResult<TReadDto>> CreateAsync(TCreateDto createDto)
         {
             var entity = _mapper.Map<TEntity>(createDto);
             var createdEntity = await _repository.CreateAsync(entity);
-            return createdEntity is null ? Result.Fail<TId>() : Result.Success(createdEntity.Id);
+            var dto = _mapper.Map<TReadDto>(createdEntity);
+            return createdEntity is null ? Result.Fail<TReadDto>() : Result.Success(dto);
         }
 
         /// <summary>
@@ -44,12 +46,12 @@ namespace DigitalData.Core.Application
         /// </summary>
         /// <param name="updateDto">The DTO to update an entity from.</param>
         /// <returns>A service message indicating success or failure.</returns>
-        public virtual async Task<Result> UpdateAsync<TUpdateDto>(TUpdateDto updateDto) where TUpdateDto : IUnique<TId>
+        public virtual async Task<Result> UpdateAsync<TUpdateDto>(TUpdateDto updateDto)
         {
-            var currentEntitiy = await _repository.ReadByIdAsync(updateDto.Id);
+            var currentEntitiy = await _repository.ReadByIdAsync(updateDto.GetId<TId>());
 
             if (currentEntitiy is null)
-                return Result.Fail().Notice(LogLevel.Warning, Flag.NotFound, $"{updateDto.Id} is not found in update process of {GetType()} entity.");
+                return Result.Fail().Notice(LogLevel.Warning, Flag.NotFound, $"{updateDto.GetIdOrDefault<TId>()} is not found in update process of {GetType()} entity.");
     
             var entity = _mapper.Map(updateDto, currentEntitiy);
 

DigitalData.Core.Application/DIExtensions.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.Abstraction.Application;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;

DigitalData.Core.Application/DigitalData.Core.Application.csproj

@@ -5,7 +5,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-    <Description>This package provides implementations for application services within the DigitalData.Core.Abstractions library. It includes generic CRUD operations using Entity Framework Core, AutoMapper integration for object mapping, and additional services such as JWT handling and directory search functionality, adhering to Clean Architecture principles to ensure separation of concerns and maintainability.</Description>
+    <Description>This package includes generic CRUD operations using Entity Framework Core, AutoMapper integration for object mapping, and additional services such as JWT handling and directory search functionality, adhering to Clean Architecture principles.</Description>
     <PackageId>DigitalData.Core.Application</PackageId>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
@@ -14,20 +14,19 @@
     <PackageIcon>core_icon.png</PackageIcon>
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <PackageTags>digital data core application clean architecture</PackageTags>
-    <Version>3.2.1</Version>
-    <AssemblyVersion>3.2.1</AssemblyVersion>
-    <FileVersion>3.2.1</FileVersion>
+    <Version>3.4.0</Version>
+    <AssemblyVersion>3.4.0</AssemblyVersion>
+    <FileVersion>3.4.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <None Include="..\..\nuget-package-icons\core_icon.png">
+    <None Include="..\Assets\core_icon.png">
       <Pack>True</Pack>
       <PackagePath>\</PackagePath>
     </None>
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.Localization.Abstractions" Version="7.0.16" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="7.0.0" />
@@ -37,20 +36,26 @@
     <PackageReference Include="System.Security.Cryptography.Cng" Version="5.0.0" />
   </ItemGroup>
 
-	<ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
-		<PackageReference Include="AutoMapper" Version="13.0.1" />
-	</ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+	<PackageReference Include="AutoMapper" Version="13.0.1" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
+  </ItemGroup>
 
-	<ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
-		<PackageReference Include="AutoMapper" Version="14.0.0" />
-	</ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.1" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
+  </ItemGroup>
 
-	<ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
-		<PackageReference Include="AutoMapper" Version="14.0.0" />
-	</ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="9.0.5" />
+	<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.5" />
+  </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
+    <ProjectReference Include="..\DigitalData.Core.Abstraction.Application\DigitalData.Core.Abstraction.Application.csproj" />
   </ItemGroup>
 
 </Project>

DigitalData.Core.Application/DirectorySearchService.cs

@@ -1,10 +1,10 @@
-using DigitalData.Core.Abstractions.Application;
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
 using System.DirectoryServices;
 using Microsoft.Extensions.Caching.Memory;
 using System.DirectoryServices.AccountManagement;
-using DigitalData.Core.DTO;
 using Microsoft.Extensions.Options;
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Abstraction.Application;
 
 namespace DigitalData.Core.Application
 {

DigitalData.Core.Application/JWTService.cs

@@ -1,63 +1,63 @@
-using Microsoft.IdentityModel.Tokens;
+using DigitalData.Core.Abstraction.Application;
+using Microsoft.IdentityModel.Tokens;
 using System.IdentityModel.Tokens.Jwt;
 using System.Security.Cryptography;
 
-namespace DigitalData.Core.Application
+namespace DigitalData.Core.Application;
+
+/// <summary>
+/// Implements the <see cref="IJWTService{TClaimValue}"/> interface to manage JWT operations for claims of type <typeparamref name="TClaimValue"/>.
+/// </summary>
+public class JWTService<TClaimValue> : IJWTService<TClaimValue>
 {
+    private readonly Func<TClaimValue, SecurityTokenDescriptor> _factory;
+
     /// <summary>
-    /// Implements the <see cref="IJWTService{TClaimValue}"/> interface to manage JWT operations for claims of type <typeparamref name="TClaimValue"/>.
+    /// Initializes a new instance of the <see cref="JWTService{TClaimValue}"/> class.
     /// </summary>
-    public class JWTService<TClaimValue> : IJWTService<TClaimValue>
+    /// <param name="tokenDescriptorFactory">A factory function to produce <see cref="SecurityTokenDescriptor"/> based on the claim value.</param>
+    public JWTService(Func<TClaimValue, SecurityTokenDescriptor> tokenDescriptorFactory)
     {
-        private readonly Func<TClaimValue, SecurityTokenDescriptor> _factory;
+        _factory = tokenDescriptorFactory;
+    }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="JWTService{TClaimValue}"/> class.
-        /// </summary>
-        /// <param name="tokenDescriptorFactory">A factory function to produce <see cref="SecurityTokenDescriptor"/> based on the claim value.</param>
-        public JWTService(Func<TClaimValue, SecurityTokenDescriptor> tokenDescriptorFactory)
-        {
-            _factory = tokenDescriptorFactory;
-        }
+    /// <summary>
+    /// Generates a symmetric security key with the specified byte size.
+    /// </summary>
+    /// <param name="byteSize">The size of the security key in bytes. Default is 32 bytes.</param>
+    /// <returns>A new instance of <see cref="SymmetricSecurityKey"/>.</returns>
+    public static SymmetricSecurityKey GenerateSecurityKey(int byteSize = 32)
+    {
+        using var rng = RandomNumberGenerator.Create();
+        var randomBytes = new byte[byteSize];
+        rng.GetBytes(randomBytes);
+        var securityKey = new SymmetricSecurityKey(randomBytes);
 
-        /// <summary>
-        /// Generates a symmetric security key with the specified byte size.
-        /// </summary>
-        /// <param name="byteSize">The size of the security key in bytes. Default is 32 bytes.</param>
-        /// <returns>A new instance of <see cref="SymmetricSecurityKey"/>.</returns>
-        public static SymmetricSecurityKey GenerateSecurityKey(int byteSize = 32)
-        {
-            using var rng = RandomNumberGenerator.Create();
-            var randomBytes = new byte[byteSize];
-            rng.GetBytes(randomBytes);
-            var securityKey = new SymmetricSecurityKey(randomBytes);
+        return securityKey;
+    }
 
-            return securityKey;
-        }
+    /// <summary>
+    /// Generates a JWT for the specified claim value.
+    /// </summary>
+    /// <param name="claimValue">The claim value to encode in the JWT.</param>
+    /// <returns>A JWT as a string.</returns>
+    public string GenerateToken(TClaimValue claimValue)
+    {
+        var tokenDescriptor = _factory(claimValue);
 
-        /// <summary>
-        /// Generates a JWT for the specified claim value.
-        /// </summary>
-        /// <param name="claimValue">The claim value to encode in the JWT.</param>
-        /// <returns>A JWT as a string.</returns>
-        public string GenerateToken(TClaimValue claimValue)
-        {
-            var tokenDescriptor = _factory(claimValue);
+        var tokenHandler = new JwtSecurityTokenHandler();
+        var token = tokenHandler.CreateToken(tokenDescriptor);
+        return tokenHandler.WriteToken(token);
+    }
 
-            var tokenHandler = new JwtSecurityTokenHandler();
-            var token = tokenHandler.CreateToken(tokenDescriptor);
-            return tokenHandler.WriteToken(token);
-        }
-
-        /// <summary>
-        /// Reads and validates a security token from a string representation.
-        /// </summary>
-        /// <param name="token">The JWT to read.</param>
-        /// <returns>A <see cref="JwtSecurityToken"/> if the token is valid; otherwise, null.</returns>
-        public JwtSecurityToken? ReadSecurityToken(string token)
-        {
-            var tokenHandler = new JwtSecurityTokenHandler();
-            return tokenHandler.CanReadToken(token) ? tokenHandler.ReadToken(token) as JwtSecurityToken : null;
-        }
+    /// <summary>
+    /// Reads and validates a security token from a string representation.
+    /// </summary>
+    /// <param name="token">The JWT to read.</param>
+    /// <returns>A <see cref="JwtSecurityToken"/> if the token is valid; otherwise, null.</returns>
+    public JwtSecurityToken? ReadSecurityToken(string token)
+    {
+        var tokenHandler = new JwtSecurityTokenHandler();
+        return tokenHandler.CanReadToken(token) ? tokenHandler.ReadToken(token) as JwtSecurityToken : null;
     }
 }

DigitalData.Core.Application/Key.cs

@@ -1,11 +1,11 @@
-namespace DigitalData.Core.Application
+namespace DigitalData.Core.Application;
+
+[Obsolete("Use MediatR")]
+public static class Key
 {
-    public static class Key
-    {
-        public static readonly string EntityDoesNotExist = "EntityDoesNotExist";
-        public static readonly string ReadFailed = "ReadFailed";
-        public static readonly string UpdateFailed = "UpdateFailed";
-        public static readonly string DeletionFailed = "DeletionFailed";
-        public static readonly string DirSearcherDisconnected = "DirSearcherDisconnected";
-    }
+    public static readonly string EntityDoesNotExist = "EntityDoesNotExist";
+    public static readonly string ReadFailed = "ReadFailed";
+    public static readonly string UpdateFailed = "UpdateFailed";
+    public static readonly string DeletionFailed = "DeletionFailed";
+    public static readonly string DirSearcherDisconnected = "DirSearcherDisconnected";
 }

DigitalData.Core.Application/ReadService.cs

@@ -1,79 +1,78 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.Abstractions.Infrastructure;
-using AutoMapper;
-using DigitalData.Core.DTO;
-using DigitalData.Core.Abstractions;
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Abstraction.Application.Repository;
 
-namespace DigitalData.Core.Application
+namespace DigitalData.Core.Application;
+
+/// <summary>
+/// Provides generic Read (Read and Delete) operations for a specified type of entity.
+/// </summary>
+/// <typeparam name="TReadDto">The DTO type for read operations.</typeparam>
+/// <typeparam name="TEntity">The entity type.</typeparam>
+/// <typeparam name="TId">The type of the identifier for the entity.</typeparam>
+[Obsolete("Use MediatR")]
+public class ReadService<TCRUDRepository, TReadDto, TEntity, TId> : IReadService<TReadDto, TEntity, TId>
+    where TCRUDRepository : ICRUDRepository<TEntity, TId> where TReadDto : class where TEntity : class
 {
+    protected readonly TCRUDRepository _repository;
+    protected readonly IMapper _mapper;
+
     /// <summary>
-    /// Provides generic Read (Read and Delete) operations for a specified type of entity.
+    /// Initializes a new instance of the CRUDService class with the specified repository, translation service, and mapper.
     /// </summary>
-    /// <typeparam name="TReadDto">The DTO type for read operations.</typeparam>
-    /// <typeparam name="TEntity">The entity type.</typeparam>
-    /// <typeparam name="TId">The type of the identifier for the entity.</typeparam>
-    public class ReadService<TCRUDRepository, TReadDto, TEntity, TId> : IReadService<TReadDto, TEntity, TId>
-        where TCRUDRepository : ICRUDRepository<TEntity, TId> where TReadDto : class where TEntity : class, IUnique<TId>
+    /// <param name="repository">The CRUD repository for accessing the database.</param>
+    /// <param name="mapper">The AutoMapper instance for mapping between DTOs and entity objects.</param>
+    public ReadService(TCRUDRepository repository, IMapper mapper)
     {
-        protected readonly TCRUDRepository _repository;
-        protected readonly IMapper _mapper;
-
-        /// <summary>
-        /// Initializes a new instance of the CRUDService class with the specified repository, translation service, and mapper.
-        /// </summary>
-        /// <param name="repository">The CRUD repository for accessing the database.</param>
-        /// <param name="mapper">The AutoMapper instance for mapping between DTOs and entity objects.</param>
-        public ReadService(TCRUDRepository repository, IMapper mapper)
-        {
-            _repository = repository;
-            _mapper = mapper;
-        }
-
-        /// <summary>
-        /// Asynchronously reads an entity by its identifier and maps it to a read DTO.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to read.</param>
-        /// <returns>A service result indicating success or failure, including the read DTO if successful.</returns>
-        public virtual async Task<DataResult<TReadDto>> ReadByIdAsync(TId id)
-        {
-            var entity = await _repository.ReadByIdAsync(id);
-            return entity is null
-                ? Result.Fail<TReadDto>()
-                : Result.Success(_mapper.Map<TReadDto>(entity));
-        }
-
-        /// <summary>
-        /// Asynchronously reads all entities and maps them to read DTOs.
-        /// </summary>
-        /// <returns>A service result including a collection of read DTOs.</returns>
-        public virtual async Task<DataResult<IEnumerable<TReadDto>>> ReadAllAsync()
-        {
-            var entities = await _repository.ReadAllAsync();
-            var readDto = _mapper.Map<IEnumerable<TReadDto>>(entities);
-            return Result.Success(readDto);
-        }
-
-        /// <summary>
-        /// Asynchronously deletes an entity by its identifier.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to delete.</param>
-        /// <returns>A service message indicating success or failure.</returns>
-        public virtual async Task<Result> DeleteAsyncById(TId id)
-        {
-            TEntity? entity = await _repository.ReadByIdAsync(id);
-
-            if (entity is null)
-                return Result.Fail();
-
-            bool isDeleted = await _repository.DeleteAsync(entity);
-            return isDeleted ? Result.Success() : Result.Fail();
-        }
-
-        /// <summary>
-        /// Asynchronously checks if an entity with the specified identifier exists.
-        /// </summary>
-        /// <param name="id">The identifier of the entity to check.</param>
-        /// <returns>A Task that represents the asynchronous operation. The task result contains a boolean value indicating whether the entity exists.</returns>
-        public virtual async Task<bool> HasEntity(TId id) => await _repository.CountAsync(id) > 0;
+        _repository = repository;
+        _mapper = mapper;
     }
+
+    /// <summary>
+    /// Asynchronously reads an entity by its identifier and maps it to a read DTO.
+    /// </summary>
+    /// <param name="id">The identifier of the entity to read.</param>
+    /// <returns>A service result indicating success or failure, including the read DTO if successful.</returns>
+    public virtual async Task<DataResult<TReadDto>> ReadByIdAsync(TId id)
+    {
+        var entity = await _repository.ReadByIdAsync(id);
+        return entity is null
+            ? Result.Fail<TReadDto>()
+            : Result.Success(_mapper.Map<TReadDto>(entity));
+    }
+
+    /// <summary>
+    /// Asynchronously reads all entities and maps them to read DTOs.
+    /// </summary>
+    /// <returns>A service result including a collection of read DTOs.</returns>
+    public virtual async Task<DataResult<IEnumerable<TReadDto>>> ReadAllAsync()
+    {
+        var entities = await _repository.ReadAllAsync();
+        var readDto = _mapper.Map<IEnumerable<TReadDto>>(entities);
+        return Result.Success(readDto);
+    }
+
+    /// <summary>
+    /// Asynchronously deletes an entity by its identifier.
+    /// </summary>
+    /// <param name="id">The identifier of the entity to delete.</param>
+    /// <returns>A service message indicating success or failure.</returns>
+    public virtual async Task<Result> DeleteAsyncById(TId id)
+    {
+        TEntity? entity = await _repository.ReadByIdAsync(id);
+
+        if (entity is null)
+            return Result.Fail();
+
+        bool isDeleted = await _repository.DeleteAsync(entity);
+        return isDeleted ? Result.Success() : Result.Fail();
+    }
+
+    /// <summary>
+    /// Asynchronously checks if an entity with the specified identifier exists.
+    /// </summary>
+    /// <param name="id">The identifier of the entity to check.</param>
+    /// <returns>A Task that represents the asynchronous operation. The task result contains a boolean value indicating whether the entity exists.</returns>
+    public virtual async Task<bool> HasEntity(TId id) => await _repository.CountAsync(id) > 0;
 }

DigitalData.Core.Client/BaseHttpClientService.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstractions.Client;
+using DigitalData.Core.Client.Interface;
 using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using System.Web;

DigitalData.Core.Client/DIExtensions.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstractions.Client;
+using DigitalData.Core.Client.Interface;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;

DigitalData.Core.Client/DigitalData.Core.Client.csproj

@@ -6,7 +6,6 @@
     <Nullable>enable</Nullable>
     <Description>This package provides HTTP client extension methods for the DigitalData.Core library, offering simplified and asynchronous methods for fetching and handling HTTP responses. It includes utility methods for sending GET requests, reading response content as text or JSON, and deserializing JSON into dynamic or strongly-typed objects using Newtonsoft.Json. These extensions facilitate efficient and easy-to-read HTTP interactions in client applications.</Description>
     <PackageId>DigitalData.Core.Client</PackageId>
-    <Version>2.0.3</Version>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
     <Product>Digital Data GmbH</Product>
@@ -15,8 +14,9 @@
     <PackageIcon>core_icon.png</PackageIcon>
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <PackageTags>digital data core http client json serilization</PackageTags>
-    <AssemblyVersion>2.0.3</AssemblyVersion>
-    <FileVersion>2.0.3</FileVersion>
+    <Version>2.1.0</Version>
+    <AssemblyVersion>2.1.0</AssemblyVersion>
+    <FileVersion>2.1.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -26,13 +26,27 @@
     </None>
   </ItemGroup>
 
-  <ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.1" />
     <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="7.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="8.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="9.0.5" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="9.0.5" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
   </ItemGroup>

DigitalData.Core.Client/HttpClientService.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstractions.Client;
+using DigitalData.Core.Client.Interface;
 using Microsoft.Extensions.Options;
 using System.Net;
 

DigitalData.Core.Client/Interface/IBaseHttpClientService.cs

@@ -1,6 +1,6 @@
 using System.Net;
 
-namespace DigitalData.Core.Abstractions.Client
+namespace DigitalData.Core.Client.Interface
 {
     public interface IBaseHttpClientService
     {

DigitalData.Core.Client/Interface/IHttpClientOptions.cs

@@ -1,4 +1,4 @@
-namespace DigitalData.Core.Abstractions.Client
+namespace DigitalData.Core.Client.Interface
 {
     public interface IHttpClientOptions
     {

DigitalData.Core.Client/Interface/IHttpClientService.cs

@@ -1,4 +1,4 @@
-namespace DigitalData.Core.Abstractions.Client
+namespace DigitalData.Core.Client.Interface
 {
     public interface IHttpClientService<TClientOptions> : IBaseHttpClientService where TClientOptions : IHttpClientOptions
     {

DigitalData.Core.Client/ServiceFactory.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstractions.Client;
+using DigitalData.Core.Client.Interface;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DigitalData.Core.Client

DigitalData.Core.Exceptions.Middleware/DependencyInjection.cs

@@ -0,0 +1,26 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace DigitalData.Core.Exceptions.Middleware;
+
+public static class DependencyInjection
+{
+    public static IServiceCollection ConfigureGlobalExceptionHandler(this IServiceCollection services, Action<GlobalExceptionHandlerOptions>? options = null, bool addDefaultHandlers = true)
+    {
+        options ??= opt => { };
+
+        if (addDefaultHandlers)
+        {
+            options += opt => opt.Add(HttpExceptionHandler.Default, setAsDefault: true);
+            options += opt => opt.Add(HttpExceptionHandler.DefaultBadRequest);
+            options += opt => opt.Add(HttpExceptionHandler.DefaultNotFound);
+        }
+        return services.Configure(options);
+    }
+
+    public static IApplicationBuilder UseGlobalExceptionHandler(this IApplicationBuilder app)
+    {
+        app.UseMiddleware<GlobalExceptionHandlerMiddleware>();
+        return app;
+    }
+}

DigitalData.Core.Exceptions.Middleware/DigitalData.Core.Exceptions.Middleware.csproj

@@ -0,0 +1,50 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net7.0;net8.0;net9.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+	  <!-- NuGet Package Metadata -->
+	  <PackageId>DigitalData.Core.Exceptions.Middleware</PackageId>
+	  <Authors>Digital Data GmbH</Authors>
+	  <Company>Digital Data GmbH</Company>
+	  <Product>DigitalData.Core.Exceptions.Middleware</Product>
+      <Description>Provides middleware components for standardized exception handling and error response formatting in ASP.NET Core applications.</Description>
+	  <PackageTags>digital data core exceptions middleware</PackageTags>
+	  <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+	  <Copyright>Copyright 2025</Copyright>
+	  <PackageProjectUrl></PackageProjectUrl>
+	  <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
+	  <PackAsTool>False</PackAsTool>
+	  <PackageIcon>core_icon.png</PackageIcon>
+	  <Version>1.0.1</Version>
+	  <AssemblyVersion>1.0.1</AssemblyVersion>
+	  <FileVersion>1.0.1</FileVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+	  <None Include="..\Assets\core_icon.png">
+		  <Pack>True</Pack>
+		  <PackagePath>\</PackagePath>
+	  </None>
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+    <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.1" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+	<PackageReference Include="Microsoft.Extensions.Options" Version="8.0.2" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+	<PackageReference Include="Microsoft.Extensions.Options" Version="9.0.5" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.3.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.7" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DigitalData.Core.Exceptions\DigitalData.Core.Exceptions.csproj" />
+  </ItemGroup>
+
+</Project>

DigitalData.Core.Exceptions.Middleware/GlobalExceptionHandlerMiddleware.cs

@@ -0,0 +1,52 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace DigitalData.Core.Exceptions.Middleware;
+
+/// <summary>
+/// Middleware for handling exceptions globally in the application.
+/// Captures exceptions thrown during the request pipeline execution,
+/// logs them, and returns an appropriate HTTP response with a JSON error message.
+/// </summary>
+public class GlobalExceptionHandlerMiddleware
+{
+    private readonly RequestDelegate _next;
+
+    private readonly ILogger<GlobalExceptionHandlerMiddleware>? _logger;
+
+    private readonly GlobalExceptionHandlerOptions? _options;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="GlobalExceptionHandlerMiddleware"/> class.
+    /// </summary>
+    /// <param name="next">The next middleware in the request pipeline.</param>
+    /// <param name="logger">The logger instance for logging exceptions.</param>
+    public GlobalExceptionHandlerMiddleware(RequestDelegate next, ILogger<GlobalExceptionHandlerMiddleware>? logger = null, IOptions<GlobalExceptionHandlerOptions>? options = null)
+    {
+        _next = next;
+        _logger = logger;
+        _options = options?.Value;
+    }
+
+    /// <summary>
+    /// Invokes the middleware to handle the HTTP request.
+    /// </summary>
+    /// <param name="context">The HTTP context of the current request.</param>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    public async Task InvokeAsync(HttpContext context)
+    {
+        try
+        {
+            await _next(context); // Continue down the pipeline
+        }
+        catch (Exception ex)
+        {
+            if(ex.GetType() == typeof(Exception) && _options?.DefaultHandler is not null)
+                await _options.DefaultHandler.HandleExceptionAsync(context, ex, _logger);
+
+            if (_options?.Handlers.TryGetValue(ex.GetType(), out var handler) ?? false)
+                await handler.HandleExceptionAsync(context, ex, _logger);
+        }
+    }
+}

DigitalData.Core.Exceptions.Middleware/GlobalExceptionHandlerOptions.cs

@@ -0,0 +1,17 @@
+namespace DigitalData.Core.Exceptions.Middleware;
+
+public class GlobalExceptionHandlerOptions
+{
+    internal readonly Dictionary<Type, HttpExceptionHandler> Handlers = new();
+
+    internal HttpExceptionHandler? DefaultHandler { get; private set; }
+
+    public GlobalExceptionHandlerOptions Add(HttpExceptionHandler handler, bool setAsDefault = false)
+    {
+        if (setAsDefault)
+            DefaultHandler = handler;
+        else
+            Handlers[handler.ExceptionType] = handler;
+        return this;
+    }
+}

DigitalData.Core.Exceptions.Middleware/HttpExceptionHandler.cs

@@ -0,0 +1,42 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using System.Net;
+using System.Text.Json;
+
+namespace DigitalData.Core.Exceptions.Middleware;
+
+public record HttpExceptionHandler(Type ExceptionType, Func<HttpContext, Exception, ILogger?, Task> HandleExceptionAsync)
+{
+    #region Alternative generator methods
+    public static HttpExceptionHandler Create<TException>(Func<HttpContext, Exception, ILogger?, Task> HandleExceptionAsync) where TException : Exception
+        => new HttpExceptionHandler(typeof(TException), HandleExceptionAsync);
+
+    public static HttpExceptionHandler Create<TException>(HttpStatusCode statusCode, Func<Exception, string> messageFactory) where TException : Exception
+        => Create<TException>(
+        async (context, ex, logger) =>
+        {
+            context.Response.ContentType = "application/json";
+            context.Response.StatusCode = (int)statusCode;
+            var message = messageFactory(ex);
+            await context.Response.WriteAsync(JsonSerializer.Serialize(new { message }));
+        }
+    );
+    #endregion
+
+    #region Default handlers
+    public static readonly Func<Exception, string> DefaultMessageFactory = ex => ex.Message;
+
+    public static HttpExceptionHandler DefaultBadRequest => Create<BadRequestException>(HttpStatusCode.BadRequest, DefaultMessageFactory);
+
+    public static HttpExceptionHandler DefaultNotFound => Create<NotFoundException>(HttpStatusCode.NotFound, DefaultMessageFactory);
+
+    public static HttpExceptionHandler Default => Create<Exception>(
+        async (context, ex, logger) =>
+        {
+            context.Response.ContentType = "application/json";
+            context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
+            var message = "An unexpected error occurred.";
+            await context.Response.WriteAsync(JsonSerializer.Serialize(new { message }));
+        });
+    #endregion
+};

DigitalData.Core.Exceptions/BadRequestException.cs

@@ -0,0 +1,22 @@
+namespace DigitalData.Core.Exceptions;
+
+/// <summary>
+/// Represents an exception that is thrown when a bad request is encountered.
+/// </summary>
+public class BadRequestException : Exception
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BadRequestException"/> class.
+    /// </summary>
+    public BadRequestException()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BadRequestException"/> class with a specified error message.
+    /// </summary>
+    /// <param name="message">The message that describes the error.</param>
+    public BadRequestException(string? message) : base(message)
+    {
+    }
+}

DigitalData.Core.Exceptions/DigitalData.Core.Exceptions.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net7.0;net8.0;net9.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+	<!-- NuGet Package Metadata -->
+	<PackageId>DigitalData.Core.Exceptions</PackageId>
+	<Authors>Digital Data GmbH</Authors>
+	<Company>Digital Data GmbH</Company>
+	<Product>DigitalData.Core.Exceptions</Product>
+	<Description>This package contains exceptions for the DigitalData.Core library</Description>
+	<PackageTags>digital data core exceptions</PackageTags>
+	<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+	<Copyright>Copyright 2025</Copyright>
+	<PackageProjectUrl></PackageProjectUrl>
+	<RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
+	<PackAsTool>False</PackAsTool>
+	<PackageIcon>core_icon.png</PackageIcon>
+	<Version>1.1.0</Version>
+	<AssemblyVersion>1.1.0</AssemblyVersion>
+	<FileVersion>1.1.0</FileVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\Assets\core_icon.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+</Project>

DigitalData.Core.Exceptions/ForbiddenException.cs

@@ -0,0 +1,24 @@
+namespace DigitalData.Core.Exceptions;
+
+/// <summary>
+/// Represents an exception thrown when an operation is forbidden.
+/// Typically used to indicate lack of permission or access rights.
+/// </summary>
+public class ForbiddenException : Exception
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ForbiddenException"/> class.
+    /// </summary>
+    public ForbiddenException()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ForbiddenException"/> class with a specified error message.
+    /// </summary>
+    /// <param name="message">The message that describes the error.</param>
+    public ForbiddenException(string? message)
+        : base(message)
+    {
+    }
+}

DigitalData.Core.Exceptions/NotFoundException.cs

@@ -0,0 +1,22 @@
+namespace DigitalData.Core.Exceptions;
+
+/// <summary>
+/// Represents an exception that is thrown when a requested resource is not found.
+/// </summary>
+public class NotFoundException : Exception
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="NotFoundException"/> class.
+    /// </summary>
+    public NotFoundException()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="NotFoundException"/> class with a specified error message.
+    /// </summary>
+    /// <param name="message">The message that describes the error.</param>
+    public NotFoundException(string? message) : base(message)
+    {
+    }
+}

DigitalData.Core.Infrastructure.AutoMapper/DigitalData.Core.Infrastructure.AutoMapper.csproj

@@ -6,7 +6,6 @@
     <Nullable>enable</Nullable>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <PackageId>DigitalData.Core.Infrastructure.AutoMapper</PackageId>
-    <Version>1.0.2</Version>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
     <Product>DigitalData.Core.Infrastructure.AutoMapper</Product>
@@ -16,8 +15,9 @@
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <RepositoryType>digital data core abstractions clean architecture mapping</RepositoryType>
     <PackageTags>digital data core infrastructure clean architecture mapping</PackageTags>
-    <AssemblyVersion>1.0.2</AssemblyVersion>
-    <FileVersion>1.0.2</FileVersion>
+	<Version>1.0.3</Version>
+    <AssemblyVersion>1.0.3</AssemblyVersion>
+    <FileVersion>1.0.3</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -28,7 +28,6 @@
   </ItemGroup>
 	
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
     <ProjectReference Include="..\DigitalData.Core.Infrastructure\DigitalData.Core.Infrastructure.csproj" />
   </ItemGroup>
 

DigitalData.Core.Infrastructure.AutoMapper/EntityAutoMapper.cs

@@ -1,5 +1,5 @@
 using AutoMapper;
-using DigitalData.Core.Abstractions.Infrastructure;
+using DigitalData.Core.Abstraction.Application.Repository;
 
 namespace DigitalData.Core.Infrastructure.AutoMapper;
 

DigitalData.Core.Infrastructure/CRUDRepository.cs

@@ -1,5 +1,6 @@
-using DigitalData.Core.Abstractions;
-using DigitalData.Core.Abstractions.Infrastructure;
+#if NET
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.Repository;
 using Microsoft.EntityFrameworkCore;
 
 namespace DigitalData.Core.Infrastructure
@@ -14,8 +15,9 @@ namespace DigitalData.Core.Infrastructure
     /// This repository abstracts the common database operations, offering an asynchronous API to work with the entity's data.
     /// It leverages the EF Core's DbContext and DbSet to perform these operations.
     /// </remarks>
+    [Obsolete("Use Repository")]
     public class CRUDRepository<TEntity, TId, TDbContext> : ICRUDRepository<TEntity, TId>
-        where TEntity : class, IUnique<TId>
+        where TEntity : class
         where TDbContext : DbContext
     {
         protected readonly TDbContext _dbContext;
@@ -107,6 +109,7 @@ namespace DigitalData.Core.Infrastructure
         /// If there are multiple entities with the same identifier, they will all be counted. 
         /// The default implementation assumes that the identifier is unique for each entity.
         /// </remarks>
-        public virtual async Task<int> CountAsync(TId id) => await _dbSet.Where(e => e.Id!.Equals(id)).CountAsync();
+        public virtual async Task<int> CountAsync(TId id) => await _dbSet.Where(e => e.GetId().Equals(id)).CountAsync();
     }
-}
+}
+#endif

DigitalData.Core.Infrastructure/DbRepository.cs

@@ -1,79 +1,137 @@
-using DigitalData.Core.Abstractions.Infrastructure;
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Abstractions.Interfaces;
+using DigitalData.Core.Infrastructure.Factory;
 using Microsoft.EntityFrameworkCore;
 using System.Linq.Expressions;
+using Microsoft.Extensions.DependencyInjection;
 
-namespace DigitalData.Core.Infrastructure;
+#if NETFRAMEWORK
+using System.Collections.Generic;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+#endif
 
-public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbContext : DbContext where TEntity : class
-{
-    protected internal readonly TDbContext Context;
-
-    protected internal readonly DbSet<TEntity> Entities;
-
-    public IEntityMapper<TEntity> Mapper { get; }
-
-    public DbRepository(TDbContext context, Func<TDbContext, DbSet<TEntity>> queryFactory, IEntityMapper<TEntity> mapper)
+namespace DigitalData.Core.Infrastructure
+#if NET
+    ;
+#elif NETFRAMEWORK
     {
-        Context = context;
-        Entities = queryFactory(context);
-        Mapper = mapper;
-    }
+#endif
 
-    public virtual async Task<TEntity> CreateAsync(TEntity entity, CancellationToken ct = default)
+    public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbContext : DbContext where TEntity : class
     {
-        Entities.Add(entity);
-        await Context.SaveChangesAsync(ct);
-        return entity;
-    }
+        protected internal readonly TDbContext Context;
 
-    public virtual async Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken ct = default)
-    {
-        Entities.AddRange(entities);
-        await Context.SaveChangesAsync(ct);
-        return entities;
-    }
+        protected internal readonly DbSet<TEntity> Entities;
 
-    public virtual async Task<IEnumerable<TEntity>> ReadAllAsync(Expression<Func<TEntity, bool>>? expression = null, CancellationToken ct = default)
-        => expression is null
-            ? await Entities.AsNoTracking().ToListAsync(ct)
-            : await Entities.AsNoTracking().Where(expression).ToListAsync(ct);
+        public IMapper
+#if NET
+        ?
+#endif
+            Mapper { get; }
 
-    public virtual async Task<TEntity?> ReadOrDefaultAsync(Expression<Func<TEntity, bool>> expression, bool single = true, CancellationToken ct = default)
-        => single 
-            ? await Entities.AsNoTracking().Where(expression).SingleOrDefaultAsync(ct)
-            : await Entities.AsNoTracking().Where(expression).FirstOrDefaultAsync(ct);
-
-    public virtual async Task<IEnumerable<TDto>> ReadAllAsync<TDto>(Expression<Func<TEntity, bool>>? expression = null, CancellationToken ct = default)
-        => Mapper.Map<TDto>(await ReadAllAsync(expression, ct));
-
-    public virtual async Task<TDto?> ReadOrDefaultAsync<TDto>(Expression<Func<TEntity, bool>> expression, bool single = true, CancellationToken ct = default)
-    {
-        var entity = await ReadOrDefaultAsync(expression, single, ct);
-        return entity is null ? default : Mapper.Map<TDto>(entity);
-    }
-
-    public virtual async Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken ct = default)
-    {
-        var entities = await Entities.Where(expression).ToListAsync(ct);
-
-        for (int i = entities.Count - 1; i >= 0; i--)
+        public DbRepository(TDbContext context, DbSetFactory<TDbContext, TEntity> factory, IMapper
+#if NET
+        ?
+#endif
+            mapper = null)
         {
-            Mapper.Map(dto, entities[i]);
-            Entities.Update(entities[i]);
+            Context = context;
+            Entities = factory.Create(context);
+            Mapper = mapper;
         }
 
-        await Context.SaveChangesAsync(ct);
-    }
-
-    public virtual async Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken ct = default)
-    {
-        var entities = await Entities.Where(expression).ToListAsync(ct);
-
-        for (int i = entities.Count - 1; i >= 0; i--)
+        #region Create
+        public virtual async Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default)
         {
-            Entities.Remove(entities[i]);
+            Entities.Add(entity);
+            await Context.SaveChangesAsync(cancel);
+            return entity;
         }
 
-        await Context.SaveChangesAsync(ct);
+        public virtual async Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default)
+        {
+            Entities.AddRange(entities);
+            await Context.SaveChangesAsync(cancel);
+            return entities;
+        }
+
+        public virtual Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default)
+            => CreateAsync(Mapper
+#if NET
+            !
+#endif
+                .Map<TEntity>(dto), cancel);
+
+        public virtual Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default)
+            => CreateAsync(Mapper
+#if NET
+            !
+#endif
+                .Map<IEnumerable<TEntity>>(dtos), cancel);
+        #endregion Create
+
+        #region Read
+        public virtual IQueryable<TEntity> Query => Entities.AsNoTracking();
+
+        public virtual IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression) => Entities.AsNoTracking().Where(expression);
+
+        public virtual IEnumerable<TEntity> GetAll() => Entities.AsNoTracking().ToList();
+
+        public virtual async Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancel = default) => await Entities.AsNoTracking().ToListAsync(cancel);
+        #endregion Read
+
+        #region Update
+        public virtual Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default) => UpdateAsync(dto, q => q.Where(expression), cancel);
+
+        public virtual Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
+            => UpdateAsync(entity => Mapper
+#if NET
+                                            !
+#endif
+                                            .Map(dto, entity), query, cancel);
+
+        public virtual async Task UpdateAsync(Action<TEntity> modification, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
+        {
+            var entities = await query(Entities).ToListAsync(cancel);
+
+            for (int i = entities.Count - 1; i >= 0; i--)
+                modification.Invoke(entities[i]);
+
+            await Context.SaveChangesAsync(cancel);
+        }
+
+        public virtual Task UpdateAsync(Action<TEntity> modification, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default)
+            => UpdateAsync(modification, q => q.Where(expression), cancel);
+        #endregion Update
+
+        #region Delete
+        public virtual Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default) => DeleteAsync(q => q.Where(expression), cancel);
+
+        public virtual async Task DeleteAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
+        {
+            var entities = await query(Entities).ToListAsync(cancel);
+
+            for (int i = entities.Count - 1; i >= 0; i--)
+            {
+                Entities.Remove(entities[i]);
+            }
+
+            await Context.SaveChangesAsync(cancel);
+        }
+        #endregion Delete
+
+        #region Obsolete
+        [Obsolete("Use IRepository<TEntity>.Where")]
+        public virtual IQueryable<TEntity> Read() => Entities.AsQueryable();
+
+        [Obsolete("Use IRepository<TEntity>.Get")]
+        public virtual IQueryable<TEntity> ReadOnly() => Entities.AsNoTracking();
+        #endregion
     }
-}
+#if NETFRAMEWORK
+    }
+#endif

DigitalData.Core.Infrastructure/DependencyInjection.cs

@@ -1,19 +1,145 @@
-using DigitalData.Core.Abstractions.Infrastructure;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Infrastructure.Factory;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Reflection;
+#if NETFRAMEWORK
+using System.Collections.Generic;
+using System;
+using System.Linq;
+#endif
 
-namespace DigitalData.Core.Infrastructure;
+namespace DigitalData.Core.Infrastructure
+#if NET
+    ;
+#elif NETFRAMEWORK
+    {
+#endif
 
 public static class DependencyInjection
 {
-    public static EntityConfigurationOptions<TEntity> AddDbRepository<TDbContext, TEntity>(this IServiceCollection services, Func<TDbContext, DbSet<TEntity>> queryFactory)
+    public static IServiceCollection AddDbRepository(this IServiceCollection services, Action<RepositoryConfiguration> options)
+    {
+        // register services from configuration
+        var cfg = new RepositoryConfiguration();
+        options.Invoke(cfg);
+        cfg.RegisterAllServices(services);
+
+        return services;
+    }
+
+    public class RepositoryConfiguration
+    {
+        // 1. register from assembly
+        private readonly Queue<Action<IServiceCollection>> RegsFromAssembly = new Queue<Action<IServiceCollection>>();
+
+        // 2. register entities (can overwrite)
+        private readonly Queue<Action<IServiceCollection>> RegsEntity = new Queue<Action<IServiceCollection>>();
+
+        // 3. register db set factories (can overwrite)
+        private readonly Queue<Action<IServiceCollection>> RegsDbSetFactory = new Queue<Action<IServiceCollection>>();
+
+        internal void RegisterAllServices(IServiceCollection services)
+        {
+            // 1. register from assembly
+            RegsFromAssembly.InvokeAll(services);
+
+            // 2. register entities (can overwrite)
+            RegsEntity.InvokeAll(services);
+
+            // 3. register db set factories (can overwrite)
+            RegsDbSetFactory.InvokeAll(services);
+        }
+
+        internal RepositoryConfiguration() { }
+
+        public void RegisterFromAssembly<TDbContext>(Assembly assembly) where TDbContext : DbContext
+        {
+            void reg(IServiceCollection services)
+            {
+                // scan all types in the Assembly
+                var entityTypes = assembly.GetTypes()
+                    .Where(t => t.IsClass && !t.IsAbstract && t.GetCustomAttribute<TableAttribute>() != null);
+
+                foreach (var entityType in entityTypes)
+                {
+                    #region Repository
+                    /// register repository
+                    // create generic DbRepository<DbContext, TEntity> type
+                    var repositoryType = typeof(DbRepository<,>).MakeGenericType(typeof(TDbContext), entityType);
+                    var interfaceType = typeof(IRepository<>).MakeGenericType(entityType);
+
+                    // add into DI container as Scoped
+                    services.AddScoped(interfaceType, repositoryType);
+                    #endregion Repository
+
+                    #region DbSetFactory
+                    /// register DbSetFactory
+                    var addDbSetFactoryMethod = typeof(DependencyInjection)
+                        .GetMethod(nameof(AddDbSetFactory),
+                                   BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+
+                    var genericMethod = addDbSetFactoryMethod
+#if NET
+                                        !
+#endif
+                                        .MakeGenericMethod(typeof(TDbContext), entityType);
+                    genericMethod.Invoke(null, new [] { services, null });
+                    #endregion DbSetFactory
+                }
+            }
+
+            RegsFromAssembly.Enqueue(reg);
+        }
+
+        public void RegisterEntity<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>>
+#if NET
+            ?
+#endif
+            dbSetFactory = null)
+            where TDbContext : DbContext
+            where TEntity : class
+        {
+            void reg(IServiceCollection services)
+                => services
+                    .AddScoped<IRepository<TEntity>, DbRepository<TDbContext, TEntity>>()
+                    .AddDbSetFactory(dbSetFactory);
+
+            RegsEntity.Enqueue(reg);
+        }
+
+        public void RegisterDbSetFactory<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>> dbSetFactory)
+            where TDbContext : DbContext
+            where TEntity : class
+            => RegsDbSetFactory.Enqueue(s => s.AddDbSetFactory(dbSetFactory));
+    }
+
+    private static void InvokeAll<T>(this Queue<Action<T>> queue, T services)
+    {
+        while (queue.Count > 0)
+            queue.Dequeue().Invoke(services);
+    }
+
+    internal static IServiceCollection AddDbSetFactory<TDbContext, TEntity>(this IServiceCollection services, Func<TDbContext, DbSet<TEntity>>
+#if NET
+        ?
+#endif
+        create = null)
         where TDbContext : DbContext
         where TEntity : class
     {
-        services
-            .AddScoped<IRepository<TEntity>, DbRepository<TDbContext, TEntity>>()
-            .AddSingleton(queryFactory);
-
-        return new EntityConfigurationOptions<TEntity>(services);
+#if NET
+        create ??= ctx => ctx.Set<TEntity>();
+#elif NETFRAMEWORK
+        if(create is null)
+            create = ctx => ctx.Set<TEntity>();
+#endif
+        services.AddSingleton(_ => new DbSetFactory<TDbContext, TEntity>(create));
+        return services;
     }
-}
+}
+
+#if NETFRAMEWORK
+    }
+#endif

DigitalData.Core.Infrastructure/DigitalData.Core.Infrastructure.csproj

@@ -1,32 +1,48 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net7.0;net8.0;net9.0</TargetFrameworks>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
+    <TargetFrameworks>net462;net7.0;net8.0;net9.0</TargetFrameworks>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <PackageId>DigitalData.Core.Infrastructure</PackageId>
-    <Version>2.0.4</Version>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
     <Product>DigitalData.Core.Infrastructure</Product>
-    <Description>This package provides implementations for data access and other low-level services within the DigitalData.Core.Abstractions library. It includes generic CRUD operations using Entity Framework Core, database context management, and other infrastructure-related functionalities, adhering to Clean Architecture principles to ensure separation of concerns and maintainability.</Description>
+    <Description>This package provides implementations for data access and other low-level services within the DigitalData.Core.Application library. It includes generic CRUD operations using Entity Framework Core, database context management, and other infrastructure-related functionalities, adhering to Clean Architecture principles.</Description>
     <Copyright>Copyright 2024</Copyright>
     <PackageIcon>core_icon.png</PackageIcon>
     <RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
     <RepositoryType>digital data core abstractions clean architecture</RepositoryType>
     <PackageTags>digital data core infrastructure clean architecture</PackageTags>
-    <AssemblyVersion>2.0.4</AssemblyVersion>
-    <FileVersion>2.0.4</FileVersion>
+    <Version>2.5.2</Version>
+    <AssemblyVersion>2.5.2</AssemblyVersion>
+    <FileVersion>2.5.2</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <None Include="..\..\nuget-package-icons\core_icon.png">
+    <None Include="..\Assets\core_icon.png">
       <Pack>True</Pack>
       <PackagePath>\</PackagePath>
     </None>
   </ItemGroup>
 
+  <!-- disable for net462 -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net462'">
+	<Nullable>disable</Nullable>
+	<ImplicitUsings>disable</ImplicitUsings>
+	<LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+
+  <!-- enable for net7 and more -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net7.0' Or '$(TargetFramework)' == 'net8.0' Or '$(TargetFramework)' == 'net9.0'">
+	<Nullable>enable</Nullable>
+	<ImplicitUsings>enable</ImplicitUsings>
+	<LangVersion>latest</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
+	<PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.32" />
+  </ItemGroup>
+
   <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.20" />
   </ItemGroup>
@@ -36,11 +52,11 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.5" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\DigitalData.Core.Abstractions\DigitalData.Core.Abstractions.csproj" />
+    <ProjectReference Include="..\DigitalData.Core.Abstraction.Application\DigitalData.Core.Abstraction.Application.csproj" />
   </ItemGroup>
 
   <ItemGroup>

DigitalData.Core.Infrastructure/EntityConfigurationOptions.cs

@@ -1,27 +0,0 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace DigitalData.Core.Infrastructure;
-
-public class EntityConfigurationOptions<TEntity>
-{
-    private readonly IServiceCollection _services;
-
-    public EntityConfigurationOptions(IServiceCollection services)
-    {
-        _services = services;
-    }
-
-    public EntityConfigurationOptions<TEntity> AddCustomMapper<TEntityMapper>(Action<IServiceCollection> configure, Func<IServiceProvider, TEntityMapper>? factory = null)
-        where TEntityMapper : class, IEntityMapper<TEntity>
-    {
-        configure(_services);
-
-        if (factory is null)
-            _services.AddSingleton<IEntityMapper<TEntity>, TEntityMapper>();
-        else
-            _services.AddSingleton(factory);
-        
-        return this;
-    }
-}

DigitalData.Core.Infrastructure/Factory/DbSetFactory.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore;
+#if NETFRAMEWORK
+using System;
+#endif
+
+namespace DigitalData.Core.Infrastructure.Factory
+#if NET
+    ;
+#elif NETFRAMEWORK
+    {
+#endif
+
+public class DbSetFactory<TDbContext,TEntity> where TDbContext : DbContext where TEntity : class
+{
+    public readonly Func<TDbContext, DbSet<TEntity>> Create;
+
+    public DbSetFactory(Func<TDbContext, DbSet<TEntity>> create)
+    {
+        Create = create;
+    }
+}
+
+#if NETFRAMEWORK
+    }
+#endif

DigitalData.Core.Tests/Abstractions/FactoryTests.cs

@@ -0,0 +1,173 @@
+using Microsoft.Extensions.DependencyInjection;
+using DigitalData.Core.Abstractions;
+
+namespace DigitalData.Core.Tests.Abstractions
+{
+    [TestFixture]
+    public class FactoryTests
+    {
+        private Factory _factory;
+
+        [SetUp]
+        public void Setup()
+        {
+            _factory = new Factory();
+        }
+
+        [Test]
+        public void Add_ServiceDescriptor_ShouldIncreaseCount()
+        {
+            // Arrange
+            var descriptor = ServiceDescriptor.Singleton(typeof(string), "test");
+
+            // Act
+            _factory.Add(descriptor);
+
+            // Assert
+            Assert.That(_factory.Count, Is.EqualTo(1));
+            Assert.That(_factory.Contains(descriptor), Is.True);
+        }
+
+        [Test]
+        public void Clear_ShouldRemoveAllServices()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "test"));
+            _factory.Add(ServiceDescriptor.Singleton(typeof(int), 42));
+
+            // Act
+            _factory.Clear();
+
+            // Assert
+            Assert.That(_factory.Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GetService_ShouldReturnRegisteredInstance()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "Hello World"));
+
+            // Act
+            var result = _factory.GetService(typeof(string));
+
+            // Assert
+            Assert.That(result, Is.EqualTo("Hello World"));
+        }
+
+        [Test]
+        public void GetService_UnregisteredType_ShouldReturnNull()
+        {
+            // Act
+            var result = _factory.GetService(typeof(int));
+
+            // Assert
+            Assert.That(result, Is.Null);
+        }
+
+        [Test]
+        public void ModifyAfterBuild_ShouldThrowInvalidOperationException()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "x"));
+            var _ = _factory.GetService(typeof(string)); // trigger build
+
+            // Act & Assert
+            Assert.Throws<InvalidOperationException>(() => _factory.Add(ServiceDescriptor.Singleton(typeof(int), 1)));
+        }
+
+        [Test]
+        public void Remove_ShouldWorkBeforeBuild()
+        {
+            // Arrange
+            var descriptor = ServiceDescriptor.Singleton(typeof(string), "Test");
+            _factory.Add(descriptor);
+
+            // Act
+            var removed = _factory.Remove(descriptor);
+
+            // Assert
+            Assert.That(removed, Is.True);
+            Assert.That(_factory.Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void Insert_ShouldInsertAtCorrectIndex()
+        {
+            // Arrange
+            var d1 = ServiceDescriptor.Singleton(typeof(string), "A");
+            var d2 = ServiceDescriptor.Singleton(typeof(int), 1);
+
+            _factory.Add(d1);
+            _factory.Insert(0, d2);
+
+            // Act
+            var first = _factory[0];
+
+            // Assert
+            Assert.That(first.ServiceType, Is.EqualTo(typeof(int)));
+        }
+
+        [Test]
+        public void Enumerator_ShouldIterateOverServices()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "a"));
+            _factory.Add(ServiceDescriptor.Singleton(typeof(int), 5));
+
+            // Act
+            var list = _factory.ToList();
+
+            // Assert
+            Assert.That(list.Count, Is.EqualTo(2));
+            Assert.That(list.Any(sd => sd.ServiceType == typeof(string)), Is.True);
+            Assert.That(list.Any(sd => sd.ServiceType == typeof(int)), Is.True);
+        }
+
+        [Test]
+        public void CopyTo_ShouldCopyElements()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "x"));
+            _factory.Add(ServiceDescriptor.Singleton(typeof(int), 10));
+            var array = new ServiceDescriptor[2];
+
+            // Act
+            _factory.CopyTo(array, 0);
+
+            // Assert
+            Assert.That(array[0].ServiceType, Is.EqualTo(typeof(string)));
+            Assert.That(array[1].ServiceType, Is.EqualTo(typeof(int)));
+        }
+
+        [Test]
+        public void RemoveAt_ShouldRemoveItemAtIndex()
+        {
+            // Arrange
+            _factory.Add(ServiceDescriptor.Singleton(typeof(string), "x"));
+            _factory.Add(ServiceDescriptor.Singleton(typeof(int), 5));
+
+            // Act
+            _factory.RemoveAt(0);
+
+            // Assert
+            Assert.That(_factory.Count, Is.EqualTo(1));
+            Assert.That(_factory[0].ServiceType, Is.EqualTo(typeof(int)));
+        }
+
+        [Test]
+        public void Indexer_Set_ShouldReplaceItem()
+        {
+            // Arrange
+            var original = ServiceDescriptor.Singleton(typeof(string), "A");
+            var replacement = ServiceDescriptor.Singleton(typeof(string), "B");
+            _factory.Add(original);
+
+            // Act
+            _factory[0] = replacement;
+
+            // Assert
+            Assert.That(_factory[0], Is.EqualTo(replacement));
+        }
+    }
+}

DigitalData.Core.Tests/Client/BaseHttpClientServiceTest.cs

@@ -1,5 +1,5 @@
-using DigitalData.Core.Abstractions.Client;
-using DigitalData.Core.Client;
+using DigitalData.Core.Client;
+using DigitalData.Core.Client.Interface;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DigitalData.Core.Tests.Client

DigitalData.Core.Tests/DigitalData.Core.Tests.csproj

@@ -26,7 +26,6 @@
     <ProjectReference Include="..\DigitalData.Core.Application\DigitalData.Core.Application.csproj" />
     <ProjectReference Include="..\DigitalData.Core.Client\DigitalData.Core.Client.csproj" />
     <ProjectReference Include="..\DigitalData.Core.DTO\DigitalData.Core.DTO.csproj" />
-    <ProjectReference Include="..\DigitalData.Core.Infrastructure.AutoMapper\DigitalData.Core.Infrastructure.AutoMapper.csproj" />
     <ProjectReference Include="..\DigitalData.Core.Infrastructure\DigitalData.Core.Infrastructure.csproj" />
     <ProjectReference Include="..\DigitalData.Core.Security\DigitalData.Core.Security.csproj" />
   </ItemGroup>
@@ -42,7 +41,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.5" />
 	<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="9.0.4" />
   </ItemGroup>
 

DigitalData.Core.Tests/Infrastructure/DbRepositoryTests.cs

@@ -1,113 +0,0 @@
-namespace DigitalData.Core.Tests.Infrastructure;
-
-using DigitalData.Core.Infrastructure;
-using DigitalData.Core.Tests.Mock;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using System.Reflection;
-using DigitalData.Core.Abstractions.Infrastructure;
-using DigitalData.Core.Infrastructure.AutoMapper;
-
-public class DbRepositoryTests
-{
-    private IHost _host;
-
-    private IRepository<User> _userRepo;
-
-    [SetUp]
-    public void Setup()
-    {
-        var builder = Host.CreateApplicationBuilder();
-
-        builder.Services.AddDbContext<MockDbContext>(opt => opt.UseInMemoryDatabase("MockDB"));
-
-        builder.Services.AddDbRepository<MockDbContext, User>(context => context.Users).UseAutoMapper(typeof(UserCreateDto), typeof(UserReadDto), typeof(UserBase));
-
-        builder.Services.AddAutoMapper(Assembly.GetExecutingAssembly());
-
-        _host = builder.Build();
-
-        _userRepo = _host.Services.GetRequiredService<IRepository<User>>();
-    }
-
-    [TearDown]
-    public void TearDown()
-    {
-        if (_host is IDisposable disposableHost)
-            disposableHost.Dispose();
-    }
-
-    [TestCase(true, TestName = "WhenGivenMultipleUsers")]
-    [TestCase(false, TestName = "WhenGivenSingleUser")]
-    public void CreateAsync_ShouldNotThrow(bool multiple)
-    {
-        // Arrange
-        var faker = Fake.CreateUserFaker();
-
-        // Act & Assert
-        if (multiple)
-            Assert.DoesNotThrowAsync(async () => await _userRepo.CreateAsync(faker.Generate(Random.Shared.Next(1, 10))));
-        else
-            Assert.DoesNotThrowAsync(async () => await _userRepo.CreateAsync(faker.Generate()));
-    }
-
-    [TestCase(true, TestName = "WhenDtoUsed")]
-    [TestCase(false, TestName = "WhenEntityUsed")]
-    public async Task ReadAsync_ShouldReturnCreated(bool useDto)
-    {
-        // Act
-        var createdUser = useDto
-            ? await _userRepo.CreateAsync(Fake.UserCreateDto)
-            : await _userRepo.CreateAsync(Fake.User);
-
-        var readUser = await _userRepo.ReadFirstOrDefaultAsync(u => u.Id == createdUser.Id);
-
-        // Assert
-        Assert.Multiple(() =>
-        {
-            Assert.That(readUser, Is.Not.Null);
-            Assert.That(readUser, Is.EqualTo(createdUser));
-        });
-    }
-
-    [Test]
-    public async Task ReadAsync_ShouldReturnUpdated()
-    {
-        // Arrange
-        var createdUser = await _userRepo.CreateAsync(Fake.UserCreateDto);
-        var userUpdateDto = new UserUpdateDto() { Age = 10, Email = "Bar", FirstName = "Foo" };
-
-        // Act
-        await _userRepo.UpdateAsync(userUpdateDto, u => u.Id == createdUser!.Id);
-        var upToDateUser = await _userRepo.ReadFirstOrDefaultAsync(u => u.Id == createdUser!.Id);
-
-        // Assert
-        Assert.Multiple(() =>
-        {
-            Assert.That(upToDateUser, Is.Not.Null);
-            Assert.That(upToDateUser?.FirstName, Is.EqualTo(userUpdateDto.FirstName));
-            Assert.That(upToDateUser?.Email, Is.EqualTo(userUpdateDto.Email));
-            Assert.That(upToDateUser?.Age, Is.EqualTo(userUpdateDto.Age));
-        });
-    }
-
-    [Test]
-    public async Task ReadAsync_ShouldNotReturnDeleted()
-    {
-        // Arrange
-        var createdUser = await _userRepo.CreateAsync(Fake.UserCreateDto);
-        var readUser = await _userRepo.ReadFirstOrDefaultAsync(u => u.Id == createdUser.Id);
-
-        // Act
-        await _userRepo.DeleteAsync(u => u.Id == createdUser.Id);
-        var deletedUser = await _userRepo.ReadFirstOrDefaultAsync(u => u.Id == createdUser.Id);
-        
-        // Assert
-        Assert.Multiple(() =>
-        {
-            Assert.That(readUser, Is.Not.Null);
-            Assert.That(deletedUser, Is.Null);
-        });
-    }
-}

DigitalData.Core.Tests/Mock/User.cs

@@ -1,6 +1,10 @@
-namespace DigitalData.Core.Tests.Mock;
+using DigitalData.Core.Abstractions.Interfaces;
+using System.ComponentModel.DataAnnotations.Schema;
 
-public class User : UserBase
+namespace DigitalData.Core.Tests.Mock;
+
+[Table("USER")]
+public class User : UserBase, IEntity
 {
     public required int Id { get; init; }
 
@@ -9,4 +13,4 @@ public class User : UserBase
     public override bool Equals(object? obj)
         => (obj is User user && user.GetHashCode() == GetHashCode())
         || (obj is UserBase userBase && userBase.GetHashCode() == base.GetHashCode());
-}
+}

DigitalData.Core.Tests/Mock/UserCreateDto.cs

@@ -1,5 +1,7 @@
-namespace DigitalData.Core.Tests.Mock;
+using DigitalData.Core.Abstractions.Interfaces;
 
-public class UserCreateDto : UserBase
+namespace DigitalData.Core.Tests.Mock;
+
+public class UserCreateDto : UserBase, IDto<User>
 {
-}
+}

DigitalData.Core.Tests/Mock/UserReadDto.cs

@@ -1,5 +1,7 @@
-namespace DigitalData.Core.Tests.Mock;
+using DigitalData.Core.Abstractions.Interfaces;
 
-public class UserReadDto : UserBase
+namespace DigitalData.Core.Tests.Mock;
+
+public class UserReadDto : UserBase, IDto<User>
 {
-}
+}

DigitalData.Core.Tests/Mock/UserUpdateDto.cs

@@ -1,5 +1,7 @@
-namespace DigitalData.Core.Tests.Mock;
+using DigitalData.Core.Abstractions.Interfaces;
 
-public class UserUpdateDto : UserBase
+namespace DigitalData.Core.Tests.Mock;
+
+public class UserUpdateDto : UserBase, IDto<User>
 {
-}
+}

DigitalData.Core.sln

@@ -39,6 +39,22 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.Core.Infrastruc
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Infrastructure", "Infrastructure", "{41795B74-A757-4E93-B907-83BFF04EEE5C}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.Core.Exceptions", "DigitalData.Core.Exceptions\DigitalData.Core.Exceptions.csproj", "{BAEF6CC9-4FE2-4E3F-9D32-911C9E8CCFB4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.Core.Exceptions.Middleware", "DigitalData.Core.Exceptions.Middleware\DigitalData.Core.Exceptions.Middleware.csproj", "{2336AE61-A21D-437E-A11B-367D008A64B2}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Exceptions", "Exceptions", "{8C3AF25D-81D9-4651-90CA-BF0BD2A03EA7}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "assets", "assets", "{0A27EA70-74F4-48FB-881C-D741F2FCD456}"
+	ProjectSection(SolutionItems) = preProject
+		Assets\core_icon.png = Assets\core_icon.png
+		Assets\core_legacy_icon.png = Assets\core_legacy_icon.png
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.Core.Abstraction.Application", "DigitalData.Core.Abstraction.Application\DigitalData.Core.Abstraction.Application.csproj", "{420C35A7-0EDE-4E2E-8500-484B57B0367A}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Application", "Application", "{E18417C2-D9F5-437A-9ED5-473DD6260066}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -92,21 +108,33 @@ Global
 		{9BC2DEC5-E89D-48CC-9A51-4D94496EE4A6}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9BC2DEC5-E89D-48CC-9A51-4D94496EE4A6}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9BC2DEC5-E89D-48CC-9A51-4D94496EE4A6}.Release|Any CPU.Build.0 = Release|Any CPU
-		{C9266749-9504-4EA9-938F-F083357B60B7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{C9266749-9504-4EA9-938F-F083357B60B7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C9266749-9504-4EA9-938F-F083357B60B7}.Debug|Any CPU.ActiveCfg = Release|Any CPU
+		{C9266749-9504-4EA9-938F-F083357B60B7}.Debug|Any CPU.Build.0 = Release|Any CPU
 		{C9266749-9504-4EA9-938F-F083357B60B7}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{C9266749-9504-4EA9-938F-F083357B60B7}.Release|Any CPU.Build.0 = Release|Any CPU
 		{CE00E1F7-2771-4D9C-88FB-E564894E539E}.Debug|Any CPU.ActiveCfg = Release|Any CPU
 		{CE00E1F7-2771-4D9C-88FB-E564894E539E}.Debug|Any CPU.Build.0 = Release|Any CPU
 		{CE00E1F7-2771-4D9C-88FB-E564894E539E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{CE00E1F7-2771-4D9C-88FB-E564894E539E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BAEF6CC9-4FE2-4E3F-9D32-911C9E8CCFB4}.Debug|Any CPU.ActiveCfg = Release|Any CPU
+		{BAEF6CC9-4FE2-4E3F-9D32-911C9E8CCFB4}.Debug|Any CPU.Build.0 = Release|Any CPU
+		{BAEF6CC9-4FE2-4E3F-9D32-911C9E8CCFB4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BAEF6CC9-4FE2-4E3F-9D32-911C9E8CCFB4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2336AE61-A21D-437E-A11B-367D008A64B2}.Debug|Any CPU.ActiveCfg = Release|Any CPU
+		{2336AE61-A21D-437E-A11B-367D008A64B2}.Debug|Any CPU.Build.0 = Release|Any CPU
+		{2336AE61-A21D-437E-A11B-367D008A64B2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2336AE61-A21D-437E-A11B-367D008A64B2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A}.Debug|Any CPU.ActiveCfg = Release|Any CPU
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A}.Debug|Any CPU.Build.0 = Release|Any CPU
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{A765EBEA-3D1E-4F36-869B-6D72F87FF3F6} = {41795B74-A757-4E93-B907-83BFF04EEE5C}
-		{DB404CD9-CBB8-4771-AB1B-FD4FDE2C28CC} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{DB404CD9-CBB8-4771-AB1B-FD4FDE2C28CC} = {E18417C2-D9F5-437A-9ED5-473DD6260066}
 		{C57B2480-F632-4691-9C4C-8CC01237203C} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{B54DEF90-C30C-44EA-9875-76F1B330CBB7} = {EDF84A84-1E01-484E-B073-383F7139C891}
 		{0B051A5F-BD38-47D1-BAFF-D44BA30D3FB7} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
@@ -121,6 +149,11 @@ Global
 		{C9266749-9504-4EA9-938F-F083357B60B7} = {72CBAFBA-55CC-49C9-A484-F8F4550054CB}
 		{CE00E1F7-2771-4D9C-88FB-E564894E539E} = {41795B74-A757-4E93-B907-83BFF04EEE5C}
 		{41795B74-A757-4E93-B907-83BFF04EEE5C} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{BAEF6CC9-4FE2-4E3F-9D32-911C9E8CCFB4} = {8C3AF25D-81D9-4651-90CA-BF0BD2A03EA7}
+		{2336AE61-A21D-437E-A11B-367D008A64B2} = {8C3AF25D-81D9-4651-90CA-BF0BD2A03EA7}
+		{8C3AF25D-81D9-4651-90CA-BF0BD2A03EA7} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{420C35A7-0EDE-4E2E-8500-484B57B0367A} = {E18417C2-D9F5-437A-9ED5-473DD6260066}
+		{E18417C2-D9F5-437A-9ED5-473DD6260066} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {8E2C3187-F848-493A-9E79-56D20DDCAC94}