From 7825fc1e3788b7b670e2a55bf4e16313d9204ef8 Mon Sep 17 00:00:00 2001
From: Kamran Sadin <MrSadin@Gmail.Com>
Date: Sun, 22 Jun 2025 00:38:08 +0330
Subject: [PATCH 1/2] Add CancellationToken to Repository methods

---
 .../GenericRepository/GenericRepository.cs    | 42 +++++++++++++------
 .../GenericRepository/IGenericRepository.cs   | 16 ++++---
 .../GenericRepository/IRepository.cs          | 18 +++++---
 3 files changed, 51 insertions(+), 25 deletions(-)

diff --git a/src/KSFramework/GenericRepository/GenericRepository.cs b/src/KSFramework/GenericRepository/GenericRepository.cs
index 448ecd9..3a109b1 100644
--- a/src/KSFramework/GenericRepository/GenericRepository.cs
+++ b/src/KSFramework/GenericRepository/GenericRepository.cs
@@ -23,20 +23,24 @@ public GenericRepository(DbContext context) : base(context)
     /// Gets an entity by its primary key.
     /// </summary>
     /// <param name="id">The entity ID.</param>
+    /// <param name="cancellationToken"></param>
     /// <returns>The entity if found; otherwise, null.</returns>
-    public async ValueTask<TEntity?> GetByIdAsync(object id)
+    public async ValueTask<TEntity?> GetByIdAsync(object id,
+        CancellationToken cancellationToken = default)
     {
-        return await DbSet.FindAsync(id);
+        return await DbSet.FindAsync(id, cancellationToken);
     }
 
     /// <summary>
     /// Gets all entities.
     /// </summary>
     /// <param name="asNoTracking">Whether to disable tracking for better performance.</param>
+    /// <param name="cancellationToken"></param>
     /// <returns>A list of all entities.</returns>
-    public async Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true)
+    public async Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true,
+        CancellationToken cancellationToken = default)
     {
-        return await AsQueryable(asNoTracking).ToListAsync();
+        return await AsQueryable(asNoTracking).ToListAsync(cancellationToken);
     }
 
     /// <summary>
@@ -48,7 +52,11 @@ public async Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true)
     /// <param name="orderBy">Property name to order by.</param>
     /// <param name="desc">Order descending if true.</param>
     /// <returns>A paginated list of entities.</returns>
-    public async Task<PaginatedList<TEntity>> GetPagedAsync(int pageIndex, int pageSize, Expression<Func<TEntity, bool>>? where = null, string? orderBy = "", bool desc = false)
+    public async Task<PaginatedList<TEntity>> GetPagedAsync(int pageIndex,
+        int pageSize,
+        Expression<Func<TEntity, bool>>? where = null,
+        string? orderBy = "",
+        bool desc = false)
     {
         var query = ApplyWhere(AsQueryable(), where);
         return await PaginatedList<TEntity>.CreateAsync(query, pageIndex, pageSize, where, orderBy, desc);
@@ -84,28 +92,34 @@ public IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate, bool
     /// Gets a single entity that matches the given predicate or null.
     /// </summary>
     /// <param name="predicate">The filter expression.</param>
+    /// <param name="cancellationToken"></param>
     /// <returns>The matching entity or null.</returns>
-    public async Task<TEntity?> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate)
+    public async Task<TEntity?> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate,
+        CancellationToken cancellationToken = default)
     {
-        return await DbSet.SingleOrDefaultAsync(predicate);
+        return await DbSet.SingleOrDefaultAsync(predicate, cancellationToken);
     }
 
     /// <summary>
     /// Adds a new entity asynchronously.
     /// </summary>
     /// <param name="entity">The entity to add.</param>
-    public async Task AddAsync(TEntity entity)
+    /// <param name="cancellationToken"></param>
+    public async Task AddAsync(TEntity entity,
+        CancellationToken cancellationToken = default)
     {
-        await DbSet.AddAsync(entity);
+        await DbSet.AddAsync(entity, cancellationToken);
     }
 
     /// <summary>
     /// Adds a range of entities asynchronously.
     /// </summary>
     /// <param name="entities">The entities to add.</param>
-    public async Task AddRangeAsync(IEnumerable<TEntity> entities)
+    /// <param name="cancellationToken"></param>
+    public async Task AddRangeAsync(IEnumerable<TEntity> entities,
+        CancellationToken cancellationToken = default)
     {
-        await DbSet.AddRangeAsync(entities);
+        await DbSet.AddRangeAsync(entities, cancellationToken);
     }
 
     /// <summary>
@@ -139,9 +153,11 @@ public void RemoveRange(IEnumerable<TEntity> entities)
     /// Determines whether any entity exists that matches the specified predicate.
     /// </summary>
     /// <param name="predicate">The condition to check.</param>
+    /// <param name="cancellationToken"></param>
     /// <returns>True if at least one entity exists; otherwise, false.</returns>
-    public async Task<bool> IsExistValueForPropertyAsync(Expression<Func<TEntity, bool>> predicate)
+    public async Task<bool> IsExistValueForPropertyAsync(Expression<Func<TEntity, bool>> predicate,
+        CancellationToken cancellationToken = default)
     {
-        return await DbSet.AnyAsync(predicate);
+        return await DbSet.AnyAsync(predicate, cancellationToken);
     }
 }
\ No newline at end of file
diff --git a/src/KSFramework/GenericRepository/IGenericRepository.cs b/src/KSFramework/GenericRepository/IGenericRepository.cs
index 52cd222..f769604 100644
--- a/src/KSFramework/GenericRepository/IGenericRepository.cs
+++ b/src/KSFramework/GenericRepository/IGenericRepository.cs
@@ -14,14 +14,14 @@ public interface IGenericRepository<TEntity> where TEntity : class
     /// </summary>
     /// <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);
+    ValueTask<TEntity?> GetByIdAsync(object id, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Asynchronously retrieves all entities.
     /// </summary>
     /// <param name="asNoTracking">Whether to track entities in change tracker.</param>
     /// <returns>A task containing all entities.</returns>
-    Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true);
+    Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Asynchronously retrieves a paginated list of entities with optional filtering and ordering.
@@ -68,19 +68,21 @@ PaginatedList<TEntity> GetPaged(
     /// </summary>
     /// <param name="predicate">The condition to match.</param>
     /// <returns>A task containing a single entity or null.</returns>
-    Task<TEntity?> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate);
+    Task<TEntity?> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Asynchronously adds an entity to the repository.
     /// </summary>
     /// <param name="entity">The entity to add.</param>
-    Task AddAsync(TEntity entity);
+    /// <param name="cancellationToken"></param>
+    Task AddAsync(TEntity entity, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Asynchronously adds multiple entities to the repository.
     /// </summary>
     /// <param name="entities">The entities to add.</param>
-    Task AddRangeAsync(IEnumerable<TEntity> entities);
+    /// <param name="cancellationToken"></param>
+    Task AddRangeAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Updates an existing entity in the repository.
@@ -104,6 +106,8 @@ PaginatedList<TEntity> GetPaged(
     /// Asynchronously checks whether any entity matches the given predicate.
     /// </summary>
     /// <param name="predicate">The condition to match.</param>
+    /// <param name="cancellationToken"></param>
     /// <returns>True if any entity matches; otherwise, false.</returns>
-    Task<bool> IsExistValueForPropertyAsync(Expression<Func<TEntity, bool>> predicate);
+    Task<bool> IsExistValueForPropertyAsync(Expression<Func<TEntity, bool>> predicate,
+        CancellationToken cancellationToken = default);
 }
\ No newline at end of file
diff --git a/src/KSFramework/GenericRepository/IRepository.cs b/src/KSFramework/GenericRepository/IRepository.cs
index 75bdaef..d099325 100644
--- a/src/KSFramework/GenericRepository/IRepository.cs
+++ b/src/KSFramework/GenericRepository/IRepository.cs
@@ -9,10 +9,13 @@ namespace KSFramework.GenericRepository;
 /// <typeparam name="TEntity">The entity type.</typeparam>
 public interface IRepository<TEntity> where TEntity : class
 {
-    Task AddAsync(TEntity entity);
-    Task AddRangeAsync(IEnumerable<TEntity> entities);
+    Task AddAsync(TEntity entity,
+        CancellationToken cancellationToken = default);
+    Task AddRangeAsync(IEnumerable<TEntity> entities,
+        CancellationToken cancellationToken = default);
     IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate, bool asNoTracking = true);
-    Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true);
+    Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true,
+        CancellationToken cancellationToken = default);
     Task<PaginatedList<TEntity>> GetPagedAsync(
         int pageIndex,
         int pageSize,
@@ -25,10 +28,13 @@ PaginatedList<TEntity> GetPaged(
         Expression<Func<TEntity, bool>>? where = null,
         string? orderBy = "",
         bool desc = false);
-    ValueTask<TEntity?> GetByIdAsync(object id);
+    ValueTask<TEntity?> GetByIdAsync(object id,
+        CancellationToken cancellationToken = default);
     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);
+    Task<TEntity?> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate,
+        CancellationToken cancellationToken = default);
+    Task<bool> IsExistValueForPropertyAsync(Expression<Func<TEntity, bool>> predicate,
+        CancellationToken cancellationToken = default);
     void Update(TEntity entity);
 }
\ No newline at end of file

From 1e212d666ed9562846301b33e4f4a69c4354c8ee Mon Sep 17 00:00:00 2001
From: Kamran Sadin <MrSadin@Gmail.Com>
Date: Sun, 22 Jun 2025 12:28:31 +0330
Subject: [PATCH 2/2] Add CancellationToken to GenericRepository GetPaged
 methods

---
 .../GenericRepository/GenericRepository.cs         |  6 ++++--
 .../GenericRepository/IGenericRepository.cs        |  6 +++++-
 src/KSFramework/Pagination/PaginatedList.cs        | 14 ++++++++++----
 3 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/src/KSFramework/GenericRepository/GenericRepository.cs b/src/KSFramework/GenericRepository/GenericRepository.cs
index 3a109b1..afad026 100644
--- a/src/KSFramework/GenericRepository/GenericRepository.cs
+++ b/src/KSFramework/GenericRepository/GenericRepository.cs
@@ -51,15 +51,17 @@ public async Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true,
     /// <param name="where">Optional filter expression.</param>
     /// <param name="orderBy">Property name to order by.</param>
     /// <param name="desc">Order descending if true.</param>
+    /// <param name="cancellationToken"></param>
     /// <returns>A paginated list of entities.</returns>
     public async Task<PaginatedList<TEntity>> GetPagedAsync(int pageIndex,
         int pageSize,
         Expression<Func<TEntity, bool>>? where = null,
         string? orderBy = "",
-        bool desc = false)
+        bool desc = false,
+        CancellationToken cancellationToken = default)
     {
         var query = ApplyWhere(AsQueryable(), where);
-        return await PaginatedList<TEntity>.CreateAsync(query, pageIndex, pageSize, where, orderBy, desc);
+        return await PaginatedList<TEntity>.CreateAsync(query, pageIndex, pageSize, where, orderBy, desc, cancellationToken);
     }
 
     /// <summary>
diff --git a/src/KSFramework/GenericRepository/IGenericRepository.cs b/src/KSFramework/GenericRepository/IGenericRepository.cs
index f769604..da8dcc5 100644
--- a/src/KSFramework/GenericRepository/IGenericRepository.cs
+++ b/src/KSFramework/GenericRepository/IGenericRepository.cs
@@ -13,6 +13,7 @@ public interface IGenericRepository<TEntity> where TEntity : class
     /// Asynchronously retrieves an entity by its unique identifier.
     /// </summary>
     /// <param name="id">The unique identifier of the entity.</param>
+    /// <param name="cancellationToken"></param>
     /// <returns>A task representing the asynchronous operation, containing the entity if found; otherwise, null.</returns>
     ValueTask<TEntity?> GetByIdAsync(object id, CancellationToken cancellationToken = default);
 
@@ -20,6 +21,7 @@ public interface IGenericRepository<TEntity> where TEntity : class
     /// Asynchronously retrieves all entities.
     /// </summary>
     /// <param name="asNoTracking">Whether to track entities in change tracker.</param>
+    /// <param name="cancellationToken"></param>
     /// <returns>A task containing all entities.</returns>
     Task<IEnumerable<TEntity>> GetAllAsync(bool asNoTracking = true, CancellationToken cancellationToken = default);
 
@@ -31,13 +33,15 @@ public interface IGenericRepository<TEntity> where TEntity : class
     /// <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>
+    /// <param name="cancellationToken"></param>
     /// <returns>A task 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);
+        bool desc = false,
+        CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Retrieves a paginated list of entities with optional filtering and ordering.
diff --git a/src/KSFramework/Pagination/PaginatedList.cs b/src/KSFramework/Pagination/PaginatedList.cs
index 7a053a8..470a8f5 100644
--- a/src/KSFramework/Pagination/PaginatedList.cs
+++ b/src/KSFramework/Pagination/PaginatedList.cs
@@ -37,8 +37,14 @@ public bool HasNextPage
         }
     }
 
-    public static async Task<PaginatedList<T>> CreateAsync(IQueryable<T> source, int pageIndex, int pageSize, Expression<Func<T, bool>>? where = null,
-                                                            string? orderBy = "", bool desc = false)
+    public static async Task<PaginatedList<T>> CreateAsync(
+        IQueryable<T> source,
+        int pageIndex,
+        int pageSize,
+        Expression<Func<T, bool>>? where = null,
+        string? orderBy = "",
+        bool desc = false,
+        CancellationToken cancellationToken = default)
     {
         if(where is null) where = x => true;
         
@@ -54,8 +60,8 @@ public static async Task<PaginatedList<T>> CreateAsync(IQueryable<T> source, int
             }
         }
         
-        var count = await source.CountAsync(where);
-        var items = await source.Where(where).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync();
+        var count = await source.CountAsync(where, cancellationToken);
+        var items = await source.Where(where).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync(cancellationToken);
         return new PaginatedList<T>(items, count, pageIndex, pageSize);
     }