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 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();
}
}
private async void OnReceivedMessage(MqttApplicationMessageReceivedEventArgs args)
{
// What about error handling?
try
{
using (await _asyncLock.WaitAsync())
{
Debug.WriteLine($"{args.ApplicationMessage.Topic}: {Encoding.UTF8.GetString(args.ApplicationMessage.Payload)}");
if (!args.ProcessingFailed)
{
await _receivedMessages.Next(args.ApplicationMessage);
}
}
}
catch (Exception e)
{
await _receivedMessages.Error(e);
}
}
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);
}
}
}