public async void Normal_2_Consumers() { var push = new MulticastAsyncEnumerable <int>(); var en1 = push.GetAsyncEnumerator(); var task1 = Task.Run(async() => { await en1.AssertResult(1, 2, 3, 4, 5); }); var en2 = push.GetAsyncEnumerator(); 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 void Error_2_Consumers() { var push = new MulticastAsyncEnumerable <int>(); 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 Push() { for (var i = 0; i < 10; i++) { var push = new MulticastAsyncEnumerable <int>(); var en = AsyncEnumerable.Merge( push.Filter(v => v % 2 == 0), push.Filter(v => v % 2 != 0) ) .ToListAsync(); var t = Task.Run(async() => { for (var j = 0; j < 100_000; j++) { await push.Next(j); } await push.Complete(); }); var list = await en; await t; var set = new HashSet <int>(list); Assert.Equal(100_000, set.Count); } }
public async void Error_No_Consumers() { var push = new MulticastAsyncEnumerable <int>(); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Error(new InvalidOperationException()); await push.AssertFailure(typeof(InvalidOperationException)); }
public async void Normal_No_Consumers() { var push = new MulticastAsyncEnumerable <int>(); for (var i = 1; i <= 5; i++) { await push.Next(i); } await push.Complete(); await push.AssertResult(); }
public async void Error() { var push = new MulticastAsyncEnumerable <int>(); var t1 = push.AssertFailure(typeof(InvalidOperationException)); var t2 = push.AssertFailure(typeof(InvalidOperationException)); await AsyncEnum.Error <int>(new InvalidOperationException()) .Consume(push); await t1; await t2; }
public async void Normal() { var push = new MulticastAsyncEnumerable <int>(); var t1 = push.AssertResult(1, 2, 3, 4, 5); var t2 = push.AssertResult(1, 2, 3, 4, 5); await AsyncEnumerable.Range(1, 5) .Consume(push); await t1; await t2; }
public async void HasConsumers() { var push = new MulticastAsyncEnumerable <int>(); Assert.False(push.HasConsumers); var en = push.GetAsyncEnumerator(); Assert.True(push.HasConsumers); await en.DisposeAsync(); Assert.False(push.HasConsumers); }
/// <summary> /// Kind of Multiplexer to multiple consumers (multiple enumeration) to provide the the same results /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public static IAsyncEnumerable <T> ToMulticastQueue <T>(this IAsyncEnumerable <T> source, CancellationToken cancellationToken = default) { return(ToMulticastQueueImpl().HandleInDispatcher(cancellationToken)); IAsyncEnumerable <T> ToMulticastQueueImpl() { var queue = new MulticastAsyncEnumerable <T>(); FillQueue(source, queue, cancellationToken); return(queue); } }
public IAsyncEnumerator <TResult> GetAsyncEnumerator() { var subject = new MulticastAsyncEnumerable <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 MulticastAsyncEnumerable <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 Normal() { var push = new MulticastAsyncEnumerable <int>(); var en = push.Latest().GetAsyncEnumerator(); try { await push.Next(1); Assert.True(await en.MoveNextAsync()); Assert.Equal(1, en.Current); await push.Next(2); await push.Next(3); await Task.Delay(200); Assert.True(await en.MoveNextAsync()); Assert.Equal(3, en.Current); await push.Next(4); await push.Complete(); Assert.True(await en.MoveNextAsync()); Assert.Equal(4, en.Current); Assert.False(await en.MoveNextAsync()); } finally { await en.DisposeAsync(); } }
public async void Normal_One_Consumer() { var push = new MulticastAsyncEnumerable <int>(); var en1 = push.GetAsyncEnumerator(default);
public AsyncEnumMqttClient(IMqttClient mqttClient, IMqttNetLogger logger) : base(mqttClient, logger) { ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(OnReceivedMessage); _receivedMessages = new MulticastAsyncEnumerable <MqttApplicationMessage>(); }
public IAsyncEnumerable <TResult> ExecuteParallelAsync(IAsyncEnumerable <AsyncStreamQueueItem <TResult, TSource> > inputItems, int maxConcurrentTasks, CancellationToken cancellationToken) { var throttler = new SemaphoreSlim(maxConcurrentTasks); var nextLock = new SemaphoreSlim(1, 1); var multicastStream = new MulticastAsyncEnumerable <TResult>(); HashSet <Task> runningStreams = new HashSet <Task>(); HandleInputStreams(); return(multicastStream); async void HandleInputStreams() { try { await foreach (AsyncStreamQueueItem <TResult, TSource> inputItem in inputItems.WithCancellation(cancellationToken)) { var stream = ExecuteItem(throttler, inputItem, cancellationToken); lock (runningStreams) { runningStreams.Add(ConsumeSubStream(stream)); } } await Task.WhenAll(runningStreams); await nextLock.WaitAsync(cancellationToken); try { await multicastStream.Complete(); } finally { nextLock.Release(); } } catch (Exception e) { await multicastStream.Error(e); } } async Task ConsumeSubStream(IAsyncEnumerable <TResult> source) { try { await foreach (var item in source.WithCancellation(cancellationToken)) { await nextLock.WaitAsync(cancellationToken); try { await multicastStream.Next(item); } finally { nextLock.Release(); } } } catch (Exception e) { await multicastStream.Error(e); } } }