Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Standalone version of the Sharpnado.Presentation.Forms paginator (it has no dependencies). It is totally crossplatform.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
namespace Sharpnado.Presentation.Paging
{
/// <summary>
/// Interface IInfiniteListLoader.
/// </summary>
public interface IInfiniteListLoader
{
/// <summary>
/// This method must be called by the UI element in charge of displaying data.
/// Per example, on android, a scroll listener can reference IInfiniteListLoader and call it from OnScroll.
/// The implementation execution time of this method must be transparent as it should return immediately and doesn't block the caller.
/// </summary>
/// <param name="lastVisibleIndex">Index of the last visible item.</param>
void OnScroll(int lastVisibleIndex);
}
public struct PageResult<TItem>
{
public static readonly PageResult<TItem> Empty = new PageResult<TItem>(0, new List<TItem>());
public PageResult(int totalCount, IReadOnlyList<TItem> items)
{
TotalCount = totalCount;
Items = items ?? new List<TItem>();
}
public int TotalCount { get; }
public IReadOnlyList<TItem> Items { get; }
public static bool operator ==(PageResult<TItem> p1, PageResult<TItem> p2)
{
return ReferenceEquals(p1.Items, p2.Items) && p1.TotalCount == p2.TotalCount;
}
public static bool operator !=(PageResult<TItem> p1, PageResult<TItem> p2)
{
return !ReferenceEquals(p1.Items, p2.Items) || p1.TotalCount != p2.TotalCount;
}
public bool Equals(PageResult<TItem> other)
{
return TotalCount == other.TotalCount && Equals(Items, other.Items);
}
public override bool Equals(object obj)
{
if (ReferenceEquals(null, obj))
{
return false;
}
return obj is PageResult<TItem> result && Equals(result);
}
public override int GetHashCode()
{
unchecked
{
return (TotalCount * 397) ^ (Items != null ? Items.GetHashCode() : 0);
}
}
}
/// <summary>
/// Component responsible for manually loading the pages of a service.
/// It also bears the responsibility of loading the next page when scrolling the infinite list.
/// This automatic loading feature is exposed by the IInfiniteListLoader interface.
/// And yes: it has 2 responsibilities, which goes against SRP, but it makes the component very efficient, simple and usable.
/// So *** SRP (well not generally speaking, but for this one time).
/// </summary>
public class Paginator<TResult> : IInfiniteListLoader, IDisposable
{
private const float LoadingThresholdDefault = 1f / 4;
private const int PageSizeDefault = 10;
private const int MaxItemCountDefault = 200;
private readonly object _syncRoot = new object();
private readonly int _maxItemCount;
private readonly Func<int, int, Task<PageResult<TResult>>> _pageSourceLoader;
private readonly Action<Task> _onTaskCompleted;
private readonly float _loadingThreshold;
private bool _isDisposed;
private List<TResult> _items;
private bool _refreshRequested;
private CancellationTokenSource _loadingTaskTokenSource;
/// <summary>
/// The paginator is a concrete component, it is usable directly by instantiation (please don't abuse DI :).
/// </summary>
/// <param name="pageSize">The page size for the data.</param>
/// <param name="maxItemCount">The maximum number of elements that the paginator can load.</param>
/// <param name="pageSourceLoader">
/// The func that will return the data. Here you have two options:
/// 1. The func calls the REST (or whatever) service, build ViewModels from the Models, then add them to collection the ObservableCollection.
/// The onTaskCompleted callback will be optional.
/// 2. The func still calls the domain service, but just returns the PageResult of Models.
/// The onTaskCompleted will create your ViewModels and add them to the ObservableCollection.
/// The two parameters of the Func are pageNumber and pageSize.
/// </param>
/// <param name="onTaskCompleted">
/// This callback is called at the end of each page loading, successful or not.
/// This is where you want to assign the retrieved items to your ObservableCollection.
/// </param>
/// <param name="loadingThreshold">
/// The list threshold from where the next page loading will be triggered (magic will occur in the OnScroll method of the IInfiniteListLoader interface)
/// This threshold stands for a percentage of the last page:
/// Let's say you have 40 items loaded in your List and page size is 10, if the threshold is 0.5,
/// the loading of the next page will be triggered when element 35 will become visible.
/// Default is 0.25. Requires loadingThreshold in [0,1].
/// </param>
public Paginator(
Func<int, int, Task<PageResult<TResult>>> pageSourceLoader,
Action<Task> onTaskCompleted = null,
int pageSize = PageSizeDefault,
int maxItemCount = MaxItemCountDefault,
float loadingThreshold = LoadingThresholdDefault)
{
Debug.Assert(pageSize > 0);
Debug.Assert(maxItemCount > 0);
Debug.Assert(loadingThreshold >= 0 && loadingThreshold <= 1);
Debug.WriteLine($"Building paginator with pageSize: {pageSize}, maxItemCount: {maxItemCount}, loadingThreshold: {loadingThreshold}");
_maxItemCount = maxItemCount;
_pageSourceLoader = pageSourceLoader;
_onTaskCompleted = onTaskCompleted;
_loadingThreshold = loadingThreshold;
PageSize = pageSize;
TotalCount = _maxItemCount;
Reset();
}
public Task<PageResult<TResult>> LoadingTask { get; private set; }
/// <summary>
/// Number of pages successfully loaded.
/// </summary>
public int PageLoadedCount { get; private set; }
/// <summary>
/// Number of items successfully loaded.
/// </summary>
public int LoadedCount => Items.Count;
public bool IsFull => LoadedCount >= TotalCount;
public int PageSize { get; }
public int TotalCount { get; private set; }
public int TotalRemoteCount { get; private set; }
public bool HasStarted => LoadingTask != null;
public bool IsLoadingSuccessfull => LoadingTask.Status == TaskStatus.RanToCompletion;
/// <summary>
/// True if the user requested a refresh of the list.
/// </summary>
public bool HasRefreshed
{
get
{
lock (_syncRoot)
{
return _refreshRequested;
}
}
}
public IReadOnlyList<TResult> Items => _items;
/// <summary>
/// Last page returned by the data source.
/// </summary>
public PageResult<TResult> LastResult { get; private set; }
public void Dispose()
{
if (_isDisposed)
{
return;
}
_isDisposed = true;
}
/// <summary>
/// This method must be called by the UI element in charge of displaying data.
/// Per example, on android, a scroll listener can reference this paginator as an IInfiniteListLoader and call it from OnScroll.
/// The call to this method is nearly transparent as it returns immediately and doesn't block the caller.
/// (benchmarked as 4 ticks for a call (10 000 ticks == 1ms)).
/// </summary>
public async void OnScroll(int lastVisibleIndex)
{
try
{
if (await ShouldLoadNextPage(lastVisibleIndex))
{
Debug.WriteLine($"Scrolled: loading more (max index of visible item {lastVisibleIndex})");
int pageToLoad = lastVisibleIndex / PageSize + 2;
await LoadPage(pageToLoad, calledFromScroll: true);
}
}
catch (Exception exception)
{
Debug.WriteLine($"Error in OnScroll task: {exception}");
}
}
/// <summary>
/// Launch the loading of a data page.
/// If a task is currently running, it gets discarded (callbacks won't be called).
/// If the first page loading is asked whereas one or several pages have already been loaded, a "refresh" is detected.
/// </summary>
/// <param name="pageNumber">The page number to load (pageNumber = 1 for the first page).</param>
/// <param name="calledFromScroll">True if LoadPage has been called from OnScroll method of the IInfiniteListLoader.</param>
public Task<PageResult<TResult>> LoadPage(int pageNumber, bool calledFromScroll = false)
{
Debug.Assert(pageNumber > 0);
Debug.Assert(
calledFromScroll || pageNumber == 1 || pageNumber == (PageLoadedCount + 1),
"The paginator can only load sequential pages");
Debug.WriteLine($"Requesting page n°{pageNumber} load, {PageLoadedCount} pages loaded so far");
lock (_syncRoot)
{
if (calledFromScroll)
{
if (pageNumber <= PageLoadedCount)
{
Debug.WriteLine(
$"Aborting IInfiniteListLoader call: only a direct call to LoadPage can lead to a refresh");
return Task.FromResult(PageResult<TResult>.Empty);
}
}
if (pageNumber > PageLoadedCount && IsFull)
{
Debug.WriteLine(
$"Cannot load page {pageNumber} total item count has already been reached ({TotalCount})");
return Task.FromResult(PageResult<TResult>.Empty);
}
if (pageNumber == 1 && PageLoadedCount > 0)
{
Debug.WriteLine("Refresh detected");
_refreshRequested = true;
}
else
{
_refreshRequested = false;
}
if (LoadingTask != null && !LoadingTask.IsCompleted)
{
// Cancels callbacks of previous task if not completed
_loadingTaskTokenSource.Cancel();
}
_loadingTaskTokenSource = new CancellationTokenSource();
LoadingTask = _pageSourceLoader(pageNumber, PageSize);
MonitorLoadingTask(_loadingTaskTokenSource.Token);
}
return LoadingTask;
}
private void MonitorLoadingTask(CancellationToken cancellationToken)
{
Task.Run(
async () =>
{
Debug.WriteLine("MonitorLoadingTask");
try
{
await LoadingTask;
if (cancellationToken.IsCancellationRequested)
{
Debug.WriteLine("Loading task has been canceled by user");
return;
}
OnPageRetrieved(LoadingTask);
}
catch (TaskCanceledException canceledException)
{
Debug.WriteLine($"Task has been canceled {canceledException}");
}
catch (Exception exception)
{
Debug.WriteLine($"Error in wrapped task {exception}");
}
})
.ContinueWith(task => OnTaskCompleted(LoadingTask), TaskScheduler.FromCurrentSynchronizationContext());
}
private void OnPageRetrieved(Task<PageResult<TResult>> task)
{
Debug.WriteLine("OnPageRetrieved()");
if (_isDisposed)
{
return;
}
var result = task.Result;
lock (_syncRoot)
{
LastResult = result;
Debug.WriteLine($"{result.Items.Count} items retrieved, total remote items is {result.TotalCount}");
if (_refreshRequested)
{
Reset();
}
TotalRemoteCount = result.TotalCount;
TotalCount = Math.Min(result.TotalCount, _maxItemCount);
PageLoadedCount++;
}
_items.AddRange(result.Items);
Debug.WriteLine($"{Items.Count} items in paginator collection, {PageLoadedCount} pages loaded");
Debug.Assert(PageLoadedCount > 0);
Debug.Assert(result.Items != null && _maxItemCount >= 0);
}
private void OnTaskCompleted(Task task)
{
Debug.WriteLine($"OnTaskCompleted( taskStatus: {task.Status} )");
if (_isDisposed)
{
return;
}
_onTaskCompleted?.Invoke(task);
}
private void Reset()
{
Debug.WriteLine("Resetting paginator");
PageLoadedCount = 0;
_items = new List<TResult>();
}
private Task<bool> ShouldLoadNextPage(int lastVisibleIndex)
{
return Task.Run(() =>
{
if (lastVisibleIndex < 0)
{
return false;
}
if (PageLoadedCount == 0)
{
// If no pages are loaded, there is nothing to scroll
return false;
}
if (IsFull)
{
// All messages are already loaded nothing to paginate
return false;
}
if (HasStarted && !LoadingTask.IsCompleted)
{
// Currently loading page
return false;
}
int itemsCount = LoadedCount;
return lastVisibleIndex >= (itemsCount - (PageSize * _loadingThreshold));
});
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.