public override bool TryWrite(T item)
{
UnsortedChannel <T> parent = _parent;
while (true)
{
AsyncOperation <T>? blockedReader = null;
AsyncOperation <bool>?waitingReadersTail = null;
lock (parent.SyncObj)
{
// If writing has already been marked as done, fail the write.
parent.AssertInvariants();
if (parent._doneWriting != null)
{
return(false);
}
// If there aren't any blocked readers, just add the data to the queue,
// and let any waiting readers know that they should try to read it.
// We can only complete such waiters here under the lock if they run
// continuations asynchronously (otherwise the synchronous continuations
// could be invoked under the lock). If we don't complete them here, we
// need to do so outside of the lock.
if (parent._blockedReaders.IsEmpty)
{
parent._items.Push(item);
waitingReadersTail = parent._waitingReadersTail;
if (waitingReadersTail == null)
{
return(true);
}
parent._waitingReadersTail = null;
}
else
{
// There were blocked readers. Grab one, and then complete it outside of the lock.
blockedReader = parent._blockedReaders.DequeueHead();
}
}
if (blockedReader != null)
{
// Complete the reader. It's possible the reader was canceled, in which
// case we loop around to try everything again.
if (blockedReader.TrySetResult(item))
{
return(true);
}
}
else
{
// Wake up all of the waiters. Since we've released the lock, it's possible
// we could cause some spurious wake-ups here, if we tell a waiter there's
// something available but all data has already been removed. It's a benign
// race condition, though, as consumers already need to account for such things.
ChannelUtilities.WakeUpWaiters(ref waitingReadersTail, result: true);
return(true);
}
}
}
public override bool TryRead([MaybeNullWhen(false)] out T item)
{
UnsortedChannel <T> parent = _parent;
// Dequeue an item if we can
if (parent._items.TryPop(out item))
{
CompleteIfDone(parent);
return(true);
}
item = default !;
public override ValueTask <T> ReadAsync(CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return(new ValueTask <T>(Task.FromCanceled <T>(cancellationToken)));
}
// Dequeue an item if we can.
UnsortedChannel <T> parent = _parent;
if (parent._items.TryPop(out T item))
{
CompleteIfDone(parent);
return(new ValueTask <T>(item));
}
lock (parent.SyncObj)
{
parent.AssertInvariants();
// Try to dequeue again, now that we hold the lock.
if (parent._items.TryPop(out item))
{
CompleteIfDone(parent);
return(new ValueTask <T>(item));
}
// There are no items, so if we're done writing, fail.
if (parent._doneWriting != null)
{
return(ChannelUtilities.GetInvalidCompletionValueTask <T>(parent._doneWriting));
}
// If we're able to use the singleton reader, do so.
if (!cancellationToken.CanBeCanceled)
{
AsyncOperation <T> singleton = _readerSingleton;
if (singleton.TryOwnAndReset())
{
parent._blockedReaders.EnqueueTail(singleton);
return(singleton.ValueTaskOfT);
}
}
// Otherwise, create and queue a reader.
var reader = new AsyncOperation <T>(parent._runContinuationsAsynchronously, cancellationToken);
parent._blockedReaders.EnqueueTail(reader);
return(reader.ValueTaskOfT);
}
}
public override bool TryComplete(Exception?error)
{
UnsortedChannel <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 and _waitingReaders will not be mutated:
// they're only mutated by readers while holding the lock, and only if _doneWriting is null.
// freely manipulate _blockedReaders and _waitingReaders without any concurrency concerns.
ChannelUtilities.FailOperations <AsyncOperation <T>, T>(parent._blockedReaders, ChannelUtilities.CreateInvalidCompletionException(error));
ChannelUtilities.WakeUpWaiters(ref parent._waitingReadersTail, result: false, error: error);
// Successfully transitioned to completed.
return(true);
}
internal UnsortedChannelWriter(UnsortedChannel <T> parent) => _parent = parent;
internal UnsortedChannelReader(UnsortedChannel <T> parent)
{
_parent = parent;
_readerSingleton = new AsyncOperation <T>(parent._runContinuationsAsynchronously, pooled: true);
_waiterSingleton = new AsyncOperation <bool>(parent._runContinuationsAsynchronously, pooled: true);
}
