Bump version to 1.1.1 in project file

Updated DigitalData.Core.Exceptions.csproj to set <Version>, <AssemblyVersion>, and <FileVersion> to 1.1.1, replacing the previous 1.1.0 values. No other changes were made.

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

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Abstraction.Application.DTO;
+#if NET
+namespace DigitalData.Core.Abstraction.Application.DTO;
 
 /// <summary>
 /// Represents a base Data Transfer Object (DTO) with an identifier.
@@ -15,3 +16,4 @@ public record BaseDTO<TId>(TId Id) where TId : notnull
 	/// <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

@@ -1,5 +1,6 @@
-namespace DigitalData.Core.Abstraction.Application.DTO
+#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
@@ -71,4 +72,4 @@
     /// </summary>
     public List<string>? Categories { get; set; }
 }
-}
+#endif

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

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Configuration;
+#if NET
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using System.Configuration;
 
@@ -32,3 +33,4 @@ public static class DIExtensions
         return services;
     }
 }
+#endif

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

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Logging;
+#if NET
+using Microsoft.Extensions.Logging;
 using System.Text;
 
 namespace DigitalData.Core.Abstraction.Application.DTO;
@@ -391,3 +392,4 @@ public static class DTOExtensions
     [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

@@ -1,4 +1,5 @@
-using System.Text.Json.Serialization;
+#if NET
+using System.Text.Json.Serialization;
 
 namespace DigitalData.Core.Abstraction.Application.DTO;
 
@@ -26,3 +27,4 @@ public class DataResult<T> : Result
     [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

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Abstraction.Application.DTO;
+#if NET
+namespace DigitalData.Core.Abstraction.Application.DTO;
 
 /// <summary>
 /// Defines flags that indicate specific types of status or conditions in a service operation.
@@ -48,3 +49,4 @@ public enum Flag
     /// </summary>
     NotFound
 }
+#endif

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

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Logging;
+#if NET
+using Microsoft.Extensions.Logging;
 
 namespace DigitalData.Core.Abstraction.Application.DTO;
 
@@ -26,3 +27,4 @@ public class Notice
     [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
     public List<string> Messages { get; init; } = new();
 }
+#endif

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

@@ -1,4 +1,5 @@
-using System.Text.Json.Serialization;
+#if NET
+using System.Text.Json.Serialization;
 
 namespace DigitalData.Core.Abstraction.Application.DTO;
 
@@ -106,3 +107,4 @@ public class Result
     };
 #pragma warning restore CS8601 // Possible null reference assignment.
 }
+#endif

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

@@ -1,9 +1,7 @@
 <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>
     <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>
@@ -14,9 +12,9 @@
     <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.3.1</Version>
+    <Version>1.6.0</Version>
-    <AssemblyVersion>1.3.1</AssemblyVersion>
+    <AssemblyVersion>1.6.0</AssemblyVersion>
-    <FileVersion>1.3.1</FileVersion>
+    <FileVersion>1.6.0</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -26,6 +24,20 @@
     </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" />
@@ -36,22 +48,32 @@
     <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" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="3.1.32" />
+  </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" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="7.0.20" />
   </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" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="8.0.15" />
   </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" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="9.0.5" />
   </ItemGroup>
 
   <ItemGroup>

DigitalData.Core.Abstraction.Application/EntityExtensions.cs

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Abstraction.Application;
+#if NET
+namespace DigitalData.Core.Abstraction.Application;
 
 /// <summary>
 /// Provides extension methods for retrieving the value of an 'Id' property from objects.
@@ -92,3 +93,4 @@ public static class EntityExtensions
         return id is not null;
     }
 }
+#endif

DigitalData.Core.Abstraction.Application/IBasicCRUDService.cs

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Abstraction.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,
@@ -19,3 +20,4 @@
     {
     }
 }
+#endif

DigitalData.Core.Abstraction.Application/ICRUDService.cs

@@ -1,7 +1,8 @@
-using DigitalData.Core.Abstraction.Application.DTO;
+#if NET
+using DigitalData.Core.Abstraction.Application.DTO;
+
+namespace DigitalData.Core.Abstraction.Application;
 
-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
@@ -22,4 +23,4 @@ namespace DigitalData.Core.Abstraction.Application
     /// <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

@@ -1,8 +1,10 @@
-using DigitalData.Core.Abstraction.Application.DTO;
+#if NET
+using DigitalData.Core.Abstraction.Application.DTO;
 using System.DirectoryServices;
 
-namespace DigitalData.Core.Abstraction.Application
+namespace DigitalData.Core.Abstraction.Application;
-{
+
+[Obsolete("Use DigitalData.ActiveDirectory")]
 public interface IDirectorySearchService
 {
     public string ServerName { get; }
@@ -91,4 +93,4 @@ namespace DigitalData.Core.Abstraction.Application
     /// <returns>The cached <see cref="DirectoryEntry"/> if found; otherwise, null.</returns>
     DirectoryEntry? GetSearchRootCache(string username);
 }
-}
+#endif

DigitalData.Core.Abstraction.Application/IJWTService.cs

@@ -1,9 +1,10 @@
-using Microsoft.IdentityModel.Tokens;
+#if NET
+using Microsoft.IdentityModel.Tokens;
 using System.IdentityModel.Tokens.Jwt;
 using System.Security.Cryptography;
 
-namespace DigitalData.Core.Abstraction.Application
+namespace DigitalData.Core.Abstraction.Application;
-{
+
 /// <summary>
 /// Defines the operations for JWT service handling claims of type <typeparamref name="TClaimValue"/>.
 /// </summary>
@@ -38,4 +39,4 @@ namespace DigitalData.Core.Abstraction.Application
     /// <returns>A <see cref="JwtSecurityToken"/> if the token is valid; otherwise, null.</returns>
     JwtSecurityToken? ReadSecurityToken(string token);
 }
-}
+#endif

DigitalData.Core.Abstraction.Application/IReadService.cs

@@ -1,7 +1,8 @@
-using DigitalData.Core.Abstraction.Application.DTO;
+#if NET
+using DigitalData.Core.Abstraction.Application.DTO;
+
+namespace DigitalData.Core.Abstraction.Application;
 
-namespace DigitalData.Core.Abstraction.Application
-{
 [Obsolete("Use MediatR")]
 public interface IReadService<TReadDto, TEntity, TId>
     where TReadDto : class where TEntity : class
@@ -36,4 +37,4 @@ namespace DigitalData.Core.Abstraction.Application
     /// <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/Extensions.cs

@@ -1,63 +0,0 @@
-using System.Linq.Expressions;
-using DigitalData.Core.Abstractions.Interfaces;
-
-namespace DigitalData.Core.Abstraction.Application.Repository;
-
-public static class Extensions
-{
-    #region IRepository
-    #region Read
-    public static IEnumerable<TEntity> GetAll<TEntity>(this IRepository repository) where TEntity : IEntity 
-        => repository.Entity<TEntity>().GetAll();
-
-    public static Task<IEnumerable<TEntity>> GetAllAsync<TEntity>(this IRepository repository, CancellationToken cancel = default) where TEntity : IEntity
-        => repository.Entity<TEntity>().GetAllAsync(cancel);
-
-    public static IQueryable<TEntity> Where<TEntity>(this IRepository repository, Expression<Func<TEntity, bool>> expression)
-         where TEntity : IEntity
-        => repository.Entity<TEntity>().Where(expression);
-    #endregion
-
-    #region Create
-    public static Task<TEntity> CreateAsync<TEntity>(this IRepository repository, TEntity entity, CancellationToken cancel = default)
-        where TEntity : IEntity
-        => repository.Entity<TEntity>().CreateAsync(entity, cancel);
-
-    public static Task<TEntity> CreateAsync<TEntity, TDto>(this IRepository repository, TDto dto, CancellationToken cancel = default)
-        where TEntity : IEntity
-        where TDto : IDto<TEntity>
-        => repository.Entity<TEntity>().CreateAsync(dto, cancel);
-
-    public static Task<IEnumerable<TEntity>> CreateAsync<TEntity>(this IRepository repository, IEnumerable<TEntity> entities, CancellationToken cancel = default)
-        where TEntity : IEntity
-        => repository.Entity<TEntity>().CreateAsync(entities, cancel);
-
-    public static Task<IEnumerable<TEntity>> CreateAsync<TEntity, TDto>(this IRepository repository, IEnumerable<TDto> dtos, CancellationToken cancel = default)
-        where TEntity : IEntity
-        where TDto : IDto<TEntity>
-        => repository.Entity<TEntity>().CreateAsync(dtos, cancel);
-    #endregion Create
-
-    #region Update
-    public static Task UpdateAsync<TEntity, TDto>(this IRepository repository, TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default)
-        where TEntity : IEntity
-        where TDto : IDto<TEntity>
-        => repository.Entity<TEntity>().UpdateAsync(dto, expression, cancel);
-
-    public static Task UpdateAsync<TEntity, TDto>(this IRepository repository, TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
-        where TEntity : IEntity
-        where TDto : IDto<TEntity>
-        => repository.Entity<TEntity>().UpdateAsync(dto, query, cancel);
-    #endregion
-
-    #region Delete
-    public static Task DeleteAsync<TEntity>(this IRepository repository, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default)
-         where TEntity : IEntity
-        => repository.Entity<TEntity>().DeleteAsync(expression, cancel);
-
-    public static Task DeleteAsync<TEntity>(this IRepository repository, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
-         where TEntity : IEntity
-        => repository.Entity<TEntity>().DeleteAsync(query, cancel);
-    #endregion
-    #endregion
-}

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

@@ -1,4 +1,5 @@
-namespace DigitalData.Core.Abstraction.Application.Repository
+#if NET
+namespace DigitalData.Core.Abstraction.Application.Repository
 {
     /// <summary>
     /// Defines the contract for CRUD operations on a repository for entities of type TEntity.
@@ -61,3 +62,4 @@
         Task<int> CountAsync(TId id);
     }
 }
+#endif

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

@@ -1,4 +1,7 @@
-namespace DigitalData.Core.Abstraction.Application.Repository
+#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

@@ -1,50 +1,140 @@
-using DigitalData.Core.Abstractions.Interfaces;
+using System.Linq.Expressions;
-using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore.Query;
+#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;
+namespace DigitalData.Core.Abstraction.Application.Repository
+{
+    public interface IRepository
+    {
+#if NET
+    public
+#endif
+        Task<int> ExecuteQueryRawAsync([NotParameterized] string sql, IEnumerable<object> parameters, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        Task<int> ExecuteQueryInterpolatedAsync(FormattableString sql, CancellationToken cancel = default);
+
+#if NET
+    public
+#endif
+        int ExecuteQueryRaw([NotParameterized] string sql, params object[] parameters);
+
+#if NET
+    public
+#endif
+        int ExecuteQueryInterpolated(FormattableString sql);
+    }
 
     public interface IRepository<TEntity>
     {
         #region Create
-    public Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default);
+#if NET
+    public
+#endif
+        Task<TEntity> CreateAsync(TEntity entity, CancellationToken cancel = default);
 
-    public Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default);
+#if NET
+    public
+#endif
+        Task<IEnumerable<TEntity>> CreateAsync(IEnumerable<TEntity> entities, CancellationToken cancel = default);
 
-    public Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default);
+#if NET
+    public
+#endif
+        Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default);
 
-    public Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default);
+#if NET
+    public
+#endif
+        Task<IEnumerable<TEntity>> CreateAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancel = default);
         #endregion Create
 
         #region Read
-    public IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression);
+#if NET
+    public
+#endif
+        IQueryable<TEntity> Query { get; }
 
-    public IEnumerable<TEntity> GetAll();
+#if NET
+    public
+#endif
+        IQueryable<TEntity> QueryRaw([NotParameterized] string sql, params object[] parameters);
 
-    public Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancel = default);
+#if NET
+    public
+#endif
+        IQueryable<TEntity> QueryInterpolated([NotParameterized] FormattableString sql);
+
+#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
-    public Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+#if NET
+    public
+#endif
+        Task UpdateAsync<TDto>(TDto dto, Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
 
-    public Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, 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
-    public Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
+#if NET
+    public
+#endif
+        Task DeleteAsync(Expression<Func<TEntity, bool>> expression, CancellationToken cancel = default);
 
-    public Task DeleteAsync(Func<IQueryable<TEntity>, IQueryable<TEntity>> query, 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")]
-    public IQueryable<TEntity> Read();
+#if NET
+    public
+#endif
+        IQueryable<TEntity> Read();
 
         [Obsolete("Use IRepository<TEntity>.Where")]
-    public IQueryable<TEntity> ReadOnly();
+#if NET
+    public
+#endif
+        IQueryable<TEntity> ReadOnly();
         #endregion
     }
-
-public interface IRepository
-{
-    public IRepository<TEntity> Entity<TEntity>() where TEntity : IEntity;
 }

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

@@ -1,6 +0,0 @@
-namespace DigitalData.Core.Abstraction.Application.Repository;
-
-public interface IRepositoryFactory
-{
-    public IRepository<TEntity> Get<TEntity>();
-}

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/DigitalData.Core.Abstractions.csproj

@@ -16,11 +16,17 @@
 		<RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
 		<PackAsTool>False</PackAsTool>
 		<PackageIcon>core_icon.png</PackageIcon>
-		<Version>4.1.1</Version>
+		<Version>4.3.0</Version>
-		<AssemblyVersion>4.1.1</AssemblyVersion>
+		<AssemblyVersion>4.3.0</AssemblyVersion>
-		<FileVersion>4.1.1</FileVersion>
+		<FileVersion>4.3.0</FileVersion>
 	</PropertyGroup>
 
+	<ItemGroup>
+		<None Include="..\Assets\core_icon.png">
+			<Pack>True</Pack>
+			<PackagePath>\</PackagePath>
+		</None>
+	</ItemGroup>
 
 	<!-- disable for net462 -->
 	<PropertyGroup Condition="'$(TargetFramework)' == 'net462'">
@@ -36,26 +42,27 @@
 		<LangVersion>latest</LangVersion>
 	</PropertyGroup>
 
-	<ItemGroup>
+	<ItemGroup Condition="'$(TargetFramework)' == 'net462'">
-	  <None Include="..\..\nuget-package-icons\core_icon.png">
+	  <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
-	    <Pack>True</Pack>
+	  <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="7.0.0" />
-	    <PackagePath>\</PackagePath>
-	  </None>
 	</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="8.0.2" />
+      <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.Exceptions/BadRequestException.cs

@@ -19,4 +19,13 @@ public class BadRequestException : Exception
     public BadRequestException(string? message) : base(message)
     {
     }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BadRequestException"/> class with a specified error message and inner exception.
+    /// </summary>
+    /// <param name="message">The message that describes the error.</param>
+    /// <param name="innerException">The exception that caused the current exception.</param>
+    public BadRequestException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
 }

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

@@ -17,9 +17,9 @@
 	<RepositoryUrl>http://git.dd:3000/AppStd/WebCoreModules.git</RepositoryUrl>
 	<PackAsTool>False</PackAsTool>
 	<PackageIcon>core_icon.png</PackageIcon>
-	<Version>1.1.0</Version>
+	<Version>1.1.1</Version>
-	<AssemblyVersion>1.1.0</AssemblyVersion>
+	<AssemblyVersion>1.1.1</AssemblyVersion>
-	<FileVersion>1.1.0</FileVersion>
+	<FileVersion>1.1.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>

DigitalData.Core.Infrastructure/CRUDRepository.cs

@@ -1,4 +1,5 @@
-using DigitalData.Core.Abstraction.Application;
+#if NET
+using DigitalData.Core.Abstraction.Application;
 using DigitalData.Core.Abstraction.Application.Repository;
 using Microsoft.EntityFrameworkCore;
 
@@ -111,3 +112,4 @@ namespace DigitalData.Core.Infrastructure
         public virtual async Task<int> CountAsync(TId id) => await _dbSet.Where(e => e.GetId().Equals(id)).CountAsync();
     }
 }
+#endif

DigitalData.Core.Infrastructure/DbRepository.cs

@@ -1,11 +1,48 @@
 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.EntityFrameworkCore.Query;
+#if NETFRAMEWORK
+using System.Collections.Generic;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+#endif
 
-namespace DigitalData.Core.Infrastructure;
+namespace DigitalData.Core.Infrastructure
+{
+    public class DbRepository<TDbContext> : IRepository where TDbContext : DbContext
+    {
+        protected internal readonly TDbContext Context;
+
+        public DbRepository(TDbContext context)
+        {
+            Context = context;
+        }
+
+        public Task<int> ExecuteQueryRawAsync([NotParameterized] string sql, IEnumerable<object> parameters, CancellationToken cancel = default)
+        {
+            return Context.Database.ExecuteSqlRawAsync(sql, parameters, cancel);
+        }
+
+        public Task<int> ExecuteQueryInterpolatedAsync(FormattableString sql, CancellationToken cancel = default)
+        {
+            return Context.Database.ExecuteSqlInterpolatedAsync(sql, cancel);
+        }
+
+        public int ExecuteQueryRaw([NotParameterized] string sql, params object[] parameters)
+        {
+            return Context.Database.ExecuteSqlRaw(sql, parameters);
+        }
+
+        public int ExecuteQueryInterpolated(FormattableString sql)
+        {
+            return Context.Database.ExecuteSqlInterpolated(sql);
+        }
+    }
 
     public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbContext : DbContext where TEntity : class
     {
@@ -13,9 +50,17 @@ public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbC
 
         protected internal readonly DbSet<TEntity> Entities;
 
-    public IMapper? Mapper { get; }
+        public IMapper
+#if NET
+        ?
+#endif
+            Mapper { get; }
 
-    public DbRepository(TDbContext context, DbSetFactory<TDbContext, TEntity> factory, IMapper? mapper = null)
+        public DbRepository(TDbContext context, DbSetFactory<TDbContext, TEntity> factory, IMapper
+#if NET
+        ?
+#endif
+            mapper = null)
         {
             Context = context;
             Entities = factory.Create(context);
@@ -37,13 +82,28 @@ public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbC
             return entities;
         }
 
-    public virtual Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancel = default) => CreateAsync(Mapper!.Map<TEntity>(dto), cancel);
+        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!.Map<IEnumerable<TEntity>>(dtos), cancel);
+            => 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> QueryRaw([NotParameterized] string sql, params object[] parameters) => Entities.FromSqlRaw(sql, parameters).AsNoTracking();
+
+        public virtual IQueryable<TEntity> QueryInterpolated([NotParameterized] FormattableString sql) => Entities.FromSqlInterpolated(sql).AsNoTracking();
+
         public virtual IQueryable<TEntity> Where(Expression<Func<TEntity, bool>> expression) => Entities.AsNoTracking().Where(expression);
 
         public virtual IEnumerable<TEntity> GetAll() => Entities.AsNoTracking().ToList();
@@ -54,18 +114,25 @@ public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbC
         #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 async Task UpdateAsync<TDto>(TDto dto, Func<IQueryable<TEntity>, IQueryable<TEntity>> query, CancellationToken cancel = default)
+        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]);
-            Mapper!.Map(dto, entities[i]);
-            Entities.Update(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
@@ -92,15 +159,4 @@ public class DbRepository<TDbContext, TEntity> : IRepository<TEntity> where TDbC
         public virtual IQueryable<TEntity> ReadOnly() => Entities.AsNoTracking();
         #endregion
     }
-
-public class DbRepository : IRepository
-{
-    private readonly IRepositoryFactory _factory;
-
-    public DbRepository(IRepositoryFactory factory)
-    {
-        _factory = factory;
-    }
-
-    public IRepository<TEntity> Entity<TEntity>() where TEntity : IEntity => _factory.Get<TEntity>();
 }

DigitalData.Core.Infrastructure/DependencyInjection.cs

@@ -4,9 +4,14 @@ 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
-
+{
     public static class DependencyInjection
     {
         public static IServiceCollection AddDbRepository(this IServiceCollection services, Action<RepositoryConfiguration> options)
@@ -16,25 +21,22 @@ public static class DependencyInjection
             options.Invoke(cfg);
             cfg.RegisterAllServices(services);
 
-        // register db repository
-        services.AddSingleton<IRepository, DbRepository>();
-
-        // register db repository factory
-        services.AddSingleton<IRepositoryFactory, DbRepositoryFactory>();
-
             return services;
         }
 
         public class RepositoryConfiguration
         {
             // 1. register from assembly
-        private readonly Queue<Action<IServiceCollection>> RegsFromAssembly = new();
+            private readonly Queue<Action<IServiceCollection>> RegsFromAssembly = new Queue<Action<IServiceCollection>>();
 
             // 2. register entities (can overwrite)
-        private readonly Queue<Action<IServiceCollection>> RegsEntity = new();
+            private readonly Queue<Action<IServiceCollection>> RegsEntity = new Queue<Action<IServiceCollection>>();
 
             // 3. register db set factories (can overwrite)
-        private readonly Queue<Action<IServiceCollection>> RegsDbSetFactory = new();
+            private readonly Queue<Action<IServiceCollection>> RegsDbSetFactory = new Queue<Action<IServiceCollection>>();
+
+            // 4. register repository
+            private readonly Queue<Action<IServiceCollection>> RegsRepository = new Queue<Action<IServiceCollection>>();
 
             internal void RegisterAllServices(IServiceCollection services)
             {
@@ -46,6 +48,9 @@ public static class DependencyInjection
 
                 // 3. register db set factories (can overwrite)
                 RegsDbSetFactory.InvokeAll(services);
+
+                // 4. register repository
+                RegsRepository.InvokeAll(services);
             }
 
             internal RepositoryConfiguration() { }
@@ -76,7 +81,11 @@ public static class DependencyInjection
                             .GetMethod(nameof(AddDbSetFactory),
                                        BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
 
-                    var genericMethod = addDbSetFactoryMethod!.MakeGenericMethod(typeof(TDbContext), entityType);
+                        var genericMethod = addDbSetFactoryMethod
+#if NET
+                                        !
+#endif
+                                            .MakeGenericMethod(typeof(TDbContext), entityType);
                         genericMethod.Invoke(null, new [] { services, null });
                         #endregion DbSetFactory
                     }
@@ -85,7 +94,11 @@ public static class DependencyInjection
                 RegsFromAssembly.Enqueue(reg);
             }
 
-        public void RegisterEntity<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>>? dbSetFactory = null)
+            public void RegisterEntity<TDbContext, TEntity>(Func<TDbContext, DbSet<TEntity>>
+#if NET
+            ?
+#endif
+                dbSetFactory = null)
                 where TDbContext : DbContext
                 where TEntity : class
             {
@@ -101,6 +114,10 @@ public static class DependencyInjection
                 where TDbContext : DbContext
                 where TEntity : class
                 => RegsDbSetFactory.Enqueue(s => s.AddDbSetFactory(dbSetFactory));
+
+            public void RegisterDefaultRepository<TDbContext>()
+                where TDbContext : DbContext
+                => RegsRepository.Enqueue(s => s.AddScoped<IRepository, DbRepository<TDbContext>>());
         }
 
         private static void InvokeAll<T>(this Queue<Action<T>> queue, T services)
@@ -109,12 +126,22 @@ public static class DependencyInjection
                 queue.Dequeue().Invoke(services);
         }
 
-    internal static IServiceCollection AddDbSetFactory<TDbContext, TEntity>(this IServiceCollection services, Func<TDbContext, DbSet<TEntity>>? create = null)
+        internal static IServiceCollection AddDbSetFactory<TDbContext, TEntity>(this IServiceCollection services, Func<TDbContext, DbSet<TEntity>>
+#if NET
+        ?
+#endif
+            create = null)
             where TDbContext : DbContext
             where TEntity : class
         {
+#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;
         }
     }
+}

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

@@ -1,9 +1,7 @@
 <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>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <PackageId>DigitalData.Core.Infrastructure</PackageId>
     <Authors>Digital Data GmbH</Authors>
@@ -15,9 +13,9 @@
     <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>
-    <Version>2.4.1</Version>
+    <Version>2.6.1</Version>
-    <AssemblyVersion>2.4.1</AssemblyVersion>
+    <AssemblyVersion>2.6.1</AssemblyVersion>
-    <FileVersion>2.4.1</FileVersion>
+    <FileVersion>2.6.1</FileVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -27,16 +25,38 @@
     </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" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="3.1.32" />
+  </ItemGroup>
+
   <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.20" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="7.0.20" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.15" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="8.0.15" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.5" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.5" />
   </ItemGroup>
 
   <ItemGroup>

DigitalData.Core.Infrastructure/Factory/DbRepositoryFactory.cs

@@ -1,16 +0,0 @@
-using DigitalData.Core.Abstraction.Application.Repository;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace DigitalData.Core.Infrastructure.Factory;
-
-public class DbRepositoryFactory : IRepositoryFactory
-{
-    private readonly IServiceProvider _provider;
-
-    public DbRepositoryFactory(IServiceProvider provider)
-    {
-        _provider = provider;
-    }
-
-    public IRepository<TEntity> Get<TEntity>() => _provider.GetRequiredService<IRepository<TEntity>>();
-}

DigitalData.Core.Infrastructure/Factory/DbSetFactory.cs

@@ -1,6 +1,14 @@
 using Microsoft.EntityFrameworkCore;
+#if NETFRAMEWORK
+using System;
+#endif
 
-namespace DigitalData.Core.Infrastructure.Factory;
+namespace DigitalData.Core.Infrastructure.Factory
+#if NET
+    ;
+#elif NETFRAMEWORK
+    {
+#endif
 
 public class DbSetFactory<TDbContext,TEntity> where TDbContext : DbContext where TEntity : class
 {
@@ -11,3 +19,7 @@ public class DbSetFactory<TDbContext,TEntity> where TDbContext : DbContext where
         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/Infrastructure/DbRepositoryTests.cs

@@ -1,115 +0,0 @@
-using DigitalData.Core.Tests.Mock;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using System.Reflection;
-using DigitalData.Core.Abstraction.Application.Repository;
-using DigitalData.Core.Infrastructure;
-
-namespace DigitalData.Core.Tests.Infrastructure;
-
-public class DbRepositoryTests
-{
-    private IHost _host;
-
-    private IRepository Repo;
-
-    [SetUp]
-    public void Setup()
-    {
-        var builder = Host.CreateApplicationBuilder();
-
-        builder.Services.AddDbContext<MockDbContext>(opt => opt.UseInMemoryDatabase("MockDB"));
-
-        builder.Services.AddDbRepository(opt =>
-        {
-            opt.RegisterFromAssembly<MockDbContext>(typeof(User).Assembly);
-        });
-
-        builder.Services.AddAutoMapper(Assembly.GetExecutingAssembly());
-
-        _host = builder.Build();
-
-        Repo = _host.Services.GetRequiredService<IRepository>();
-    }
-
-    [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 Repo.CreateAsync(faker.Generate(Random.Shared.Next(1, 10))));
-        else
-            Assert.DoesNotThrowAsync(async () => await Repo.CreateAsync(faker.Generate()));
-    }
-
-    [TestCase(true, TestName = "WhenDtoUsed")]
-    [TestCase(false, TestName = "WhenEntityUsed")]
-    public async Task ReadAsync_ShouldReturnCreated(bool useDto)
-    {
-        // Act
-        var createdUser = useDto
-            ? await Repo.CreateAsync<User, UserCreateDto>(Fake.UserCreateDto)
-            : await Repo.CreateAsync(Fake.User);
-
-        var readUser = await Repo.Where<User>(u => u.Id == createdUser.Id).FirstOrDefaultAsync();
-
-        // 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 Repo.CreateAsync<User, UserCreateDto>(Fake.UserCreateDto);
-        var userUpdateDto = new UserUpdateDto() { Age = 10, Email = "Bar", FirstName = "Foo" };
-
-        // Act
-        await Repo.UpdateAsync<User, UserUpdateDto>(userUpdateDto, u => u.Id == createdUser!.Id);
-        var upToDateUser = await Repo.Where<User>(u => u.Id == createdUser!.Id).FirstOrDefaultAsync();
-
-        // 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 Repo.CreateAsync<User, UserCreateDto>(Fake.UserCreateDto);
-        var readUser = await Repo.Where<User>(u => u.Id == createdUser.Id).FirstOrDefaultAsync();
-
-        // Act
-        await Repo.DeleteAsync<User>(u => u.Id == createdUser.Id);
-        var deletedUser = await Repo.Where<User>(u => u.Id == createdUser.Id).FirstOrDefaultAsync();
-        
-        // Assert
-        Assert.Multiple(() =>
-        {
-            Assert.That(readUser, Is.Not.Null);
-            Assert.That(deletedUser, Is.Null);
-        });
-    }
-}

DigitalData.Core.Tests/Mock/User.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Abstractions.Interfaces;
 using System.ComponentModel.DataAnnotations.Schema;
 
 namespace DigitalData.Core.Tests.Mock;

DigitalData.Core.Tests/Mock/UserCreateDto.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Abstractions.Interfaces;
 
 namespace DigitalData.Core.Tests.Mock;
 

DigitalData.Core.Tests/Mock/UserReadDto.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Abstractions.Interfaces;
 
 namespace DigitalData.Core.Tests.Mock;
 

DigitalData.Core.Tests/Mock/UserUpdateDto.cs

@@ -1,4 +1,4 @@
-using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Abstractions.Interfaces;
 
 namespace DigitalData.Core.Tests.Mock;