Round #724

Use Span<T> and ValueTask<T> together to read from a PipeReader without allocations, exposing the result as IAsyncEnumerable<ReadOnlyMemory<byte>>.

Here's an example implementation that uses `Span<T>` and `ValueTask<T>` together to read from a `PipeReader` without allocations, exposing the result as `IAsyncEnumerable<ReadOnlyMemory<byte>>`: ```csharp using System; using System.Buffers; using System.IO.Pipes; using System.Threading; using System.Threading.Tasks; public class PipeReaderAsyncEnumerable { private readonly PipeReader _pipeReader; public PipeReaderAsyncEnumerable(PipeReader pipeReader) { _pipeReader = pipeReader; } public async IAsyncEnumerable<ReadOnlyMemory<byte>> ReadAsyncEnumerable() { while (true) { var result = await _pipeReader.ReadAsync(); var buffer = result.Buffer; if (result.IsCompleted) { if (buffer.Length > 0) { yield return buffer; } break; } yield return buffer; _pipeReader.AdvanceTo(buffer.End); } } public async IAsyncEnumerable<ReadOnlyMemory<byte>> ReadAsyncEnumerableNoAlloc() { var buffer = ArrayPool<byte>.Shared.Rent(4096); try { while (true) { var result = await _pipeReader.ReadAsync(new Span<byte>(buffer, 0, 4096)); var consumed = result.Consumed; var examined = result.Examined; if (result.IsCompleted) { if (consumed > 0) { yield return new ReadOnlyMemory<byte>(buffer, 0, consumed); } break; } yield return new ReadOnlyMemory<byte>(buffer, 0, consumed); _pipeReader.AdvanceTo(examined); } } finally { ArrayPool<byte>.Shared.Return(buffer); } } } ``` In the `ReadAsyncEnumerableNoAlloc` method, we use `ArrayPool` to rent a buffer, which reduces the allocation overhead. We then use `Span<T>` to read into this buffer, and `ValueTask<T>` to asynchronously read from the `PipeReader`. The result is exposed as `IAsyncEnumerable<ReadOnlyMemory<byte>>`, which allows the caller to enumerate over the read data without allocations. You can use this class as follows: ```csharp var pipe = new Pipe(); var pipeReader = pipe.Reader; var pipeWriter = pipe.Writer; var reader = new PipeReaderAsyncEnumerable(pipeReader); // Write some data to the pipe await pipeWriter.WriteAsync(Encoding.UTF8.GetBytes("Hello, World!")); await pipeWriter.FlushAsync(); // Read the data from the pipe await foreach (var data in reader.ReadAsyncEnumerableNoAlloc()) { Console.WriteLine($"Read {data.Length} bytes: {Encoding.UTF8.GetString(data.Span)}"); } ``` This code creates a pipe, writes some data to it, and then reads the data back using the `ReadAsyncEnumerableNoAlloc` method. The read data is then printed to the console.

Here's an implementation that uses `Span<T>` and `ValueTask<T>` to read from a `PipeReader` without allocations, exposing the result as `IAsyncEnumerable<ReadOnlyMemory<byte>>`: ```csharp using System; using System.Buffers; using System.IO.Pipes; using System.Threading; using System.Threading.Tasks; public class PipeReaderEnumerable { private readonly PipeReader _reader; public PipeReaderEnumerable(PipeReader reader) { _reader = reader; } public async IAsyncEnumerable<ReadOnlyMemory<byte>> ReadAsync() { while (true) { var result = await _reader.ReadAsync(); var buffer = result.Buffer; while (buffer.Length > 0) { var chunk = buffer.First(1024); yield return chunk; buffer = buffer.Slice(chunk.Length); } if (result.IsCompleted) { break; } } } } ``` This implementation uses the `ReadAsync` method of the `PipeReader` to read data from the pipe. The `ReadAsync` method returns a `ValueTask<ReadResult>`, which contains the data read from the pipe as a `ReadOnlySequence<byte>`. The `ReadOnlySequence<byte>` is then split into chunks of up to 1024 bytes, and each chunk is yielded as a `ReadOnlyMemory<byte>`. The `ReadAsync` method is called repeatedly until the end of the pipe is reached, at which point the loop exits. To use this implementation, you can create a `PipeReaderEnumerable` instance and call the `ReadAsync` method, like this: ```csharp var pipe = new Pipe(); var reader = pipe.Reader; var writer = pipe.Writer; var enumerable = new PipeReaderEnumerable(reader); // Write some data to the pipe await writer.WriteAsync(new byte[] { 1, 2, 3, 4, 5 }); // Read the data from the pipe await foreach (var chunk in enumerable.ReadAsync()) { Console.WriteLine($"Read {chunk.Length} bytes: {BitConverter.ToString(chunk.Span)}"); } ``` This code creates a pipe, writes some data to it, and then reads the data back out using the `PipeReaderEnumerable` class. The `ReadAsync` method is called to read the data from the pipe, and the resulting chunks are printed to the console.