Fixes

Author: A-Programmer

README.md

@@ -1,76 +1,73 @@
 using System.Linq.Expressions;
-using KSFramework.KSDomain.AggregatesHelper;
 using KSFramework.Pagination;
 
 namespace KSFramework.GenericRepository;
 
 /// <summary>
-/// Represents a generic repository interface for performing CRUD operations on entities.
+/// Represents a generic repository contract for performing common data access operations on entities.
 /// </summary>
 /// <typeparam name="TEntity">The type of the entity.</typeparam>
 public interface IGenericRepository<TEntity> where TEntity : class
 {
     /// <summary>
-    /// Retrieves an entity by its identifier asynchronously.
+    /// Asynchronously retrieves an entity by its unique identifier.
     /// </summary>
-    /// <param name="id">The identifier of the entity.</param>
-    /// <returns>A task that represents the asynchronous operation. The task result contains the entity if found.</returns>
+    /// <param name="id">The unique identifier of the entity.</param>
+    /// <returns>A task representing the asynchronous operation, containing the entity if found; otherwise, null.</returns>
     ValueTask<TEntity?> GetByIdAsync(object id);
 
     /// <summary>
-    /// Retrieves all entities asynchronously.
+    /// Asynchronously retrieves all entities.
     /// </summary>
-    /// <returns>A task that represents the asynchronous operation. The task result contains the collection of entities.</returns>
+    /// <returns>A task representing the asynchronous operation, containing a collection of all entities.</returns>
     Task<IEnumerable<TEntity>> GetAllAsync();
 
     /// <summary>
-    /// Retrieves a paginated list of entities asynchronously based on specified criteria.
+    /// Asynchronously retrieves a paginated list of entities with optional filtering and ordering.
     /// </summary>
-    /// <param name="pageIndex">The index of the page to retrieve (1-based).</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="where">Optional predicate to filter the entities.</param>
-    /// <param name="orderBy">Optional property name to order the results by.</param>
-    /// <param name="desc">Optional flag to indicate descending order.</param>
-    /// <returns>A task that represents the asynchronous operation. The task result contains the paginated list of entities.</returns>
+    /// <param name="pageIndex">The index of the page (starting from 1).</param>
+    /// <param name="pageSize">The number of items per page.</param>
+    /// <param name="where">Optional filter expression.</param>
+    /// <param name="orderBy">Optional property name to order by.</param>
+    /// <param name="desc">Indicates if the order should be descending.</param>
+    /// <returns>A task representing the asynchronous operation, containing a paginated list of entities.</returns>
     Task<PaginatedList<TEntity>> GetPagedAsync(int pageIndex, int pageSize, Expression<Func<TEntity, bool>>? where = null, string? orderBy = "", bool desc = false);
 
     /// <summary>
-    /// Retrieves a paginated list of entities synchronously based on specified criteria.
+    /// Synchronously retrieves a paginated list of entities with optional filtering and ordering.
     /// </summary>
-    /// <param name="pageIndex">The index of the page to retrieve (1-based).</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="where">Optional predicate to filter the entities.</param>
-    /// <param name="orderBy">Optional property name to order the results by.</param>
-    /// <param name="desc">Optional flag to indicate descending order.</param>
+    /// <param name="pageIndex">The index of the page (starting from 1).</param>
+    /// <param name="pageSize">The number of items per page.</param>
+    /// <param name="where">Optional filter expression.</param>
+    /// <param name="orderBy">Optional property name to order by.</param>
+    /// <param name="desc">Indicates if the order should be descending.</param>
     /// <returns>A paginated list of entities.</returns>
     PaginatedList<TEntity> GetPaged(int pageIndex, int pageSize, Expression<Func<TEntity, bool>>? where = null, string? orderBy = "", bool desc = false);
 
     /// <summary>
-    /// Finds entities that match the specified predicate.
+    /// Finds entities matching the given predicate.
     /// </summary>
-    /// <param name="predicate">The condition to filter entities.</param>
-    /// <returns>A collection of entities that match the condition.</returns>
+    /// <param name="predicate">The condition to match.</param>
+    /// <returns>A collection of matching entities.</returns>
     IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate);
 
     /// <summary>
-    /// Retrieves a single entity that matches the specified predicate, or null if no match is found.
+    /// Asynchronously returns a single entity matching the given predicate, or null if none match.
     /// </summary>
-    /// <param name="predicate">The condition to filter the entity.</param>
-    /// <returns>A task that represents the asynchronous operation. The task result contains the entity if found, otherwise null.</returns>
+    /// <param name="predicate">The condition to match.</param>
+    /// <returns>A task representing the asynchronous operation, containing a single entity or null.</returns>
     Task<TEntity?> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate);
 
     /// <summary>
-    /// Adds a new entity to the repository asynchronously.
+    /// Asynchronously adds an entity to the repository.
     /// </summary>
     /// <param name="entity">The entity to add.</param>
-    /// <returns>A task that represents the asynchronous operation.</returns>
     Task AddAsync(TEntity entity);
 
     /// <summary>
-    /// Adds multiple entities to the repository asynchronously.
+    /// Asynchronously adds multiple entities to the repository.
     /// </summary>
-    /// <param name="entities">The collection of entities to add.</param>
-    /// <returns>A task that represents the asynchronous operation.</returns>
+    /// <param name="entities">The entities to add.</param>
     Task AddRangeAsync(IEnumerable<TEntity> entities);
 
     /// <summary>
@@ -82,13 +79,13 @@ public interface IGenericRepository<TEntity> where TEntity : class
     /// <summary>
     /// Removes multiple entities from the repository.
     /// </summary>
-    /// <param name="entities">The collection of entities to remove.</param>
+    /// <param name="entities">The entities to remove.</param>
     void RemoveRange(IEnumerable<TEntity> entities);
 
     /// <summary>
-    /// Checks if any entity exists that matches the specified predicate.
+    /// Asynchronously checks whether any entity matches the given predicate.
     /// </summary>
-    /// <param name="predicate">The condition to check for existence.</param>
-    /// <returns>A task that represents the asynchronous operation. The task result contains true if a matching entity exists; otherwise, false.</returns>
+    /// <param name="predicate">The condition to match.</param>
+    /// <returns>A task representing the asynchronous operation, containing true if any entity matches; otherwise, false.</returns>
     Task<bool> IsExistValueForPropertyAsync(Expression<Func<TEntity, bool>> predicate);
-}
+}

src/KSFramework/GenericRepository/IGenericRepository.cs

@@ -1,21 +1,34 @@
 using System.Linq.Expressions;
-using KSFramework.KSDomain.AggregatesHelper;
 using KSFramework.Pagination;
 
 namespace KSFramework.GenericRepository;
+
+/// <summary>
+/// Defines the contract for a generic repository to handle basic CRUD and query operations.
+/// </summary>
+/// <typeparam name="TEntity">The entity type.</typeparam>
 public interface IRepository<TEntity> where TEntity : class
 {
-    ValueTask<TEntity?> GetByIdAsync(object id);
-    Task<IEnumerable<TEntity>> GetAllAsync();
-    Task<PaginatedList<TEntity>> GetPagedAsync(int pageIndex, int pageSize, Expression<Func<TEntity, bool>>? where = null, string? orderBy = "", bool desc = false);
-    PaginatedList<TEntity> GetPaged(int pageIndex, int pageSize, Expression<Func<TEntity, bool>>? where = null, string? orderBy = "", bool desc = false);
-    IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate);
-    Task<TEntity?> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate);
     Task AddAsync(TEntity entity);
     Task AddRangeAsync(IEnumerable<TEntity> entities);
-
+    IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate, bool asNoTracking = true);
+    Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true);
+    Task<PaginatedList<TEntity>> GetPagedAsync(
+        int pageIndex,
+        int pageSize,
+        Expression<Func<TEntity, bool>>? where = null,
+        string? orderBy = "",
+        bool desc = false);
+    PaginatedList<TEntity> GetPaged(
+        int pageIndex,
+        int pageSize,
+        Expression<Func<TEntity, bool>>? where = null,
+        string? orderBy = "",
+        bool desc = false);
+    ValueTask<TEntity?> GetByIdAsync(object id);
     void Remove(TEntity entity);
     void RemoveRange(IEnumerable<TEntity> entities);
+    Task<TEntity?> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate);
     Task<bool> IsExistValueForPropertyAsync(Expression<Func<TEntity, bool>> predicate);
-
+    void Update(TEntity entity);
 }

src/KSFramework/GenericRepository/IRepository.cs

@@ -1,76 +1,56 @@
 using System.Linq.Expressions;
-using KSFramework.KSDomain.AggregatesHelper;
 using KSFramework.Pagination;
 using Microsoft.EntityFrameworkCore;
 
 namespace KSFramework.GenericRepository;
+
 /// <summary>
-/// Provides a base implementation of the generic repository pattern for entity operations.
+/// Provides a base implementation of the <see cref="IGenericRepository{TEntity}"/> interface using Entity Framework Core.
 /// </summary>
 /// <typeparam name="TEntity">The type of the entity.</typeparam>
-public abstract class Repository<TEntity> : IRepository<TEntity> where TEntity : class
+public abstract class Repository<TEntity> : IGenericRepository<TEntity> where TEntity : class
 {
     private readonly DbContext Context;
-    protected DbSet<TEntity> Entity;
+    /// <summary>
+    /// Gets the underlying <see cref="DbSet{TEntity}"/> for querying and persisting entities.
+    /// </summary>
+    protected readonly DbSet<TEntity> Entity;
 
     /// <summary>
-    /// Initializes a new instance of the Repository class.
+    /// Initializes a new instance of the <see cref="Repository{TEntity}"/> class.
     /// </summary>
     /// <param name="context">The database context.</param>
     protected Repository(DbContext context)
     {
-        this.Context = context;
-        Entity = Context.Set<TEntity>();
+        Context = context;
+        Entity = context.Set<TEntity>();
     }
 
-    /// <summary>
-    /// Adds a new entity to the repository asynchronously.
-    /// </summary>
-    /// <param name="entity">The entity to add.</param>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <inheritdoc />
     public virtual async Task AddAsync(TEntity entity)
     {
         await Entity.AddAsync(entity);
     }
 
-    /// <summary>
-    /// Adds multiple entities to the repository asynchronously.
-    /// </summary>
-    /// <param name="entities">The collection of entities to add.</param>
-    /// <returns>A task representing the asynchronous operation.</returns>
+    /// <inheritdoc />
     public virtual async Task AddRangeAsync(IEnumerable<TEntity> entities)
     {
         await Entity.AddRangeAsync(entities);
     }
 
-    /// <summary>
-    /// Finds entities that match the specified predicate.
-    /// </summary>
-    /// <param name="predicate">The condition to filter entities.</param>
-    /// <returns>A collection of entities that match the condition.</returns>
+    /// <inheritdoc />
     public virtual IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate)
     {
         return Entity.Where(predicate);
     }
 
-    /// <summary>
-    /// Retrieves all entities asynchronously.
-    /// </summary>
-    /// <returns>A task representing the asynchronous operation, containing all entities.</returns>
+    /// <inheritdoc />
     public virtual async Task<IEnumerable<TEntity>> GetAllAsync()
     {
         return await Entity.ToListAsync();
     }
 
-    /// <summary>
-    /// Retrieves a paginated list of entities asynchronously.
-    /// </summary>
-    /// <param name="pageIndex">The index of the page to retrieve.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="where">Optional predicate to filter the entities.</param>
-    /// <param name="orderBy">Optional property name to order the results by.</param>
-    /// <param name="desc">Optional flag to indicate descending order.</param>
-    /// <returns>A task representing the asynchronous operation, containing a paginated list of entities.</returns>
+    /// <inheritdoc />
     public virtual async Task<PaginatedList<TEntity>> GetPagedAsync(int pageIndex, int pageSize, Expression<Func<TEntity, bool>>? where = null, string? orderBy = "", bool desc = false)
     {
         var query = Entity.AsQueryable();
@@ -80,64 +60,38 @@ public virtual async Task<PaginatedList<TEntity>> GetPagedAsync(int pageIndex, i
         return await PaginatedList<TEntity>.CreateAsync(query, pageIndex, pageSize, where, orderBy, desc);
     }
 
-    /// <summary>
-    /// Retrieves a paginated list of entities synchronously.
-    /// </summary>
-    /// <param name="pageIndex">The index of the page to retrieve.</param>
-    /// <param name="pageSize">The size of the page.</param>
-    /// <param name="where">Optional predicate to filter the entities.</param>
-    /// <param name="orderBy">Optional property name to order the results by.</param>
-    /// <param name="desc">Optional flag to indicate descending order.</param>
-    /// <returns>A paginated list of entities.</returns>
+    /// <inheritdoc />
     public virtual PaginatedList<TEntity> GetPaged(int pageIndex, int pageSize, Expression<Func<TEntity, bool>>? where = null, string? orderBy = "", bool desc = false)
     {
         var query = Entity.AsQueryable();
         return PaginatedList<TEntity>.Create(query, pageIndex, pageSize, where, orderBy, desc);
     }
 
-    /// <summary>
-    /// Retrieves an entity by its identifier asynchronously.
-    /// </summary>
-    /// <param name="id">The identifier of the entity.</param>
-    /// <returns>A task representing the asynchronous operation, containing the entity if found.</returns>
+    /// <inheritdoc />
     public virtual async ValueTask<TEntity?> GetByIdAsync(object id)
     {
         return await Entity.FindAsync(id);
     }
 
-    /// <summary>
-    /// Removes an entity from the repository.
-    /// </summary>
-    /// <param name="entity">The entity to remove.</param>
+    /// <inheritdoc />
     public virtual void Remove(TEntity entity)
     {
         Entity.Remove(entity);
     }
 
-    /// <summary>
-    /// Removes multiple entities from the repository.
-    /// </summary>
-    /// <param name="entities">The collection of entities to remove.</param>
+    /// <inheritdoc />
     public virtual void RemoveRange(IEnumerable<TEntity> entities)
     {
         Entity.RemoveRange(entities);
     }
 
-    /// <summary>
-    /// Retrieves a single entity that matches the specified predicate, or null if no match is found.
-    /// </summary>
-    /// <param name="predicate">The condition to filter the entity.</param>
-    /// <returns>A task representing the asynchronous operation, containing the entity if found.</returns>
+    /// <inheritdoc />
     public virtual async Task<TEntity?> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate)
     {
         return await Entity.SingleOrDefaultAsync(predicate);
     }
 
-    /// <summary>
-    /// Checks if any entity exists that matches the specified predicate.
-    /// </summary>
-    /// <param name="predicate">The condition to check for existence.</param>
-    /// <returns>A task representing the asynchronous operation, containing true if a matching entity exists.</returns>
+    /// <inheritdoc />
     public virtual async Task<bool> IsExistValueForPropertyAsync(Expression<Func<TEntity, bool>> predicate)
     {
         return await Entity.AnyAsync(predicate);

src/KSFramework/GenericRepository/Repository.cs

@@ -28,9 +28,6 @@ public GenericRepositoryTests()
     protected override void ConfigureServices(IServiceCollection services)
     {
         base.ConfigureServices(services);
-
-
-
         services.AddScoped<IGenericRepository<TestEntity>, TestGenericRepository>();
     }
 

tests/KSFramework/KSFramework.IntegrationTests/GenericRepository/GenericRepositoryTests.cs

@@ -39,11 +39,7 @@ protected virtual void ConfigureServices(IServiceCollection services)
             options.UseInMemoryDatabase("TestDatabase");
         });
 
-
-
-
-
-        services.AddScoped<DbContext, TestDbContext>();
+        services.AddScoped(provider => (DbContext)provider.GetRequiredService<TestDbContext>());
 
         // Register UnitOfWork and IUnitOfWork
         services.AddScoped<IUnitOfWork, UnitOfWork>();

tests/KSFramework/KSFramework.IntegrationTests/IntegrationTestBase.cs

@@ -1,5 +1,6 @@
 using KSFramework.KSMessaging;
 using KSFramework.KSMessaging.Abstraction;
+using KSFramework.KSMessaging.Extensions;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace KSFramework.IntegrationTests.Messaging;
@@ -40,9 +41,7 @@ protected override void ConfigureServices(IServiceCollection services)
     {
         base.ConfigureServices(services);
 
-        services.AddScoped<ICommandHandler<TestCommand, string>, TestCommandHandler>();
-        services.AddScoped<IQueryHandler<TestQuery, string>, TestQueryHandler>();
-        services.AddScoped<IMediator, Mediator>();
+        services.AddKSMediator(typeof(MediatorTests).Assembly);
     }
 
     [Fact]