Applying Pagination to a Sorted List c#

Learn how to efficiently implement sorted pagination in C# with a reusable SortedListPaginator class. Discover lazy initialization, encapsulated sorting, and flexible pagination design using interfaces like IPaginatedCollection<T> and IPage<T>. Perfect for handling large datasets with optimized performance!

Designing a system to handle paginated, sorted data efficiently requires balancing flexibility, performance, and usability. In this article, we will create a class named SortedListPaginator that implements the IPaginatedCollection<T> interface. The core idea is to encapsulate the logic of sorting and pagination, ensuring that consumers do not need to worry about these details.

---

Overview of the Design

1. Input and Sorting:

   • The class takes an unordered sequence as input.
   • It ensures the sequence is sorted based on a custom criterion provided by the caller.

2. Lazy Initialization:

   • Sorting is deferred until explicitly required, leveraging the Lazy<T> class to optimize performance.

3. Read-Only Behavior:

   • Once sorted, the data becomes read-only, ensuring it can be safely shared across collaborating objects.

4. Pagination:

   • The sorted data is divided into pages, each represented by a concrete implementation of the IPage<T> interface.

---

The Key Components

IPaginatedCollection Interface

Defines the contract for the collection, allowing access to sorted pages and their metadata.

public interface IPaginatedCollection<T> : IEnumerable<IPage<T>>
{
    int PageCount { get; }
    IPage<T> this[int index] { get; }
}

IPage Interface

Represents a single page, exposing its content and metadata.

public interface IPage<T> : IEnumerable<T>
{
    int Ordinal { get; }
    int Count { get; }
    int PageSize { get; }
}

SortedListPaginator Class

The SortedListPaginator class encapsulates the logic for sorting and pagination.

---

Implementing the SortedListPaginator

Class Definition

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public class SortedListPaginator<T> : IPaginatedCollection<T>
{
    private readonly Lazy<List<T>> _sortedData;
    private readonly int _pageSize;

    public SortedListPaginator(IEnumerable<T> source, int pageSize, Func<T, object> sortKeySelector)
    {
        if (source == null) throw new ArgumentNullException(nameof(source));
        if (pageSize <= 0) throw new ArgumentOutOfRangeException(nameof(pageSize), "Page size must be greater than zero.");
        if (sortKeySelector == null) throw new ArgumentNullException(nameof(sortKeySelector));

        _pageSize = pageSize;

        // Lazy initialization for sorting
        _sortedData = new Lazy<List<T>>(() => source.OrderBy(sortKeySelector).ToList());
    }

    // Total number of pages
    public int PageCount => (int)Math.Ceiling((double)_sortedData.Value.Count / _pageSize);

    // Access a specific page
    public IPage<T> this[int index]
    {
        get
        {
            if (index < 0 || index >= PageCount)
                throw new ArgumentOutOfRangeException(nameof(index), "Page index is out of range.");

            var start = index * _pageSize;
            var pageData = _sortedData.Value.Skip(start).Take(_pageSize);
            return new Page<T>(pageData, index + 1, _pageSize);
        }
    }

    // Enumerator for pages
    public IEnumerator<IPage<T>> GetEnumerator()
    {
        for (int i = 0; i < PageCount; i++)
        {
            yield return this[i];
        }
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

The Page Class

Each page is represented by a Page<T> object that implements the IPage<T> interface.

public class Page<T> : IPage<T>
{
    private readonly List<T> _content;

    public Page(IEnumerable<T> content, int ordinal, int pageSize)
    {
        _content = content.ToList();
        Ordinal = ordinal;
        PageSize = pageSize;
    }

    public int Ordinal { get; }
    public int Count => _content.Count;
    public int PageSize { get; }

    public IEnumerator<T> GetEnumerator() => _content.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

---

How It Works

1. Lazy Initialization with Lazy<T>:

   • The Lazy<List<T>> ensures that sorting is deferred until the sorted data is accessed for the first time.
   • This approach avoids unnecessary computation if no pages are requested.

2. Sorting in the Constructor:

   • The sorting logic is encapsulated in a lambda function passed to the Lazy<T> instance.
   • The lambda executes the sorting (OrderBy) only once, ensuring efficiency.

3. Pagination Logic:

   • The this[int index] property calculates the appropriate segment of the sorted data and returns it as a Page<T> object.
   • The Page<T> object provides metadata and an enumerator for its content.

---

Usage Example

class Program
{
    static void Main()
    {
        // Sample data: unsorted numbers
        var data = new List<int> { 5, 3, 1, 4, 2, 10, 9, 8, 7, 6 };

        // Create a SortedListPaginator
        var paginator = new SortedListPaginator<int>(
            data,
            pageSize: 3,
            sortKeySelector: x => x // Sort by value
        );

        Console.WriteLine($"Total Pages: {paginator.PageCount}");

        foreach (var page in paginator)
        {
            Console.WriteLine($"Page {page.Ordinal}:");
            foreach (var item in page)
            {
                Console.WriteLine(item);
            }
        }
    }
}

---

Output

Total Pages: 4
Page 1:
1
2
3
Page 2:
4
5
6
Page 3:
7
8
9
Page 4:
10

---

Advantages of the Design

1. Efficiency:

   • Sorting occurs only once, and only when needed.
   • Lazy initialization minimizes overhead.

2. Encapsulation:

   • Sorting and pagination are fully encapsulated, freeing the consumer from dealing with these complexities.

3. Read-Only Behavior:

   • The sorted list is immutable, ensuring safe usage across different parts of the application.

4. Flexibility:

   • The design allows any sorting criterion through the Func<T, object> parameter.

---

Key Takeaways

• Lazy Initialization is a powerful pattern for deferring costly operations until needed.
• Separating the sorting logic from pagination improves maintainability and scalability.
• Designing with interfaces ensures flexibility and encourages reusable, testable code.

This approach provides an efficient and clean solution for handling sorted, paginated data in any application.