private void AcquireTakeCancellationHandler(object _acquireNode, bool canceling)
{
LinkedListNode <AsyncTake> acquireNode = (LinkedListNode <AsyncTake>)_acquireNode;
AsyncTake acquire = acquireNode.Value;
if (acquire.TryLock())
{
// To access shared mutable state we must acquire the lock
lock (theLock)
{
asyncTakes.Remove(acquireNode);
}
// Release the resources associated with the async acquire.
acquire.Dispose(canceling);
// Complete the TaskCompletionSource to RanToCompletion (timeout)
// or Canceled final state.
if (canceling)
{
acquire.SetCanceled();
}
else
{
acquire.SetResult(default);
/**
* Cancellation handlers
*/
/**
* Try to cancel an async take request.
*/
private void TakeCancellationHandler(object _takeNode, bool canceling)
{
LinkedListNode <AsyncTake> takeNode = (LinkedListNode <AsyncTake>)_takeNode;
AsyncTake take = null;
// Acquire the lock to access the shared mutable state
lock (theLock) {
/**
* Here, the async take request can be completed or canceled
*/
if (!takeNode.Value.done)
{
// Remove the async take from the queue and mark it as canceled
asyncTakes.Remove(takeNode);
take = takeNode.Value;
take.done = true;
}
}
if (take != null)
{
// Dispose resources associated with this async take request.
take.Dispose(canceling);
// Complete the underlying task properly.
if (canceling)
{
take.SetCanceled();
}
else
{
take.SetResult(null);
}
}
}
private void TakeCancellationHandler(object request, bool canceling)
{
LinkedListNode <AsyncTake> node = (LinkedListNode <AsyncTake>)request;
AsyncTake take = node.Value;
if (take.TryLock())
{
lock (_lock) {
if (node.List != null)
{
_asyncTakes.Remove(node);
}
}
take.Dispose();
if (canceling)
{
take.SetCanceled();
}
else
{
take.SetResult(default);
/**
* Synchronous interface based on asynchronous TAP interface
*/
/**
* Try to cancel an asynchronous take represented by its task.
*/
private bool CancelTakeByTask(Task <T> takeTask)
{
AsyncTake take = null;
lock (theLock) {
foreach (AsyncTake _take in asyncTakes)
{
if (_take.Task == takeTask)
{
take = _take;
asyncTakes.Remove(_take);
take.done = true;
break;
}
}
}
if (take != null)
{
take.Dispose();
take.SetCanceled();
}
return(take != null);
}
