Stream polyfills - room for improvement?

[RichardD2]

Looking at the StreamPolyfills class, when the input Memory<T> is not wrapping an array, the methods fall back to calling .ToArray(). This will allocate a new array, use it, and then throw it away.

I suspect it may be better to use the ArrayPool<T> class for these cases.

For example, instead of:

public static async ValueTask<int> ReadAsync(
    this Stream stream,
    Memory<byte> buffer,
    CancellationToken cancellationToken)
{
    if (!MemoryMarshal.TryGetArray((ReadOnlyMemory<byte>)buffer, out var segment))
        segment = new ArraySegment<byte>(buffer.ToArray());

    return await stream.ReadAsync(segment.Array!, segment.Offset, segment.Count, cancellationToken)
        .ConfigureAwait(false);
}

You would have:

public static async ValueTask<int> ReadAsync(
    this Stream stream,
    Memory<byte> buffer,
    CancellationToken cancellationToken)
{
    if (MemoryMarshal.TryGetArray((ReadOnlyMemory<byte>)buffer, out var segment))
    {
        return await stream.ReadAsync(segment.Array!, segment.Offset, segment.Count, cancellationToken)
            .ConfigureAwait(false);
    }
    
    byte[] temp = ArrayPool<byte>.Shared.Rent(buffer.Length);
    try
    {
        int bytesRead = await stream.ReadAsync(temp, 0, buffer.Length, cancellationToken).ConfigureAwait(false);
        if (bytesRead != 0) temp.AsMemory(0, bytesRead).CopyTo(buffer);
        return bytesRead;
    }
    finally
    {
        Array.Clear(temp, 0, buffer.Length);
        ArrayPool<byte>.Shared.Return(temp);
    }
}

The WriteAsync method would use a similar approach:

 public static async ValueTask WriteAsync(
    this Stream stream,
    ReadOnlyMemory<byte> buffer,
    CancellationToken cancellationToken)
{
    if (MemoryMarshal.TryGetArray(buffer, out var segment))
    {
        await stream.WriteAsync(segment.Array!, segment.Offset, segment.Count, cancellationToken).ConfigureAwait(false);
        return;
    }
    
    var temp = ArrayPool<byte>.Shared.Rent(buffer.Length);
    try
    {
        buffer.CopyTo(temp);
        await stream.WriteAsync(temp, 0, buffer.Length, cancellationToken).ConfigureAwait(false);
    }
    finally
    {
        Array.Clear(temp, 0, buffer.Length);
        ArrayPool<byte>.Shared.Return(temp);
    }
}

[RichardD2]

Also, the current Read methods won't work if the buffer isn't backed by a managed array. The data will be read into a temporary array, which will then be thrown away. The buffer passed in will not be modified.

[Tyrrrz]

Definitely :) I didn't want to put too much code into polyfills since they are not tested. I don't want to support old frameworks beyond checking the mental "I tried" box.

It would be really nice if there were a source-only library providing these polyfills