public async void Unbounded_2_Consumers() { var push = new ReplayAsyncEnumerable <int>(); var en1 = push.GetAsyncEnumerator(); var en2 = push.GetAsyncEnumerator(); var task1 = Task.Run(async() => { await en1.AssertResult(1, 2, 3, 4, 5); }); var task2 = Task.Run(async() => { await en2.AssertResult(1, 2, 3, 4, 5); }); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Complete(); await task1; await task2; }
public async Task PushToLimitedListWithFunc() { var asyncEnum = new ReplayAsyncEnumerable <int>(); var list = new List <int>(); var max = 5; var task = asyncEnum.PushToList(list, () => max).LastAsync(); Assert.Empty(list); for (int i = 0; i < 7; i++) { await asyncEnum.Next(i); } await Task.Delay(500); Assert.Equal(5, list.Count); max = 2; for (int i = 0; i < 4; i++) { await asyncEnum.Next(i); } await asyncEnum.Complete(); await task; Assert.Equal(2, list.Count); }
public async void TimedSized_2_Consumers_Error() { var push = new ReplayAsyncEnumerable <int>(10, TimeSpan.FromHours(1)); var en1 = push.GetAsyncEnumerator(); var en2 = push.GetAsyncEnumerator(); var task1 = Task.Run(async() => { await en1.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5); }); var task2 = Task.Run(async() => { await en2.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5); }); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Error(new InvalidOperationException()); await task1; await task2; }
public async void Unbounded_No_Consumers() { var push = new ReplayAsyncEnumerable <int>(); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Complete(); await push.AssertResult(1, 2, 3, 4, 5); await push.AssertResult(1, 2, 3, 4, 5); }
public async void Unbounded_No_Consumers_Error() { var push = new ReplayAsyncEnumerable <int>(); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Error(new InvalidOperationException()); await push.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5); await push.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5); }
public async void TimedSized_No_Consumers_Error() { var push = new ReplayAsyncEnumerable <int>(10, TimeSpan.FromHours(1)); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Error(new InvalidOperationException()); await push.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5); await push.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5); }
public async void TimedSized_No_Consumers() { var push = new ReplayAsyncEnumerable <int>(10, TimeSpan.FromHours(1)); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Complete(); await push.AssertResult(1, 2, 3, 4, 5); await push.AssertResult(1, 2, 3, 4, 5); }
public async void HasConsumers() { var push = new ReplayAsyncEnumerable <int>(); Assert.False(push.HasConsumers); var en = push.GetAsyncEnumerator(); Assert.True(push.HasConsumers); await en.DisposeAsync(); Assert.False(push.HasConsumers); }
/// <summary> /// Source stream will be cached for multiple enumerations of later consumers /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="maxSize">max Size of Queue, otherwise unbounded</param> /// <param name="cancellationToken"></param> /// <returns></returns> public static IAsyncEnumerable <T> ToReplayQueue <T>(this IAsyncEnumerable <T> source, int maxSize, CancellationToken cancellationToken = default) { return(ToReplayQueueImpl().HandleInDispatcher(cancellationToken)); IAsyncEnumerable <T> ToReplayQueueImpl() { var queue = new ReplayAsyncEnumerable <T>(maxSize); FillQueue(source, queue, cancellationToken); return(queue); } }
public async void Unbounded_Take() { var push = new ReplayAsyncEnumerable <int>(); var t1 = push.Take(1).AssertResult(1); var t2 = push.Take(2).AssertResult(1, 2); await push.Next(1); await push.Next(2); await t1; await t2; }
public async void SizedTimed_Long() { const long n = 1_000_000; var push = new ReplayAsyncEnumerable <long>(10, TimeSpan.FromHours(1)); var t = push .Reduce((a, b) => a + b) .AssertResult(n * (n + 1) / 2); for (var i = 1; i <= n; i++) { await push.Next(i); } await push.Complete(); await t; }
public IAsyncEnumerator <TResult> GetAsyncEnumerator() { var subject = new ReplayAsyncEnumerable <TSource>(); IAsyncEnumerable <TResult> result; try { result = _func(subject); } catch (Exception ex) { return(new Error <TResult> .ErrorEnumerator(ex)); } var en = new MulticastEnumerator <TSource, TResult>(_source.GetAsyncEnumerator(), subject, result.GetAsyncEnumerator()); return(en); }
public IAsyncEnumerator <TResult> GetAsyncEnumerator(CancellationToken cancellationToken) { var subject = new ReplayAsyncEnumerable <TSource>(); IAsyncEnumerable <TResult> result; try { result = _func(subject); } catch (Exception ex) { return(new Error <TResult> .ErrorEnumerator(ex)); } var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); var en = new MulticastEnumerator <TSource, TResult>(_source.GetAsyncEnumerator(cts.Token), subject, result.GetAsyncEnumerator(cancellationToken), cts); return(en); }
public async void Unbounded_One_Consumer_Error() { var push = new ReplayAsyncEnumerable <int>(); var en1 = push.GetAsyncEnumerator(); var task1 = Task.Run(async() => { await en1.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5); }); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Error(new InvalidOperationException()); await task1; }
public async void TimedSized_One_Consumer() { var push = new ReplayAsyncEnumerable <int>(10, TimeSpan.FromHours(1)); var en1 = push.GetAsyncEnumerator(); var task1 = Task.Run(async() => { await en1.AssertResult(1, 2, 3, 4, 5); }); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Complete(); await task1; }
public async void TimedSized_Bounded_1_Normal() { var push = new ReplayAsyncEnumerable <int>(1, TimeSpan.FromHours(1)); await push.Next(1); await push.Next(2); var t1 = push.AssertResult(2, 3, 4, 5); await push.Next(3); await push.Next(4); await push.Next(5); await push.Complete(); await t1; await push.AssertResult(5); }
public async void TimedSized_Long_Halfway() { const long n = 1_000_000; var push = new ReplayAsyncEnumerable <long>((int)n, TimeSpan.FromHours(1)); var t = default(ValueTask); for (var i = 1; i <= n; i++) { await push.Next(i); if (i * 2 == n) { t = push .Reduce((a, b) => a + b) .AssertResult(n * (n + 1) / 2); } } await push.Complete(); await t; }
public async void Sized_Bounded_2_Normal() { var push = new ReplayAsyncEnumerable <int>(2); await push.Next(1); await push.Next(2); await push.Next(3); var t1 = push.AssertResult(2, 3, 4, 5); await push.Next(4); await push.Next(5); await push.Complete(); await t1; await push.AssertResult(4, 5); }
public async void Timed_Bounded_1_Normal() { var timeNow = new [] { 0L }; var push = new ReplayAsyncEnumerable <int>(10, TimeSpan.FromMilliseconds(100), () => timeNow[0]); await push.Next(1); timeNow[0] += 100; await push.Next(2); var t1 = push.AssertResult(2, 3, 4, 5); timeNow[0] += 100; await push.Next(3); timeNow[0] += 100; await push.Next(4); timeNow[0] += 100; await push.Next(5); await push.Complete(); await t1; await push.AssertResult(5); timeNow[0] += 100; await push.AssertResult(); }
public async void Unbounded_One_Consumer() { var push = new ReplayAsyncEnumerable <int>(); var en1 = push.GetAsyncEnumerator(default);