Write a helper that returns one page of items plus paging metadata.

• Null items are treated as empty.
• Page less than 1 becomes 1.
• Page size less than 1 becomes 10.
• Page size greater than 100 becomes 100.

I would normalize page and page size first, then compute total count and total pages. The skip amount is (page - 1) * pageSize. If the page is beyond the end, Skip and Take naturally return an empty list. I would mention that this helper is for in-memory lists; database paging should apply Skip and Take before materializing.

public sealed record PagedResult<T>(
    IReadOnlyList<T> Items,
    int Page,
    int PageSize,
    int TotalCount,
    int TotalPages);

public static PagedResult<T> ToPage<T>(IReadOnlyList<T>? items, int page, int pageSize)
{
    items ??= Array.Empty<T>();

    page = Math.Max(1, page);
    pageSize = Math.Clamp(pageSize <= 0 ? 10 : pageSize, 1, 100);

    var totalCount = items.Count;
    var totalPages = totalCount == 0
        ? 0
        : (int)Math.Ceiling(totalCount / (double)pageSize);

    var pageItems = items
        .Skip((page - 1) * pageSize)
        .Take(pageSize)
        .ToList();

    return new PagedResult<T>(pageItems, page, pageSize, totalCount, totalPages);
}

For an in-memory list, Skip and Take are O(n) in the skipped amount for general enumerables, but with a list this is acceptable for helper-level usage. Space is O(pageSize) for the returned page.

• Null item list.
• Empty list.
• Page beyond total pages.
• Invalid page and page size.
• Total count not divisible by page size.

• Use 0 items to verify total pages behavior.
• Use 21 items and page size 10 to catch ceiling math.
• Use huge page size to verify clamping.

• Using integer division and losing the final partial page.
• Forgetting page numbers are 1-based.
• Applying in-memory paging after loading a huge database table.
• Returning no metadata, making the API hard to use.