WriteAsync()

override ValueTask System.Threading.Channels.BoundedChannel< T >.BoundedChannelWriter.WriteAsync ( T item, CancellationToken cancellationToken )

inlinevirtual

Reimplemented from System.Threading.Channels.ChannelWriter< T >.

Definition at line 330 of file BoundedChannel.cs.

        {
            if (cancellationToken.IsCancellationRequested)
            {
                return new ValueTask(Task.FromCanceled(cancellationToken));
            }
            AsyncOperation<T> asyncOperation = null;
            AsyncOperation<bool> listTail = null;
            BoundedChannel<T> parent = _parent;
            bool lockTaken = false;
            try
            {
                Monitor.Enter(parent.SyncObj, ref lockTaken);
                if (parent._doneWriting != null)
                {
                    return new ValueTask(Task.FromException(ChannelUtilities.CreateInvalidCompletionException(parent._doneWriting)));
                }
                int count = parent._items.Count;
                if (count != 0)
                {
                    if (count < parent._bufferedCapacity)
                    {
                        parent._items.EnqueueTail(item);
                        return default(ValueTask);
                    }
                    if (parent._mode == BoundedChannelFullMode.Wait)
                    {
                        if (!cancellationToken.CanBeCanceled)
                        {
                            VoidAsyncOperationWithData<T> writerSingleton = _writerSingleton;
                            if (writerSingleton.TryOwnAndReset())
                            {
                                writerSingleton.Item = item;
                                parent._blockedWriters.EnqueueTail(writerSingleton);
                                return writerSingleton.ValueTask;
                            }
                        }
                        VoidAsyncOperationWithData<T> voidAsyncOperationWithData = new VoidAsyncOperationWithData<T>(runContinuationsAsynchronously: true, cancellationToken);
                        voidAsyncOperationWithData.Item = item;
                        parent._blockedWriters.EnqueueTail(voidAsyncOperationWithData);
                        return voidAsyncOperationWithData.ValueTask;
                    }
                    if (parent._mode == BoundedChannelFullMode.DropWrite)
                    {
                        Monitor.Exit(parent.SyncObj);
                        lockTaken = false;
                        parent._itemDropped?.Invoke(item);
                        return default(ValueTask);
                    }
                    T obj = ((parent._mode == BoundedChannelFullMode.DropNewest) ? parent._items.DequeueTail() : parent._items.DequeueHead());
                    parent._items.EnqueueTail(item);
                    Monitor.Exit(parent.SyncObj);
                    lockTaken = false;
                    parent._itemDropped?.Invoke(obj);
                    return default(ValueTask);
                }
                while (!parent._blockedReaders.IsEmpty)
                {
                    AsyncOperation<T> asyncOperation2 = parent._blockedReaders.DequeueHead();
                    if (asyncOperation2.UnregisterCancellation())
                    {
                        asyncOperation = asyncOperation2;
                        break;
                    }
                }
                if (asyncOperation == null)
                {
                    parent._items.EnqueueTail(item);
                    listTail = parent._waitingReadersTail;
                    if (listTail == null)
                    {
                        return default(ValueTask);
                    }
                    parent._waitingReadersTail = null;
                }
            }
            finally
            {
                if (lockTaken)
                {
                    Monitor.Exit(parent.SyncObj);
                }
            }
            if (asyncOperation != null)
            {
                bool flag = asyncOperation.TrySetResult(item);
            }
            else
            {
                ChannelUtilities.WakeUpWaiters(ref listTail, result: true);
            }
            return default(ValueTask);
        }

References System.Threading.Channels.BoundedChannel< T >.BoundedChannelWriter._parent, System.Threading.Channels.BoundedChannel< T >.BoundedChannelWriter._writerSingleton, System.cancellationToken, System.count, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Threading.Channels.ChannelUtilities.CreateInvalidCompletionException(), System.Threading.Monitor.Enter(), System.Threading.Monitor.Exit(), System.Threading.Tasks.Task< TResult >.FromCanceled(), System.Threading.Tasks.Task< TResult >.FromException(), System.item, System.obj, and System.Threading.Channels.ChannelUtilities.WakeUpWaiters().