public override ValueTask <bool> WaitToWriteAsync(CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(new ValueTask <bool>(Task.FromCanceled <bool>(cancellationToken))); } BoundedChannel <T> parent = _parent; lock (parent.SyncObj) { parent.AssertInvariants(); // If we're done writing, no writes will ever succeed. if (parent._doneWriting != null) { return(parent._doneWriting != ChannelUtilities.s_doneWritingSentinel ? new ValueTask <bool>(Task.FromException <bool>(parent._doneWriting)) :
public override bool TryComplete(Exception?error) { BoundedChannel <T> parent = _parent; bool completeTask; lock (parent.SyncObj) { parent.AssertInvariants(); // If we've already marked the channel as completed, bail. if (parent._doneWriting != null) { return(false); } // Mark that we're done writing. parent._doneWriting = error ?? ChannelUtilities.s_doneWritingSentinel; completeTask = parent._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(parent._completion, error); } // At this point, _blockedReaders/Writers and _waitingReaders/Writers will not be mutated: // they're only mutated by readers/writers 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 them without any concurrency concerns. ChannelUtilities.FailOperations <AsyncOperation <T>, T>(parent._blockedReaders, ChannelUtilities.CreateInvalidCompletionException(error)); ChannelUtilities.FailOperations <VoidAsyncOperationWithData <T>, VoidResult>(parent._blockedWriters, ChannelUtilities.CreateInvalidCompletionException(error)); ChannelUtilities.WakeUpWaiters(ref parent._waitingReadersTail, result: false, error: error); ChannelUtilities.WakeUpWaiters(ref parent._waitingWritersTail, result: false, error: error); // Successfully transitioned to completed. return(true); }
public override bool TryWrite(T item) { AsyncOperation <T>? blockedReader = null; AsyncOperation <bool>?waitingReadersTail = null; BoundedChannel <T> parent = _parent; lock (parent.SyncObj) { parent.AssertInvariants(); // If we're done writing, nothing more to do. if (parent._doneWriting != null) { return(false); } // Get the number of items in the channel currently. int count = parent._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 (!parent._blockedReaders.IsEmpty) { AsyncOperation <T> r = parent._blockedReaders.DequeueHead(); r.UnregisterCancellation(); // ensure that once we grab it, we own its completion if (!r.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. parent._items.EnqueueTail(item); waitingReadersTail = parent._waitingReadersTail; if (waitingReadersTail == null) { return(true); } parent._waitingReadersTail = null; } } else if (count < parent._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. parent._items.EnqueueTail(item); return(true); } else if (parent._mode == BoundedChannelFullMode.Wait) { // The channel is full and we're in a wait mode. // Simply exit and let the caller know we didn't write the data. return(false); } else if (parent._mode == BoundedChannelFullMode.DropWrite) { // The channel is full. Just ignore the item being added // but say we added it. return(true); } else { // The channel is full, and we're in a dropping mode. // Drop either the oldest or the newest and write the new item. if (parent._mode == BoundedChannelFullMode.DropNewest) { parent._items.DequeueTail(); } else { parent._items.DequeueHead(); } parent._items.EnqueueTail(item); return(true); } } // We either wrote the item already, or we're transferring it to the blocked reader we grabbed. if (blockedReader != null) { Debug.Assert(waitingReadersTail == null, "Shouldn't have any waiters to wake up"); // Transfer the written item to the blocked reader. bool success = blockedReader.TrySetResult(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. ChannelUtilities.WakeUpWaiters(ref waitingReadersTail, result: true); } return(true); }