/// <summary>Mark the channel as being complete, meaning no more items will be written to it.</summary> /// <param name="error">Optional Exception indicating a failure that's causing the channel to complete.</param> /// <exception cref="InvalidOperationException">The channel has already been marked as complete.</exception> public void Complete(Exception error = null) { if (!TryComplete(error)) { throw ChannelUtilities.CreateInvalidCompletionException(); } }
private ValueTask <T> ReadAsyncCore(CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(new ValueTask <T>(Task.FromCanceled <T>(cancellationToken))); } lock (SyncObj) { AssertInvariants(); // If we're already completed, nothing to read. if (_completion.Task.IsCompleted) { return(new ValueTask <T>( _completion.Task.IsCanceled ? Task.FromCanceled <T>(new CancellationToken(true)) : Task.FromException <T>( _completion.Task.IsFaulted ? ChannelUtilities.CreateInvalidCompletionException(_completion.Task.Exception.InnerException) : ChannelUtilities.CreateInvalidCompletionException()))); } // If there are any blocked writers, find one to pair up with // and get its data. Writers that got canceled will remain in the queue, // so we need to loop to skip past them. while (!_blockedWriters.IsEmpty) { WriterInteractor <T> w = _blockedWriters.DequeueHead(); if (w.Success(default))
private Task WriteAsync(T item, CancellationToken cancellationToken = default) { // Writing always succeeds (unless we've already completed writing or cancellation has been requested), // so just TryWrite and return a completed task. return (cancellationToken.IsCancellationRequested ? Task.FromCanceled(cancellationToken) : TryWrite(item) ? Task.CompletedTask : Task.FromException(ChannelUtilities.CreateInvalidCompletionException(_doneWriting))); }
private ValueTask <T> ReadAsyncCore(CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(new ValueTask <T>(Task.FromCanceled <T>(cancellationToken))); } lock (SyncObj) { AssertInvariants(); // If we're already completed, nothing to read. if (_completion.Task.IsCompleted) { return(new ValueTask <T>( _completion.Task.IsCanceled ? Task.FromCanceled <T>(new CancellationToken(true)) : Task.FromException <T>( _completion.Task.IsFaulted ? ChannelUtilities.CreateInvalidCompletionException(_completion.Task.Exception.InnerException) : ChannelUtilities.CreateInvalidCompletionException()))); } // If there are any blocked writers, find one to pair up with // and get its data. Writers that got canceled will remain in the queue, // so we need to loop to skip past them. while (!_blockedWriters.IsEmpty) { WriterInteractor <T> w = _blockedWriters.DequeueHead(); if (w.Success(default(VoidResult))) { return(new ValueTask <T>(w.Item)); } } // No writer found to pair with. Queue the reader. var r = ReaderInteractor <T> .Create(true, cancellationToken); _blockedReaders.EnqueueTail(r); // And let any waiting writers know it's their lucky day. ChannelUtilities.WakeUpWaiters(ref _waitingWriters, result: true); return(new ValueTask <T>(r.Task)); } }
private Task WriteAsync(T item, CancellationToken cancellationToken = default(CancellationToken)) { if (cancellationToken.IsCancellationRequested) { return(Task.FromCanceled(cancellationToken)); } lock (SyncObj) { // Fail if we've already completed if (_completion.Task.IsCompleted) { return (_completion.Task.IsCanceled ? Task.FromCanceled <T>(new CancellationToken(true)) : Task.FromException <T>( _completion.Task.IsFaulted ? ChannelUtilities.CreateInvalidCompletionException(_completion.Task.Exception.InnerException) : ChannelUtilities.CreateInvalidCompletionException())); } // Try to find a reader to pair with. Canceled readers remain in the queue, // so we need to loop until we find one. while (!_blockedReaders.IsEmpty) { ReaderInteractor <T> r = _blockedReaders.DequeueHead(); if (r.Success(item)) { return(Task.CompletedTask); } } // No reader was available. Queue the writer. var w = WriterInteractor <T> .Create(true, cancellationToken, item); _blockedWriters.EnqueueTail(w); // And let any waiting readers know it's their lucky day. ChannelUtilities.WakeUpWaiters(ref _waitingReaders, result: true); return(w.Task); } }
private Task WriteAsync(T item, CancellationToken cancellationToken = default(CancellationToken)) { if (cancellationToken.IsCancellationRequested) { return(Task.FromCanceled(cancellationToken)); } ReaderInteractor <T> blockedReader = null; ReaderInteractor <bool> waitingReaders = null; lock (SyncObj) { AssertInvariants(); // If we're done writing, trying to write is an error. if (_doneWriting != null) { return(Task.FromException(ChannelUtilities.CreateInvalidCompletionException())); } // Get the number of items in the channel currently. int count = _items.Count; if (count == 0) { // There are no items in the channel, which means we may have blocked/waiting readers. // If there are any blocked readers, find one that's not canceled // and store it to complete outside of the lock, in case it has // continuations that'll run synchronously while (!_blockedReaders.IsEmpty) { ReaderInteractor <T> r = _blockedReaders.DequeueHead(); r.UnregisterCancellation(); // ensure that once we grab it, we own its completion if (!r.Task.IsCompleted) { blockedReader = r; break; } } if (blockedReader == null) { // If there wasn't a blocked reader, then store the item. If no one's waiting // to be notified about a 0-to-1 transition, we're done. _items.EnqueueTail(item); waitingReaders = _waitingReaders; if (waitingReaders == null) { return(ChannelUtilities.TrueTask); } _waitingReaders = null; } } else if (count < _bufferedCapacity) { // There's room in the channel. Since we're not transitioning from 0-to-1 and // since there's room, we can simply store the item and exit without having to // worry about blocked/waiting readers. _items.EnqueueTail(item); return(ChannelUtilities.TrueTask); } else if (_mode == BoundedChannelFullMode.Wait) { // The channel is full and we're in a wait mode. // Queue the writer. var writer = WriterInteractor <T> .Create(true, cancellationToken, item); _blockedWriters.EnqueueTail(writer); return(writer.Task); } else { // The channel is full, and we're in a dropping mode. // Drop either the oldest or the newest and write the new item. T droppedItem = _mode == BoundedChannelFullMode.DropNewest ? _items.DequeueTail() : _items.DequeueHead(); _items.EnqueueTail(item); return(ChannelUtilities.TrueTask); } } // We either wrote the item already, or we're transfering it to the blocked reader we grabbed. if (blockedReader != null) { // Transfer the written item to the blocked reader. bool success = blockedReader.Success(item); Debug.Assert(success, "We should always be able to complete the reader."); } else { // We stored an item bringing the count up from 0 to 1. Alert // any waiting readers that there may be something for them to consume. // Since we're no longer holding the lock, it's possible we'll end up // waking readers that have since come in. waitingReaders.Success(item: true); } return(ChannelUtilities.TrueTask); }
private Task WriteAsync(T item, CancellationToken cancellationToken = default(CancellationToken)) => cancellationToken.IsCancellationRequested ? Task.FromCanceled(cancellationToken) : TryWrite(item) ? Task.CompletedTask : Task.FromException(ChannelUtilities.CreateInvalidCompletionException(_doneWriting));
private bool TryComplete(Exception error = null) { bool completeTask; lock (SyncObj) { AssertInvariants(); // If we've already marked the channel as completed, bail. if (_doneWriting != null) { return(false); } // Mark that we're done writing. _doneWriting = error ?? ChannelUtilities.DoneWritingSentinel; completeTask = _items.IsEmpty; } // If there are no items in the queue, complete the channel's task, // as no more data can possibly arrive at this point. We do this outside // of the lock in case we'll be running synchronous completions, and we // do it before completing blocked/waiting readers, so that when they // wake up they'll see the task as being completed. if (completeTask) { ChannelUtilities.Complete(_completion, error); } // At this point, _blockedReaders and _waitingReaders will not be mutated: // they're only mutated by readers while holding the lock, and only if _doneWriting is null. // We also know that only one thread (this one) will ever get here, as only that thread // will be the one to transition from _doneWriting false to true. As such, we can // freely manipulate _blockedReaders and _waitingReaders without any concurrency concerns. ChannelUtilities.FailInteractors <ReaderInteractor <T>, T>(_blockedReaders, ChannelUtilities.CreateInvalidCompletionException(error)); ChannelUtilities.WakeUpWaiters(ref _waitingReaders, result: false, error: error); // Successfully transitioned to completed. return(true); }
private bool TryComplete(Exception error = null) { lock (SyncObj) { AssertInvariants(); // Mark the channel as being done. Since there's no buffered data, we can complete immediately. if (_completion.Task.IsCompleted) { return(false); } ChannelUtilities.Complete(_completion, error); // Fail any blocked readers/writers, as there will be no writers/readers to pair them with. ChannelUtilities.FailInteractors <ReaderInteractor <T>, T>(_blockedReaders, ChannelUtilities.CreateInvalidCompletionException(error)); ChannelUtilities.FailInteractors <WriterInteractor <T>, VoidResult>(_blockedWriters, ChannelUtilities.CreateInvalidCompletionException(error)); // Let any waiting readers and writers know there won't be any more data ChannelUtilities.WakeUpWaiters(ref _waitingReaders, result: false, error: error); ChannelUtilities.WakeUpWaiters(ref _waitingWriters, result: false, error: error); } return(true); }
private bool TryComplete(Exception error = null) { object blockedReader = null; ReaderInteractor <bool> waitingReader = null; bool completeTask = false; lock (SyncObj) { // If we're already marked as complete, there's nothing more to do. if (_doneWriting != null) { return(false); } // Mark as complete for writing. _doneWriting = error ?? ChannelUtilities.DoneWritingSentinel; // If we have no more items remaining, then the channel needs to be marked as completed // and readers need to be informed they'll never get another item. All of that needs // to happen outside of the lock to avoid invoking continuations under the lock. if (_items.IsEmpty) { completeTask = true; if (_blockedReader != null) { blockedReader = _blockedReader; _blockedReader = null; } if (_waitingReader != null) { waitingReader = _waitingReader; _waitingReader = null; } } } // Complete the channel task if necessary if (completeTask) { ChannelUtilities.Complete(_completion, error); } Debug.Assert(blockedReader == null || waitingReader == null, "There should only ever be at most one reader."); // Complete a blocked reader if necessary if (blockedReader != null) { error = ChannelUtilities.CreateInvalidCompletionException(error); ReaderInteractor <T> interactor = blockedReader as ReaderInteractor <T>; if (interactor != null) { interactor.Fail(error); } else { ((AutoResetAwaiter <T>)blockedReader).SetException(error); } } // Complete a waiting reader if necessary. (We really shouldn't have both a blockedReader // and a waitingReader, but it's more expensive to prevent it than to just tolerate it.) if (waitingReader != null) { if (error != null) { waitingReader.Fail(error); } else { waitingReader.Success(false); } } // Successfully completed the channel return(true); }