PipeReader
Defines a class that provides access to a read side of pipe.
using System.Buffers;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
namespace System.IO.Pipelines
{
public abstract class PipeReader
{
private PipeReaderStream _stream;
public abstract bool TryRead(out ReadResult result);
public abstract ValueTask<ReadResult> ReadAsync(CancellationToken cancellationToken = default(CancellationToken));
public ValueTask<ReadResult> ReadAtLeastAsync(int minimumSize, CancellationToken cancellationToken = default(CancellationToken))
{
if (minimumSize < 0)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.minimumSize);
return ReadAtLeastAsyncCore(minimumSize, cancellationToken);
}
[AsyncStateMachine(typeof(<ReadAtLeastAsyncCore>d__4))]
protected virtual ValueTask<ReadResult> ReadAtLeastAsyncCore(int minimumSize, CancellationToken cancellationToken)
{
<ReadAtLeastAsyncCore>d__4 stateMachine = default(<ReadAtLeastAsyncCore>d__4);
stateMachine.<>t__builder = AsyncValueTaskMethodBuilder<ReadResult>.Create();
stateMachine.<>4__this = this;
stateMachine.minimumSize = minimumSize;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public abstract void AdvanceTo(SequencePosition consumed);
public abstract void AdvanceTo(SequencePosition consumed, SequencePosition examined);
[System.Runtime.CompilerServices.NullableContext(1)]
public virtual Stream AsStream(bool leaveOpen = false)
{
if (_stream == null)
_stream = new PipeReaderStream(this, leaveOpen);
else if (leaveOpen) {
_stream.LeaveOpen = leaveOpen;
}
return _stream;
}
public abstract void CancelPendingRead();
[System.Runtime.CompilerServices.NullableContext(2)]
public abstract void Complete(Exception exception = null);
[System.Runtime.CompilerServices.NullableContext(2)]
public virtual ValueTask CompleteAsync(Exception exception = null)
{
try {
Complete(exception);
return default(ValueTask);
} catch (Exception exception2) {
return new ValueTask(Task.FromException(exception2));
}
}
[System.Runtime.CompilerServices.NullableContext(2)]
[Obsolete("OnWriterCompleted has been deprecated and may not be invoked on all implementations of PipeReader.")]
public virtual void OnWriterCompleted([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
2,
2
})] Action<Exception, object> callback, object state)
{
}
[System.Runtime.CompilerServices.NullableContext(1)]
public static PipeReader Create(Stream stream, [System.Runtime.CompilerServices.Nullable(2)] StreamPipeReaderOptions readerOptions = null)
{
return new StreamPipeReader(stream, readerOptions ?? StreamPipeReaderOptions.s_default);
}
[return: System.Runtime.CompilerServices.Nullable(1)]
public static PipeReader Create(ReadOnlySequence<byte> sequence)
{
return new SequencePipeReader(sequence);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public virtual Task CopyToAsync(PipeWriter destination, CancellationToken cancellationToken = default(CancellationToken))
{
if (destination == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.destination);
if (cancellationToken.IsCancellationRequested)
return Task.FromCanceled(cancellationToken);
return CopyToAsyncCore(destination, (PipeWriter destination, ReadOnlyMemory<byte> memory, CancellationToken cancellationToken) => destination.WriteAsync(memory, cancellationToken), cancellationToken);
}
[System.Runtime.CompilerServices.NullableContext(1)]
public virtual Task CopyToAsync(Stream destination, CancellationToken cancellationToken = default(CancellationToken))
{
if (destination == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.destination);
if (cancellationToken.IsCancellationRequested)
return Task.FromCanceled(cancellationToken);
return CopyToAsyncCore(destination, delegate(Stream destination, ReadOnlyMemory<byte> memory, CancellationToken cancellationToken) {
ValueTask writeTask = StreamExtensions.WriteAsync(destination, memory, cancellationToken);
if (writeTask.IsCompletedSuccessfully) {
writeTask.GetAwaiter().GetResult();
return new ValueTask<FlushResult>(new FlushResult(false, false));
}
return <CopyToAsync>g__Awaited|15_1(writeTask);
}, cancellationToken);
}
[AsyncStateMachine(typeof(<CopyToAsyncCore>d__16<>))]
private Task CopyToAsyncCore<TStream>(TStream destination, Func<TStream, ReadOnlyMemory<byte>, CancellationToken, ValueTask<FlushResult>> writeAsync, CancellationToken cancellationToken)
{
<CopyToAsyncCore>d__16<TStream> stateMachine = default(<CopyToAsyncCore>d__16<TStream>);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.destination = destination;
stateMachine.writeAsync = writeAsync;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
}
}