#9 Extending the builder API to support optionally configurable page request delaying behavior

Yeah69 · Yeah69 · commit 9c34ddac0b89 · 2021-02-27T10:39:30.000+01:00
diff --git a/BFF.DataVirtualizingCollection/DataVirtualizingCollectionBuilderBase.cs b/BFF.DataVirtualizingCollection/DataVirtualizingCollectionBuilderBase.cs
@@ -146,12 +146,36 @@ public TVirtualizationKind SyncIndexAccess()
             return GenerateCollection();
         }
 
+        public IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ImmediatePageRequests()
+        {
+            _asyncPageFetchScheduler = new ImmediateAsyncPageFetchScheduler();
+            return this;
+        }
+
+        public IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ThrottledLifoPageRequests() =>
+            ThrottledLifoPageRequests(_pageBackgroundScheduler);
+
+        public IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ThrottledLifoPageRequests(
+            TimeSpan throttleDueTime) =>
+            ThrottledLifoPageRequests(throttleDueTime, _pageBackgroundScheduler);
+
+        public IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ThrottledLifoPageRequests(
+            IScheduler pageRequestBackgroundScheduler) =>
+            ThrottledLifoPageRequests(TimeSpan.FromMilliseconds(200), pageRequestBackgroundScheduler);
+
+        public IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ThrottledLifoPageRequests(
+            TimeSpan throttleDueTime,
+            IScheduler pageRequestBackgroundScheduler)
+        {
+            _asyncPageFetchScheduler = new LifoAsyncPageFetchScheduler(throttleDueTime, pageRequestBackgroundScheduler);
+            return this;
+        }
+
         public TVirtualizationKind AsyncIndexAccess(
             Func<int, int, TItem> placeholderFactory)
         {
             _indexAccessBehavior = IndexAccessBehavior.Asynchronous;
             _placeholderFactory = placeholderFactory;
-            _asyncPageFetchScheduler = new LifoAsyncPageFetchScheduler();
             return GenerateCollection();
         }
 
@@ -275,7 +299,7 @@ IPage<TItem> NonPreloadingPageFetcherFactory(
             {
                 var taskBasedPageFetcher = _taskBasedPageFetcher ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
                 var placeholderFactory = _placeholderFactory ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
-                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
+                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? new ImmediateAsyncPageFetchScheduler();
                 return new AsyncTaskBasedPage<TItem>(
                     pageKey,
                     offset,
@@ -297,7 +321,7 @@ IPage<TItem> PreloadingPageFetcherFactory(
                 var taskBasedPageFetcher = _taskBasedPageFetcher ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
                 var preloadingPlaceholderFactory = _preloadingPlaceholderFactory ??
                                                    throw new NullReferenceException(UninitializedElementsExceptionMessage);
-                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
+                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? new ImmediateAsyncPageFetchScheduler();
                 return new AsyncTaskBasedPage<TItem>(
                     pageKey,
                     offset,
@@ -329,7 +353,7 @@ IPage<TItem> NonPreloadingPageFetcherFactory(
             {
                 var asyncEnumerableBasedPageFetcher = _asyncEnumerableBasedPageFetcher ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
                 var placeholderFactory = _placeholderFactory ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
-                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
+                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? new ImmediateAsyncPageFetchScheduler();
                 return new AsyncEnumerableBasedPage<TItem>(
                     pageKey,
                     offset,
@@ -351,7 +375,7 @@ IPage<TItem> PreloadingPageFetcherFactory(
                 var asyncEnumerableBasedPageFetcher = _asyncEnumerableBasedPageFetcher ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
                 var preloadingPlaceholderFactory = _preloadingPlaceholderFactory ??
                                                    throw new NullReferenceException(UninitializedElementsExceptionMessage);
-                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
+                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? new ImmediateAsyncPageFetchScheduler();
                 return new AsyncEnumerableBasedPage<TItem>(
                     pageKey,
                     offset,
@@ -383,7 +407,7 @@ IPage<TItem> NonPreloadingPageFetcherFactory(
             {
                 var pageFetcher = _pageFetcher ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
                 var placeholderFactory = _placeholderFactory ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
-                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
+                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? new ImmediateAsyncPageFetchScheduler();
                 return new AsyncNonTaskBasedPage<TItem>(
                     pageKey,
                     offset,
@@ -405,7 +429,7 @@ IPage<TItem> PreloadingPageFetcherFactory(
                 var pageFetcher = _pageFetcher ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
                 var preloadingPlaceholderFactory = _preloadingPlaceholderFactory ??
                                                    throw new NullReferenceException(UninitializedElementsExceptionMessage);
-                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? throw new NullReferenceException(UninitializedElementsExceptionMessage);
+                var asyncPageFetchScheduler = _asyncPageFetchScheduler ?? new ImmediateAsyncPageFetchScheduler();
                 return new AsyncNonTaskBasedPage<TItem>(
                     pageKey,
                     offset,
diff --git a/BFF.DataVirtualizingCollection/IBuilderInterfaces.cs b/BFF.DataVirtualizingCollection/IBuilderInterfaces.cs
@@ -143,6 +143,43 @@ IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> Async
     /// <typeparam name="TVirtualizationKind">IDataVirtualizingCollection or ISlidingWindow.</typeparam>
     public interface IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind>
     {
+        /// <summary>
+        /// Page request are triggered right after the generation of the page's placeholders.
+        /// <para/>
+        /// This is the default behavior. You won't need to call it explicitly.
+        /// </summary>
+        IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ImmediatePageRequests();
+
+        /// <summary>
+        /// Instead of triggering the page requests right away, they are delayed in throttling (Rx) manner and then triggered in Last In First Out (LIFO)/ stack-based manner.
+        /// <para/>
+        /// Default throttling due time is set to 200 ms and default scheduler is the same as for the page requests.
+        /// </summary>
+        IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ThrottledLifoPageRequests();
+
+        /// <summary>
+        /// Instead of triggering the page requests right away, they are delayed in throttling (Rx) manner and then triggered in Last In First Out (LIFO)/ stack-based manner.
+        /// <para/>
+        /// Default scheduler is the same as for the page requests.
+        /// </summary>
+        /// <param name="throttleDueTime">Time span which has to pass by without new page request until the collected page requests are triggered.</param>
+        IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ThrottledLifoPageRequests(TimeSpan throttleDueTime);
+
+        /// <summary>
+        /// Instead of triggering the page requests right away, they are delayed in throttling (Rx) manner and then triggered in Last In First Out (LIFO)/ stack-based manner.
+        /// <para/>
+        /// Default throttling due time is set to 200 ms.
+        /// </summary>
+        /// <param name="pageRequestBackgroundScheduler">A scheduler exclusively for page request delaying.</param>
+        IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ThrottledLifoPageRequests(IScheduler pageRequestBackgroundScheduler);
+
+        /// <summary>
+        /// Instead of triggering the page requests right away, they are delayed in throttling (Rx) manner and then triggered in Last In First Out (LIFO)/ stack-based manner.
+        /// </summary>
+        /// <param name="throttleDueTime">Time span which has to pass by without new page request until the collected page requests are triggered.</param>
+        /// <param name="pageRequestBackgroundScheduler">A scheduler exclusively for page request delaying.</param>
+        IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> ThrottledLifoPageRequests(TimeSpan throttleDueTime, IScheduler pageRequestBackgroundScheduler);
+        
         /// <summary>
         /// If item of requested index isn't loaded yet the collections will return a placeholder instead and emit a notification as soon as it arrives.
         /// Per default the initially configured background scheduler is taken for page and count fetches.
diff --git a/BFF.DataVirtualizingCollection/PageStorage/AsyncPageBase.cs b/BFF.DataVirtualizingCollection/PageStorage/AsyncPageBase.cs
@@ -47,8 +47,7 @@ internal AsyncPageBase(
             
             async Task FetchPage(CancellationToken ct)
             {
-                await Task.Delay(1, ct);
-                await asyncPageFetchScheduler.Schedule(offset, ct);
+                await asyncPageFetchScheduler.Schedule().ConfigureAwait(false);
                 ct.ThrowIfCancellationRequested();
                 await FetchPageInner(ct).ConfigureAwait(false);
             }
diff --git a/BFF.DataVirtualizingCollection/PageStorage/IAsyncPageFetchScheduler.cs b/BFF.DataVirtualizingCollection/PageStorage/IAsyncPageFetchScheduler.cs
@@ -1,10 +1,9 @@
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace BFF.DataVirtualizingCollection.PageStorage
 {
     internal interface IAsyncPageFetchScheduler
     {
-        Task Schedule(int offset, CancellationToken ct);
+        Task Schedule();
     }
 }
diff --git a/BFF.DataVirtualizingCollection/PageStorage/ImmediateAsyncPageFetchScheduler.cs b/BFF.DataVirtualizingCollection/PageStorage/ImmediateAsyncPageFetchScheduler.cs
@@ -1,10 +1,9 @@
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace BFF.DataVirtualizingCollection.PageStorage
 {
     internal class ImmediateAsyncPageFetchScheduler : IAsyncPageFetchScheduler
     {
-        public Task Schedule(int offset, CancellationToken ct) => Task.CompletedTask;
+        public Task Schedule() => Task.CompletedTask;
     }
 }
diff --git a/BFF.DataVirtualizingCollection/PageStorage/LifoAsyncPageFetchScheduler.cs b/BFF.DataVirtualizingCollection/PageStorage/LifoAsyncPageFetchScheduler.cs
@@ -2,39 +2,38 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reactive;
+using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace BFF.DataVirtualizingCollection.PageStorage
 {
     internal class LifoAsyncPageFetchScheduler : IAsyncPageFetchScheduler
     {
-        private readonly Stack<(int Offset, TaskCompletionSource<Unit> TCS)> _stack = new();
-        private readonly Subject<(int Offset, TaskCompletionSource<Unit> TCS)> _subject = new();
+        private readonly Stack<TaskCompletionSource<Unit>> _stack = new();
+        private readonly Subject<TaskCompletionSource<Unit>> _subject = new();
 
-        public LifoAsyncPageFetchScheduler()
-        {
+        public LifoAsyncPageFetchScheduler(
+            TimeSpan throttleDueTime,
+            IScheduler pageRequestBackgroundScheduler) =>
             _subject
+                .Synchronize()
                 .Do(tcs => _stack.Push(tcs))
-                .Throttle(TimeSpan.FromMilliseconds(1000))
+                .Throttle(throttleDueTime, pageRequestBackgroundScheduler)
                 .Subscribe(_ =>
                 {
-                    Console.WriteLine("Throttle Emit");
                     while (_stack.Any())
                     {
-                        var (offset, tcs) = _stack.Pop();
-                        Console.WriteLine($"Pop: {offset}");
+                        var tcs = _stack.Pop();
                         tcs.SetResult(Unit.Default);
                     }
                 });
-        }
-        
-        public Task Schedule(int offset, CancellationToken ct)
+
+        public Task Schedule()
         {
             var taskCompletionSource = new TaskCompletionSource<Unit>();
-            _subject.OnNext((offset, taskCompletionSource));
+            _subject.OnNext(taskCompletionSource);
             return taskCompletionSource.Task;
         }
     }
diff --git a/Sample.Model/BackendAccesses/AllNumbersFakeBackendAccess.cs b/Sample.Model/BackendAccesses/AllNumbersFakeBackendAccess.cs
@@ -11,11 +11,7 @@ internal class AllNumbersFakeBackendAccess : IAllNumbersFakeBackendAccess
     {
         public string Name => "All Positive Numbers";
 
-        public int[] PageFetch(int pageOffset, int pageSize)
-        {
-            Console.WriteLine(pageOffset);
-            return Enumerable.Range(pageOffset, pageSize).ToArray();
-        }
+        public int[] PageFetch(int pageOffset, int pageSize) => Enumerable.Range(pageOffset, pageSize).ToArray();
 
         public int PlaceholderFetch(int _, int __)
         {
diff --git a/Sample.Model/BackendAccesses/HighWorkloadFakeBackendAccess.cs b/Sample.Model/BackendAccesses/HighWorkloadFakeBackendAccess.cs
@@ -16,15 +16,12 @@ internal class HighWorkloadFakeBackendAccess : IHighWorkloadFakeBackendAccess
         
         public string Name => "High Workload Simulation";
 
-        public ISomeWorkloadObject[] PageFetch(int pageOffset, int pageSize)
-        {
-            Console.WriteLine(pageOffset);
-            return Enumerable
+        public ISomeWorkloadObject[] PageFetch(int pageOffset, int pageSize) =>
+            Enumerable
                 .Range(pageOffset, pageSize)
                 .Select(i => (ISomeWorkloadObject) new HighWorkloadObject(i))
                 .ToArray();
-        }
-        
+
         public ISomeWorkloadObject PlaceholderFetch(int _, int __)
         {
             return Placeholder;
diff --git a/Sample.Model/BackendAccesses/MillionNumbersBackendAccess.cs b/Sample.Model/BackendAccesses/MillionNumbersBackendAccess.cs
@@ -19,11 +19,7 @@ public MillionNumbersBackendAccess(
         
         public string Name => "A Million Numbers Accessed Through Sqlite";
 
-        public long[] PageFetch(int pageOffset, int pageSize)
-        {
-            Console.WriteLine(pageOffset);
-            return _fetchMillionNumbersFromBackend.FetchPage(pageOffset, pageSize);
-        }
+        public long[] PageFetch(int pageOffset, int pageSize) => _fetchMillionNumbersFromBackend.FetchPage(pageOffset, pageSize);
 
         public long PlaceholderFetch(int _, int __)
         {
diff --git a/Sample.Model/BackendAccesses/ProfilesFakeBackendAccess.cs b/Sample.Model/BackendAccesses/ProfilesFakeBackendAccess.cs
@@ -13,14 +13,11 @@ internal class ProfilesFakeBackendAccess : IProfilesFakeBackendAccess
         
         public string Name => "Profiles";
     
-        public IProfile[] PageFetch(int pageOffset, int pageSize)
-        {
-            Console.WriteLine(pageOffset);
-            return Enumerable
+        public IProfile[] PageFetch(int pageOffset, int pageSize) =>
+            Enumerable
                 .Range(pageOffset, pageSize)
                 .Select(i => ProfileStatic.ProfilePool[i % ProfileStatic.ProfilePool.Count])
                 .ToArray();
-        }
 
         public IProfile PlaceholderFetch(int _, int __)
         {
diff --git a/Sample.ViewModel/ViewModels/Decisions/FetcherKindViewModel.cs b/Sample.ViewModel/ViewModels/Decisions/FetcherKindViewModel.cs
@@ -35,6 +35,7 @@ IAsyncOnlyIndexAccessBehaviorCollectionBuilder<T, TVirtualizationKind> Configure
                 FetcherKind.NonTaskBased => builder.NonTaskBasedFetchers(
                     (offset, size, _) =>
                     {
+                        Console.WriteLine($"Client page fetch: {offset}");
                         Thread.Sleep(DelayPageFetcherInMilliseconds);
                         return backendAccess.PageFetch(offset, size);
                     },
@@ -44,27 +45,29 @@ IAsyncOnlyIndexAccessBehaviorCollectionBuilder<T, TVirtualizationKind> Configure
                         return backendAccess.CountFetch();
                     }),
                 FetcherKind.TaskBased => builder.TaskBasedFetchers(
-                    async (offset, size, _) =>
+                    async (offset, size, ct) =>
                     {
-                        await Task.Delay(DelayPageFetcherInMilliseconds);
+                        Console.WriteLine($"Client page fetch: {offset}");
+                        await Task.Delay(DelayPageFetcherInMilliseconds, ct);
                         return backendAccess.PageFetch(offset, size);
                     },
-                    async _ =>
+                    async ct =>
                     {
-                        await Task.Delay(DelayCountFetcherInMilliseconds);
+                        await Task.Delay(DelayCountFetcherInMilliseconds, ct);
                         return backendAccess.CountFetch();
                     }),
                 FetcherKind.AsyncEnumerableBased => builder.AsyncEnumerableBasedFetchers(
-                    (offset, size, _) =>
+                    (offset, size, ct) =>
                     {
+                        Console.WriteLine($"Client page fetch: {offset}");
                         var delay = DelayCountFetcherInMilliseconds / size - 1;
                         return Fetch();
 
                         async IAsyncEnumerable<T> Fetch()
                         {
-                            await foreach (var item in backendAccess.AsyncEnumerablePageFetch(offset, size))
+                            await foreach (var item in backendAccess.AsyncEnumerablePageFetch(offset, size).WithCancellation(ct).ConfigureAwait(false))
                             {
-                                await Task.Delay(delay);
+                                await Task.Delay(delay, ct);
                                 yield return item;
                             }
                         }

Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,7 @@ internal AsyncPageBase(`
`47`	`47`
`48`	`48`	`async Task FetchPage(CancellationToken ct)`
`49`	`49`	`{`
`50`		`- await Task.Delay(1, ct);`
`51`		`- await asyncPageFetchScheduler.Schedule(offset, ct);`
	`50`	`+ await asyncPageFetchScheduler.Schedule().ConfigureAwait(false);`
`52`	`51`	`ct.ThrowIfCancellationRequested();`
`53`	`52`	`await FetchPageInner(ct).ConfigureAwait(false);`
`54`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,9 @@`
`1`		`-using System.Threading;`
`2`	`1`	`using System.Threading.Tasks;`
`3`	`2`
`4`	`3`	`namespace BFF.DataVirtualizingCollection.PageStorage`
`5`	`4`	`{`
`6`	`5`	`internal interface IAsyncPageFetchScheduler`
`7`	`6`	`{`
`8`		`- Task Schedule(int offset, CancellationToken ct);`
	`7`	`+ Task Schedule();`
`9`	`8`	`}`
`10`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,7 @@ internal class AllNumbersFakeBackendAccess : IAllNumbersFakeBackendAccess`
`11`	`11`	`{`
`12`	`12`	`public string Name => "All Positive Numbers";`
`13`	`13`
`14`		`- public int[] PageFetch(int pageOffset, int pageSize)`
`15`		`- {`
`16`		`- Console.WriteLine(pageOffset);`
`17`		`- return Enumerable.Range(pageOffset, pageSize).ToArray();`
`18`		`- }`
	`14`	`+ public int[] PageFetch(int pageOffset, int pageSize) => Enumerable.Range(pageOffset, pageSize).ToArray();`
`19`	`15`
`20`	`16`	`public int PlaceholderFetch(int _, int __)`
`21`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ IAsyncOnlyIndexAccessBehaviorCollectionBuilder<T, TVirtualizationKind> Configure`
`35`	`35`	`FetcherKind.NonTaskBased => builder.NonTaskBasedFetchers(`
`36`	`36`	`(offset, size, _) =>`
`37`	`37`	`{`
	`38`	`+ Console.WriteLine($"Client page fetch: {offset}");`
`38`	`39`	`Thread.Sleep(DelayPageFetcherInMilliseconds);`
`39`	`40`	`return backendAccess.PageFetch(offset, size);`
`40`	`41`	`},`
`@@ -44,27 +45,29 @@ IAsyncOnlyIndexAccessBehaviorCollectionBuilder<T, TVirtualizationKind> Configure`
`44`	`45`	`return backendAccess.CountFetch();`
`45`	`46`	`}),`
`46`	`47`	`FetcherKind.TaskBased => builder.TaskBasedFetchers(`
`47`		`- async (offset, size, _) =>`
	`48`	`+ async (offset, size, ct) =>`
`48`	`49`	`{`
`49`		`- await Task.Delay(DelayPageFetcherInMilliseconds);`
	`50`	`+ Console.WriteLine($"Client page fetch: {offset}");`
	`51`	`+ await Task.Delay(DelayPageFetcherInMilliseconds, ct);`
`50`	`52`	`return backendAccess.PageFetch(offset, size);`
`51`	`53`	`},`
`52`		`- async _ =>`
	`54`	`+ async ct =>`
`53`	`55`	`{`
`54`		`- await Task.Delay(DelayCountFetcherInMilliseconds);`
	`56`	`+ await Task.Delay(DelayCountFetcherInMilliseconds, ct);`
`55`	`57`	`return backendAccess.CountFetch();`
`56`	`58`	`}),`
`57`	`59`	`FetcherKind.AsyncEnumerableBased => builder.AsyncEnumerableBasedFetchers(`
`58`		`- (offset, size, _) =>`
	`60`	`+ (offset, size, ct) =>`
`59`	`61`	`{`
	`62`	`+ Console.WriteLine($"Client page fetch: {offset}");`
`60`	`63`	`var delay = DelayCountFetcherInMilliseconds / size - 1;`
`61`	`64`	`return Fetch();`
`62`	`65`
`63`	`66`	`async IAsyncEnumerable<T> Fetch()`
`64`	`67`	`{`
`65`		`- await foreach (var item in backendAccess.AsyncEnumerablePageFetch(offset, size))`
	`68`	`+ await foreach (var item in backendAccess.AsyncEnumerablePageFetch(offset, size).WithCancellation(ct).ConfigureAwait(false))`
`66`	`69`	`{`
`67`		`- await Task.Delay(delay);`
	`70`	`+ await Task.Delay(delay, ct);`
`68`	`71`	`yield return item;`
`69`	`72`	`}`
`70`	`73`	`}`