/// <summary>
/// Wraps a <see cref="Task"/> into the Begin method of an APM pattern.
/// </summary>
/// <param name="task">The task to wrap.</param>
/// <param name="callback">The callback method passed into the Begin method of the APM pattern.</param>
/// <param name="state">The state passed into the Begin method of the APM pattern.</param>
/// <returns>The asynchronous operation, to be returned by the Begin method of the APM pattern.</returns>
public static IAsyncResult ToBegin(Task task, AsyncCallback callback, object state)
{
var tcs = new TaskCompletionSource(state);
task.ContinueWith(t => {
tcs.TryCompleteFromCompletedTask(t);
callback?.Invoke(tcs.Task);
}, TaskScheduler.Default);
return tcs.Task;
}
/// <summary>
/// Upgrades the reader lock to a writer lock. Returns a disposable that downgrades the writer lock to a reader lock when disposed.
/// </summary>
/// <param name="cancellationToken">The cancellation token used to cancel the upgrade. If this is already set, then this method will attempt to upgrade immediately (succeeding if the lock is currently available).</param>
public AwaitableDisposable<IDisposable> UpgradeAsync(CancellationToken cancellationToken)
{
lock (_asyncReaderWriterLock.SyncObject) {
if (_upgrade != null) {
throw new InvalidOperationException("Cannot upgrade.");
}
_upgrade = _asyncReaderWriterLock.UpgradeAsync(cancellationToken);
}
_asyncReaderWriterLock.ReleaseWaitersWhenCanceled(_upgrade);
var ret = new TaskCompletionSource<IDisposable>();
_upgrade.ContinueWith(t => {
if (t.IsCanceled) {
lock (_asyncReaderWriterLock.SyncObject) {
_upgrade = null;
}
}
ret.TryCompleteFromCompletedTask(t);
}, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
return new AwaitableDisposable<IDisposable>(ret.Task);
}
/// <summary>
/// Asynchronously waits for a signal on this condition variable. The associated lock MUST be held when calling this method, and it will still be held when this method returns, even if the method is cancelled.
/// </summary>
/// <param name="cancellationToken">The cancellation signal used to cancel this wait.</param>
public Task WaitAsync(CancellationToken cancellationToken)
{
lock (_mutex) {
// Begin waiting for either a signal or cancellation.
var task = _queue.Enqueue(_mutex, cancellationToken);
// Attach to the signal or cancellation.
var retTcs = new TaskCompletionSource();
task.ContinueWith(async t => {
// Re-take the lock.
await _asyncLock.LockAsync().ConfigureAwait(false);
// Propagate the cancellation exception if necessary.
retTcs.TryCompleteFromCompletedTask(t);
}, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
var ret = retTcs.Task;
//Enlightenment.Trace.AsyncConditionVariable_TrackWait(this, _asyncLock, task, ret);
// Release the lock while we are waiting.
_asyncLock.ReleaseLock();
return ret;
}
}