public async Task Should_cancel_when_cancellation_attached()
{
var cts = new CancellationTokenSource();
var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
tcs.AttachCancellation(cts.Token);
cts.Cancel();
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => tcs.Task);
}
public async Task WaitAsync(CancellationToken cancellationToken)
{
try
{
confirmationTcs.AttachCancellation(cancellationToken);
await confirmationTcs.Task.ConfigureAwait(false);
}
finally
{
cleanup();
}
}
/// <summary>
/// Takes the element from queue
/// </summary>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The dequeued element</returns>
public Task <T> DequeueAsync(CancellationToken cancellationToken = default)
{
lock (mutex)
{
if (elements.Count > 0)
{
return(Task.FromResult(elements.Dequeue()));
}
CleanUpCancelledWaiters();
var waiter = new TaskCompletionSource <T>(TaskCreationOptions.RunContinuationsAsynchronously);
waiter.AttachCancellation(cancellationToken);
waiters.Enqueue(waiter);
return(waiter.Task);
}
}
/// <inheritdoc />
public virtual async Task <TResponse> RequestAsync <TRequest, TResponse>(
TRequest request,
Action <IRequestConfiguration> configure,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(request, "request");
var requestType = typeof(TRequest);
var requestConfiguration = new RequestConfiguration(
conventions.RpcRoutingKeyNamingConvention(requestType),
configuration.Timeout
);
configure(requestConfiguration);
using var cts = cancellationToken.WithTimeout(requestConfiguration.Expiration);
var correlationId = correlationIdGenerationStrategy.GetCorrelationId();
var tcs = new TaskCompletionSource <TResponse>(TaskCreationOptions.RunContinuationsAsynchronously);
RegisterResponseActions(correlationId, tcs);
using var callback = DisposableAction.Create(DeRegisterResponseActions, correlationId);
var queueName = await SubscribeToResponseAsync <TRequest, TResponse>(cts.Token).ConfigureAwait(false);
var routingKey = requestConfiguration.QueueName;
var expiration = requestConfiguration.Expiration;
var priority = requestConfiguration.Priority;
await RequestPublishAsync(
request, routingKey, queueName, correlationId, expiration, priority, configuration.MandatoryPublish, cts.Token
).ConfigureAwait(false);
tcs.AttachCancellation(cts.Token);
return(await tcs.Task.ConfigureAwait(false));
}