public void OnCompleted(Action continuation, ref PipeCompletion completion)
{
var awaitableState = Interlocked.CompareExchange(
ref _state,
continuation,
_awaitableIsNotCompleted);
if (ReferenceEquals(awaitableState, _awaitableIsNotCompleted))
{
return;
}
else if (ReferenceEquals(awaitableState, _awaitableIsCompleted))
{
_scheduler.Schedule(continuation);
}
else
{
completion.TryComplete(ThrowHelper.GetInvalidOperationException(ExceptionResource.NoConcurrentOperation));
Interlocked.Exchange(
ref _state,
_awaitableIsCompleted);
Task.Run(continuation);
Task.Run(awaitableState);
}
}
internal void CompleteWriter(Exception?exception)
{
CompletionData completionData;
PipeCompletionCallbacks?completionCallbacks;
bool readerCompleted;
lock (_sync)
{
// Commit any pending buffers
CommitUnsynchronized();
completionCallbacks = _writerCompletion.TryComplete(exception);
_readerAwaitable.Complete(out completionData);
readerCompleted = _readerCompletion.IsCompleted;
}
if (readerCompleted)
{
CompletePipe();
}
if (completionCallbacks != null)
{
ScheduleCallbacks(_readerScheduler, completionCallbacks);
}
TrySchedule(_readerScheduler, completionData);
}
internal void CompleteReader(Exception exception)
{
PipeCompletionCallbacks completionCallbacks;
Action awaitable;
bool writerCompleted;
lock (_sync)
{
if (_readingState.IsActive)
{
ThrowHelper.ThrowInvalidOperationException_CompleteReaderActiveReader();
}
completionCallbacks = _readerCompletion.TryComplete(exception);
awaitable = _writerAwaitable.Complete();
writerCompleted = _writerCompletion.IsCompleted;
}
if (completionCallbacks != null)
{
TrySchedule(_writerScheduler, s_invokeCompletionCallbacks, completionCallbacks);
}
TrySchedule(_writerScheduler, awaitable);
if (writerCompleted)
{
CompletePipe();
}
}
internal void CompleteWriter(Exception exception)
{
Action awaitable;
PipeCompletionCallbacks completionCallbacks;
bool readerCompleted;
lock (_sync)
{
// Commit any pending buffers
CommitUnsynchronized();
completionCallbacks = _writerCompletion.TryComplete(exception);
awaitable = _readerAwaitable.Complete();
readerCompleted = _readerCompletion.IsCompleted;
}
if (completionCallbacks != null)
{
TrySchedule(_readerScheduler, s_invokeCompletionCallbacks, completionCallbacks);
}
TrySchedule(_readerScheduler, awaitable);
if (readerCompleted)
{
CompletePipe();
}
}
/// <summary>
/// Marks the pipeline as being complete, meaning no more items will be written to it.
/// </summary>
/// <param name="exception">Optional Exception indicating a failure that's causing the pipeline to complete.</param>
void IPipeWriter.Complete(Exception exception)
{
if (_writingState.IsActive)
{
PipelinesThrowHelper.ThrowInvalidOperationException(ExceptionResource.CompleteWriterActiveWriter, _writingState.Location);
}
Action awaitable;
PipeCompletionCallbacks completionCallbacks;
bool readerCompleted;
lock (_sync)
{
completionCallbacks = _writerCompletion.TryComplete(exception);
awaitable = _readerAwaitable.Complete();
readerCompleted = _readerCompletion.IsCompleted;
}
if (completionCallbacks != null)
{
TrySchedule(_readerScheduler, _invokeCompletionCallbacks, completionCallbacks);
}
TrySchedule(_readerScheduler, awaitable);
if (readerCompleted)
{
CompletePipe();
}
}
internal void CompleteWriter(Exception exception)
{
Action awaitable;
PipeCompletionCallbacks completionCallbacks;
bool readerCompleted;
lock (_sync)
{
if (_currentWriteLength > 0)
{
ThrowHelper.ThrowInvalidOperationException_CompleteWriterActiveWriter();
}
completionCallbacks = _writerCompletion.TryComplete(exception);
awaitable = _readerAwaitable.Complete();
readerCompleted = _readerCompletion.IsCompleted;
}
if (completionCallbacks != null)
{
TrySchedule(_readerScheduler, s_invokeCompletionCallbacks, completionCallbacks);
}
TrySchedule(_readerScheduler, awaitable);
if (readerCompleted)
{
CompletePipe();
}
}
public Action OnCompleted(Action continuation, ref PipeCompletion completion)
{
var awaitableState = _state;
if (_state == _awaitableIsNotCompleted)
{
_state = continuation;
}
if (ReferenceEquals(awaitableState, _awaitableIsCompleted))
{
return(continuation);
}
else if (!ReferenceEquals(awaitableState, _awaitableIsNotCompleted))
{
completion.TryComplete(ThrowHelper.GetInvalidOperationException(ExceptionResource.NoConcurrentOperation));
_state = _awaitableIsCompleted;
Task.Run(continuation);
Task.Run(awaitableState);
}
return(null);
}
/// <summary>
/// Signal to the producer that the consumer is done reading.
/// </summary>
/// <param name="exception">Optional Exception indicating a failure that's causing the pipeline to complete.</param>
void IPipeReader.Complete(Exception exception)
{
if (_consumingState.IsActive)
{
ThrowHelper.ThrowInvalidOperationException(ExceptionResource.CompleteReaderActiveConsumer, _consumingState.Location);
}
_readerCompletion.TryComplete(exception);
_writerAwaitable.Resume();
if (_writerCompletion.IsCompleted)
{
Dispose();
}
}
/// <summary>
/// Signal to the producer that the consumer is done reading.
/// </summary>
/// <param name="exception">Optional Exception indicating a failure that's causing the pipeline to complete.</param>
void IPipeReader.Complete(Exception exception)
{
if (_readingState.IsActive)
{
PipelinesThrowHelper.ThrowInvalidOperationException(ExceptionResource.CompleteReaderActiveReader, _readingState.Location);
}
_readerCompletion.TryComplete(exception);
Action awaitable;
lock (_sync)
{
awaitable = _writerAwaitable.Complete();
}
TrySchedule(_writerScheduler, awaitable);
if (_writerCompletion.IsCompleted)
{
Dispose();
}
}
