async Task Test()
{
var _asyncQueue = new AsyncProducerConsumerQueue <int>();
// Producer code
await _asyncQueue.EnqueueAsync(7);
await _asyncQueue.EnqueueAsync(13);
_asyncQueue.CompleteAdding();
// Consumer code
// Displays "7" followed by "13".
while (await _asyncQueue.OutputAvailableAsync())
{
Trace.WriteLine(await _asyncQueue.DequeueAsync());
}
while (true)
{
int item;
try
{
item = await _asyncQueue.DequeueAsync();
}
catch (InvalidOperationException)
{
break;
}
Trace.WriteLine(item);
}
}
public async Task EmptyTwice()
{
var queue = new AsyncProducerConsumerQueue <int> (1);
await queue.EnqueueAsync(1);
await queue.DequeueAsync();
await queue.EnqueueAsync(1);
await queue.DequeueAsync();
}
public async Task CompleteWhilePendingEnqueue()
{
var queue = new AsyncProducerConsumerQueue <int> (1);
await queue.EnqueueAsync(5);
var enqueueTask = queue.EnqueueAsync(6);
queue.CompleteAdding();
Assert.AreEqual(5, await queue.DequeueAsync(), "#1");
await enqueueTask;
Assert.AreEqual(6, await queue.DequeueAsync(), "#2");
}
public async Task ConstructorWithCollection_AddsItems()
{
var queue = new AsyncProducerConsumerQueue <int>(new[] { 3, 5, 7 });
var result1 = await queue.DequeueAsync();
var result2 = await queue.DequeueAsync();
var result3 = await queue.DequeueAsync();
Assert.Equal(3, result1);
Assert.Equal(5, result2);
Assert.Equal(7, result3);
}
public async Task Should_receive_multiple_packets()
{
TcpTransport transport = CreateTcpTransport();
var receivedMessages = new AsyncProducerConsumerQueue <byte[]>();
transport.Subscribe(receivedMessages.Enqueue);
await transport.ConnectAsync();
Socket clientSocket = _serverSocket.Accept();
byte[] payload1 = Enumerable.Range(0, 10).Select(i => (byte)i).ToArray();
var packet1 = new TcpTransportPacket(0, payload1);
byte[] payload2 = Enumerable.Range(11, 40).Select(i => (byte)i).ToArray();
var packet2 = new TcpTransportPacket(1, payload2);
byte[] payload3 = Enumerable.Range(51, 205).Select(i => (byte)i).ToArray();
var packet3 = new TcpTransportPacket(2, payload3);
byte[] allData = ArrayUtils.Combine(packet1.Data, packet2.Data, packet3.Data);
byte[] dataPart1;
byte[] dataPart2;
allData.Split(50, out dataPart1, out dataPart2);
clientSocket.Send(dataPart1);
await Task.Delay(100);
clientSocket.Send(dataPart2);
await Task.Delay(100);
byte[] receivedData1 = await receivedMessages.DequeueAsync(CancellationTokenHelpers.Timeout(1000).Token);
receivedData1.Should().BeEquivalentTo(payload1);
byte[] receivedData2 = await receivedMessages.DequeueAsync(CancellationTokenHelpers.Timeout(1000).Token);
receivedData2.Should().BeEquivalentTo(payload2);
byte[] receivedData3 = await receivedMessages.DequeueAsync(CancellationTokenHelpers.Timeout(1000).Token);
receivedData3.Should().BeEquivalentTo(payload3);
await transport.DisconnectAsync();
clientSocket.Close();
}
public async Task EnqueueTooMany()
{
var queue = new AsyncProducerConsumerQueue <int> (1);
await queue.EnqueueAsync(5).WithTimeout("#1");
var task2 = queue.EnqueueAsync(5);
Assert.IsFalse(task2.IsCompleted, "#2");
await queue.DequeueAsync().WithTimeout("#3");
await task2.WithTimeout("#4");
await queue.DequeueAsync().WithTimeout("#5");
}
public void ConstructorWithCollection_AddsItems()
{
AsyncContext.Run(async() =>
{
var queue = new AsyncProducerConsumerQueue <int>(new[] { 3, 5, 7 });
var result1 = await queue.DequeueAsync();
var result2 = await queue.DequeueAsync();
var result3 = await queue.DequeueAsync();
Assert.AreEqual(3, result1);
Assert.AreEqual(5, result2);
Assert.AreEqual(7, result3);
});
}
public void ConstructorWithCollection_AddsItems()
{
Test.Async(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>(new[] { 3, 5, 7 });
var result1 = await queue.DequeueAsync();
var result2 = await queue.DequeueAsync();
var result3 = await queue.DequeueAsync();
Assert.AreEqual(3, result1);
Assert.AreEqual(5, result2);
Assert.AreEqual(7, result3);
});
}
//如果平台不支持TPL数据流库，可以使用Nito.AsyncEx中的AsyncProducerConsumerQueue<T>类，它同时也支持同步和异步方法。
async void Example17()
{
AsyncProducerConsumerQueue <int> queue = new AsyncProducerConsumerQueue <int>();
//异步的生产者代码
await queue.EnqueueAsync(7);
await queue.EnqueueAsync(13);
//同步的生产者代码
queue.Enqueue(7);
queue.Enqueue(13);
queue.CompleteAdding();
//单个消费者时的异步代码
while (await queue.OutputAvailableAsync())
{
Trace.WriteLine(await queue.DequeueAsync());
}
//多个消费者时的异步代码
while (true)
{
//var result = await queue.TryDequeueAsync();
//if (result.Success) break;
//Trace.WriteLine(result.Item);
}
//同步的消费者代码
foreach (var item in queue.GetConsumingEnumerable())
{
Trace.WriteLine(item);
}
}
//不支持TPL数据流时使用Nito.AsyncEx中的AsyncProduceConsumerQueue<T>类。
async void Example12()
{
AsyncProducerConsumerQueue <int> _asyncQueue = new AsyncProducerConsumerQueue <int>();
//生存者代码
await _asyncQueue.EnqueueAsync(7);
await _asyncQueue.EnqueueAsync(13);
_asyncQueue.CompleteAdding();
//消费者代码
//先显示“7”，后显示“13”。
while (await _asyncQueue.OutputAvailableAsync())
{
Trace.WriteLine(await _asyncQueue.DequeueAsync());
}
//AsyncProducerConsumerQueue<T>具有限流功能，如果生存者的运行速度可能比消费者快，这个功能就是必需的。
AsyncProducerConsumerQueue <int> _asyncQueue2 = new AsyncProducerConsumerQueue <int>(maxCount: 1);
//单个消费者
await _asyncQueue2.EnqueueAsync(7); //这个添加过程会立即执行
await _asyncQueue2.EnqueueAsync(13); //这个添加过程会（异步地）等待，直到7被移除，然后才会加入13。
_asyncQueue2.CompleteAdding();
//多个消费者
while (true)
{
//var dequeueResult = await _asyncQueue.TryDequeueAsync();
//if (dequeueResult.Success) break;
//Trace.WriteLine(dequeueResult.Item);
}
}
private async Task CommitBlocks(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
await _backgroundOperationLock.WaitAsync(ct);
if (ct.IsCancellationRequested)
{
return;
}
try
{
var block = await commitCh.DequeueAsync(ct);
logger.Debug("Committing Block Index={Index}; RoundReceived={RoundReceived}; TxCount={TxCount}", block.Index(), block.RoundReceived(), block.Transactions().Length);
var err = Commit(block);
if (err != null)
{
logger.Error("Committing Block", err);
}
//using (await commitChMonitor.EnterAsync())
//{
// commitChMonitor.Pulse();
//}
}
finally
{
_backgroundOperationLock.Release();
}
}
}
private async Task AddingTransactions(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
await _backgroundOperationLock.WaitAsync(ct);
if (ct.IsCancellationRequested)
{
return;
}
try
{
var tx = await submitCh.DequeueAsync(ct);
logger.Debug("Adding Transaction");
AddTransaction(tx);
//using (await submitChMonitor.EnterAsync())
//{
// submitChMonitor.Pulse();
//}
}
finally
{
_backgroundOperationLock.Release();
}
}
}
// Background work
private async Task ProcessingRpc(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
await _backgroundOperationLock.WaitAsync(ct);
if (ct.IsCancellationRequested)
{
return;
}
try
{
var rpc = await netCh.DequeueAsync(ct);
logger.Debug("Processing RPC");
await ProcessRpcAsync(rpc, ct);
//using (await netChMonitor.EnterAsync())
//{
// netChMonitor.Pulse();
//}
}
finally
{
_backgroundOperationLock.Release();
}
}
}
private static async Task Consume()
{
while (await AsyncQueue.OutputAvailableAsync())
{
Console.WriteLine(await AsyncQueue.DequeueAsync());
}
}
public void DequeueAfterComplete_Empty()
{
var queue = new AsyncProducerConsumerQueue <int> (2);
queue.CompleteAdding();
Assert.ThrowsAsync <InvalidOperationException> (() => queue.DequeueAsync().AsTask(), "#1");
}
public IDisposable Connect()
{
if (Interlocked.Exchange(ref _isConnected, 1) == 1)
{
throw new InvalidOperationException("Observable cannot be connected more than once.");
}
var cts = new CancellationTokenSource();
var token = cts.Token;
Task.Run(async() => {
try {
while (true)
{
token.ThrowIfCancellationRequested();
var @event = await Queue.DequeueAsync(token).ConfigureAwait(false);
foreach (var observer in Observers)
{
observer.OnNext(@event);
}
}
} catch (Exception x) when(x is OperationCanceledException || x is InvalidOperationException)
{
foreach (var observer in Observers)
{
observer.OnCompleted();
}
}
});
return(Disposable.Create(() => {
cts.Cancel();
cts.Dispose();
}));
}
public void CancelBeforeAsynchronousDequeue()
{
var cts = new CancellationTokenSource();
var queue = new AsyncProducerConsumerQueue <int>(1);
cts.Cancel();
Assert.ThrowsAsync <TaskCanceledException>(() => queue.DequeueAsync(cts.Token).WithTimeout("#1").AsTask());
}
public async Task DequeueAfterComplete_NotEmpty()
{
var queue = new AsyncProducerConsumerQueue <int> (2);
await queue.EnqueueAsync(5);
queue.CompleteAdding();
Assert.AreEqual(5, await queue.DequeueAsync(), "#1");
}
public async Task EnqueueFirst()
{
var queue = new AsyncProducerConsumerQueue <int> (2);
await queue.EnqueueAsync(5).WithTimeout("#1");
Assert.AreEqual(5, await queue.DequeueAsync(), "#2");
}
public async Task DequeueAsync_Empty_DoesNotComplete()
{
AsyncProducerConsumerQueue <int> queue = new AsyncProducerConsumerQueue <int>();
Task <int> task = queue.DequeueAsync();
await AsyncAssert.NeverCompletesAsync(task).ConfigureAwait(false);
}
public async Task DequeueAsync_EmptyAndComplete_ThrowsException()
{
var queue = new AsyncProducerConsumerQueue <int>();
queue.CompleteAdding();
await AsyncAssert.ThrowsAsync <InvalidOperationException>(() => queue.DequeueAsync());
}
public void CompleteWhilePendingDequeue()
{
var queue = new AsyncProducerConsumerQueue <int> (2);
var dequeue = queue.DequeueAsync();
queue.CompleteAdding();
Assert.ThrowsAsync <InvalidOperationException> (() => dequeue.AsTask(), "#1");
}
public async Task DequeueAsync_Empty_DoesNotComplete()
{
var queue = new AsyncProducerConsumerQueue <int>();
var task = queue.DequeueAsync();
await AsyncAssert.NeverCompletesAsync(task);
}
public async Task EnqueueAsync_SpaceAvailable_Completes()
{
AsyncProducerConsumerQueue <int> queue = new AsyncProducerConsumerQueue <int>(new[] { 13 }, 1);
Task task = queue.EnqueueAsync(7);
await queue.DequeueAsync().ConfigureAwait(false);
await task;
}
public async Task EnqueueAsync_SpaceAvailable_Completes()
{
var queue = new AsyncProducerConsumerQueue <int>(new[] { 13 }, 1);
var task = queue.EnqueueAsync(7);
await queue.DequeueAsync();
await task;
}
public async Task DequeueAsync_Cancelled_Throws()
{
AsyncProducerConsumerQueue <int> queue = new AsyncProducerConsumerQueue <int>();
CancellationTokenSource cts = new CancellationTokenSource();
Task <int> task = queue.DequeueAsync(cts.Token);
cts.Cancel();
await AsyncAssert.ThrowsAsync <OperationCanceledException>(() => task).ConfigureAwait(false);
}
public async Task EnqueueAsync_SpaceAvailable_EnqueuesItem()
{
var queue = new AsyncProducerConsumerQueue <int>();
await queue.EnqueueAsync(3);
var result = await queue.DequeueAsync();
Assert.Equal(3, result);
}
public async Task EnqueueAsync_SpaceAvailable_EnqueuesItem()
{
AsyncProducerConsumerQueue <int> queue = new AsyncProducerConsumerQueue <int>();
await queue.EnqueueAsync(3).ConfigureAwait(false);
int result = await queue.DequeueAsync().ConfigureAwait(false);
Assert.Equal(3, result);
}
public async Task DequeueAsync_Cancelled_Throws()
{
var queue = new AsyncProducerConsumerQueue <int>();
var cts = new CancellationTokenSource();
var task = queue.DequeueAsync(cts.Token);
cts.Cancel();
await AsyncAssert.ThrowsAsync <OperationCanceledException>(() => task);
}
async Task Test()
{
var queue = new AsyncProducerConsumerQueue <int>();
// Asynchronous producer code
await queue.EnqueueAsync(7);
await queue.EnqueueAsync(13);
// Synchronous producer code
queue.Enqueue(7);
queue.Enqueue(13);
queue.CompleteAdding();
// Asynchronous single consumer code
while (await queue.OutputAvailableAsync())
{
Trace.WriteLine(await queue.DequeueAsync());
}
// Asynchronous multi-consumer code
while (true)
{
int item;
try
{
item = await queue.DequeueAsync();
}
catch (InvalidOperationException)
{
break;
}
Trace.WriteLine(item);
}
// Synchronous consumer code
foreach (int item in queue.GetConsumingEnumerable())
{
Trace.WriteLine(item);
}
}
public async Task DequeueAsync_Empty_ItemAdded_Completes()
{
var queue = new AsyncProducerConsumerQueue <int>();
var task = queue.DequeueAsync();
await queue.EnqueueAsync(13);
var result = await task;
Assert.Equal(13, result);
}
public void EnqueueAsync_SpaceAvailable_EnqueuesItem()
{
Test.Async(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>();
await queue.EnqueueAsync(3);
var result = await queue.DequeueAsync();
Assert.AreEqual(3, result);
});
}
public void TryEnqueueAsync_SpaceAvailable_EnqueuesItem()
{
AsyncContext.Run(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>();
var result = await queue.TryEnqueueAsync(3);
var dequeueResult = await queue.DequeueAsync();
Assert.IsTrue(result);
Assert.AreEqual(3, dequeueResult);
});
}
public void DequeueAsync_Cancelled_Throws()
{
Test.Async(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>();
var cts = new CancellationTokenSource();
var task = queue.DequeueAsync(cts.Token);
cts.Cancel();
await AssertEx.ThrowsExceptionAsync<OperationCanceledException>(() => task);
});
}
public void EnqueueToAnyAsync_SpaceAvailable_EnqueuesItem()
{
Test.Async(async () =>
{
var queue1 = new AsyncProducerConsumerQueue<int>(new[] { 3 }, 1);
var queue2 = new AsyncProducerConsumerQueue<int>();
var queues = new[] { queue1, queue2 };
var result = await queues.EnqueueToAnyAsync(13);
var dequeueResult = await queue2.DequeueAsync();
Assert.AreSame(queue2, result);
Assert.AreEqual(13, dequeueResult);
});
}
public async Task Should_receive_multiple_packets()
{
TcpClientTransport clientTransport = CreateTcpTransport();
var receivedMessages = new AsyncProducerConsumerQueue<byte[]>();
clientTransport.Subscribe(receivedMessages.Enqueue);
await clientTransport.ConnectAsync();
Socket clientSocket = _serverSocket.Accept();
byte[] payload1 = Enumerable.Range(0, 10).Select(i => (byte) i).ToArray();
var packet1 = new TcpTransportPacket(0, payload1);
byte[] payload2 = Enumerable.Range(11, 40).Select(i => (byte) i).ToArray();
var packet2 = new TcpTransportPacket(1, payload2);
byte[] payload3 = Enumerable.Range(51, 205).Select(i => (byte) i).ToArray();
var packet3 = new TcpTransportPacket(2, payload3);
byte[] allData = ArrayUtils.Combine(packet1.Data, packet2.Data, packet3.Data);
byte[] dataPart1;
byte[] dataPart2;
allData.Split(50, out dataPart1, out dataPart2);
clientSocket.Send(dataPart1);
await Task.Delay(100);
clientSocket.Send(dataPart2);
await Task.Delay(100);
byte[] receivedData1 = await receivedMessages.DequeueAsync(CancellationTokenHelpers.Timeout(1000).Token);
receivedData1.Should().Equal(payload1);
byte[] receivedData2 = await receivedMessages.DequeueAsync(CancellationTokenHelpers.Timeout(1000).Token);
receivedData2.Should().Equal(payload2);
byte[] receivedData3 = await receivedMessages.DequeueAsync(CancellationTokenHelpers.Timeout(1000).Token);
receivedData3.Should().Equal(payload3);
await clientTransport.DisconnectAsync();
clientSocket.Close();
}
public void TryEnqueueAsync_SpaceAvailable_Completes()
{
Test.Async(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>(new[] { 13 }, 1);
var task = queue.TryEnqueueAsync(7);
await queue.DequeueAsync();
var result = await task;
Assert.IsTrue(result);
});
}
public void DequeueAsync_Empty_ItemAdded_Completes()
{
Test.Async(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>();
var task = queue.DequeueAsync();
await queue.EnqueueAsync(13);
var result = await task;
Assert.AreEqual(13, result);
});
}
public void DequeueAsync_EmptyAndComplete_ThrowsException()
{
Test.Async(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>();
queue.CompleteAdding();
await AssertEx.ThrowsExceptionAsync<InvalidOperationException>(() => queue.DequeueAsync());
});
}
public void DequeueAsync_Empty_DoesNotComplete()
{
Test.Async(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>();
var task = queue.DequeueAsync();
await AssertEx.NeverCompletesAsync(task);
});
}
public void EnqueueAsync_SpaceAvailable_Completes()
{
Test.Async(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>(new[] { 13 }, 1);
var task = queue.EnqueueAsync(7);
await queue.DequeueAsync();
await task;
});
}
public void TryEnqueueToAnyAsync_SpaceAvailable_Completes()
{
Test.Async(async () =>
{
var queue1 = new AsyncProducerConsumerQueue<int>(new[] { 13 }, 1);
var queue2 = new AsyncProducerConsumerQueue<int>(new[] { 13 }, 1);
var queues = new[] { queue1, queue2 };
var task = queues.TryEnqueueToAnyAsync(7);
await queue2.DequeueAsync();
var result = await task;
Assert.AreSame(queue2, result);
});
}