yeah69 / bff.datavirtualizingcollection Goto Github PK

DataVirtualizingCollectionBuilder
				.Build<DetailModel>
				(
					100,
					_notificationScheduler,
					_defaultScheduler
				)
				.NonPreloading()
				.Hoarding()
				.TaskBasedFetchers((offset, count, CancellationToken cancellationToken) => , ( CancellationToken cancellationToken) => )

ThrottledLifoPageRequests().AsyncIndexAccess((a, b) => {
                        return new T();
                    });

#region

using System;
using System.Collections.Generic;
using System.Reactive.Concurrency;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using BFF.DataVirtualizingCollection.DataVirtualizingCollection;

#endregion

namespace ConsoleApp11
{
	internal static class Program
	{
		public static int Version = 1;
		private const int NumberItem = 5;
		private static readonly TimeSpan Delay = TimeSpan.FromSeconds(1);
		private static readonly TimeSpan EpsilonDelay = Delay / 10;
		private static TestAsyncEnumerable testAsyncEnumerable;
		private static IDataVirtualizingCollection<int> dataVirtualizingCollection;
		private static async Task Main()
		{
			testAsyncEnumerable = new TestAsyncEnumerable(NumberItem, Delay);

			dataVirtualizingCollection = DataVirtualizingCollectionBuilder.Build<int>
				(
					10,
					new TaskPoolScheduler(Task.Factory)
				)
				.NonPreloading()
				.Hoarding()
				.AsyncEnumerableBasedFetchers(PageFetcher, CountFetcher)
				.AsyncIndexAccess((_, _) => -2);

			await Task.Delay(EpsilonDelay);
			//problem not show CountFetcher cancel
			dataVirtualizingCollection.Reset();
			Version++;
			await Task.Delay(Delay + EpsilonDelay);
			var dataVirtualizing = dataVirtualizingCollection[0];
			await Task.Delay(2 * Delay + EpsilonDelay);
			//problem not show PageFetcher cancel
			Version++;
			dataVirtualizingCollection.Reset();
			//problem not run PageFetcher version 3 
			dataVirtualizing = dataVirtualizingCollection[0];
			Console.WriteLine("End");
			Console.ReadKey();
		}
		private static async Task<int> CountFetcher(CancellationToken cancellationToken)
		{
			var version = Version;
			try
			{
				
				Console.WriteLine($"{nameof(CountFetcher)} begin {nameof(Version)}={version}");
				await Task.Delay(Delay, cancellationToken);
				Console.WriteLine($"{nameof(CountFetcher)} end {nameof(Version)}={version}");

				return NumberItem;
			}
			catch (OperationCanceledException)
			{
				Console.WriteLine($"{nameof(CountFetcher)} cancel {nameof(Version)}={version}");

				throw;
			}
		}
		private static async IAsyncEnumerable<int> PageFetcher
		(
			int offset,
			int count,
			[EnumeratorCancellation] CancellationToken cancellationToken
		)
		{
			var version = Version;
			Console.WriteLine($"{nameof(PageFetcher)} begin {nameof(Version)}={version}");

			await foreach (var item in testAsyncEnumerable.WithCancellation(cancellationToken))
			{
				yield return item;
			}

			Console.WriteLine($"{nameof(PageFetcher)} end {nameof(Version)}={version}");
		}
	}

	public class TestAsyncEnumerable : IAsyncEnumerable<int>
	{
		private readonly int _number;
		private readonly TimeSpan _delay;
		public TestAsyncEnumerable(int number, TimeSpan delay)
		{
			_number = number;
			_delay = delay;
		}
		public IAsyncEnumerator<int> GetAsyncEnumerator
		(
			CancellationToken cancellationToken
		) => new TestAsyncEnumerator(_number, _delay, Program.Version, cancellationToken);
	}

	public class TestAsyncEnumerator : IAsyncEnumerator<int>
	{
		private readonly int _number;
		private readonly TimeSpan _timeSpan;
		private readonly int _version;
		private readonly CancellationToken _cancellationToken;
		public TestAsyncEnumerator(int number, TimeSpan timeSpan, int version, CancellationToken cancellationToken)
		{
			_number = number;
			_timeSpan = timeSpan;
			_version = version;
			_cancellationToken = cancellationToken;
		}
		public int Current { get; private set; } = -1;
		public ValueTask DisposeAsync()
		{
			Console.WriteLine($"{nameof(DisposeAsync)} {nameof(Version)}={_version}");

			return default;
		}
		public async ValueTask<bool> MoveNextAsync()
		{
			try
			{
				Console.WriteLine($"before {nameof(MoveNextAsync)} {nameof(Current)} {Current} {nameof(Version)}={_version}");
				await Task.Delay(_timeSpan, _cancellationToken);
				var current = Current + 1;

				if (current >= _number)
				{
					Console.WriteLine($"end {nameof(MoveNextAsync)} {nameof(Current)} {Current} {nameof(Version)}={_version}");

					return false;
				}

				Current = current;
				Console.WriteLine($"after {nameof(MoveNextAsync)} {nameof(Current)} {Current} {nameof(Version)}={_version}");

				return true;
			}
			catch (OperationCanceledException)
			{
				Console.WriteLine($"{nameof(TestAsyncEnumerator)} is canceled {nameof(Version)}={_version}");

				throw;
			}
		}
	}
}

public IAsyncOnlyIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> TaskBasedFetchers(
      Func<int, int, CancellationToken, IAsyncEnumerable<TItem>> pageFetcherAsync,
      Func<CancellationToken, Task<int>> countFetcherAsync)
{
}

public IIndexAccessBehaviorCollectionBuilder<TItem, TVirtualizationKind> NonTaskBasedFetchers(
      Func<int, int, IEnumerableT<Item>> pageFetcher,
      Func<int> countFetcher)
{
}