Add CancellationToken to GenericRepository GetPaged methods

Author: A-Programmer

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>

src/KSFramework/GenericRepository/IGenericRepository.cs

@@ -13,13 +13,15 @@ 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);
 
     /// <summary>
     /// 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.

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);
     }