Avoid unnecessary clearing in CopyToAsync

With getting buffers from the ArrayPool, we want to clear the buffers before we put them back into the pool.  But we only need to clear the max amount we used, and we're very likely to be using much larger buffers than we actually need.  This change keeps track of how much space we used and only clears that much.

Author: stephentoub

src/Common/src/System/IO/StreamHelpers.cs

@@ -71,6 +71,7 @@ public static Task ArrayPoolCopyToAsync(Stream source, Stream destination, int b
         private static async Task ArrayPoolCopyToAsyncCore(Stream source, Stream destination, int bufferSize, CancellationToken cancellationToken)
         {
             byte[] buffer = ArrayPool<byte>.Shared.Rent(bufferSize);
+            bufferSize = 0; // reuse same field for high water mark to avoid needing another field in the state machine
             try
             {
                 while (true)
@@ -80,12 +81,17 @@ private static async Task ArrayPoolCopyToAsyncCore(Stream source, Stream destina
                     {
                         break;
                     }
+                    if (bytesRead > bufferSize)
+                    {
+                        bufferSize = bytesRead;
+                    }
                     await destination.WriteAsync(buffer, 0, bytesRead, cancellationToken).ConfigureAwait(false);
                 }
             }
             finally
             {
-                ArrayPool<byte>.Shared.Return(buffer, clearArray: true);
+                Array.Clear(buffer, 0, bufferSize); // clear only the most we used
+                ArrayPool<byte>.Shared.Return(buffer, clearArray: false);
             }
         }
     }

src/System.IO.FileSystem/src/System/IO/Win32FileStream.cs

@@ -1764,6 +1764,7 @@ private async Task AsyncModeCopyToAsync(Stream destination, int bufferSize, Canc
             // Further, typically the CopyToAsync buffer size will be larger than that used by the FileStream, such that
             // we'd likely be unable to use it anyway.  Instead, we rent the buffer from a pool.
             byte[] copyBuffer = ArrayPool<byte>.Shared.Rent(bufferSize);
+            bufferSize = 0; // repurpose bufferSize to be the high water mark for the buffer, to avoid an extra field in the state machine
 
             // Allocate an Overlapped we can use repeatedly for all operations
             var awaitableOverlapped = new PreAllocatedOverlapped(AsyncCopyToAwaitable.s_callback, readAwaitable, copyBuffer);
@@ -1859,14 +1860,23 @@ private async Task AsyncModeCopyToAsync(Stream destination, int bufferSize, Canc
                         }
 
                         // Successful operation.  If we got zero bytes, we're done: exit the read/write loop.
-                        // Otherwise, update the read position for next time accordingly.
-                        if (readAwaitable._numBytes == 0)
+                        int numBytesRead = (int)readAwaitable._numBytes;
+                        if (numBytesRead == 0)
                         {
                             break;
                         }
-                        else if (canSeek)
+
+                        // Otherwise, update the read position for next time accordingly.
+                        if (canSeek)
                         {
-                            readAwaitable._position += (int)readAwaitable._numBytes;
+                            readAwaitable._position += numBytesRead;
+                        }
+
+                        // (and keep track of the maximum number of bytes in the buffer we used, to avoid excessive and unnecessary
+                        // clearing of the buffer before we return it to the pool)
+                        if (numBytesRead > bufferSize)
+                        {
+                            bufferSize = numBytesRead;
                         }
                     }
                     finally
@@ -1896,7 +1906,9 @@ private async Task AsyncModeCopyToAsync(Stream destination, int bufferSize, Canc
                 // Cleanup from the whole copy operation
                 cancellationReg.Dispose();
                 awaitableOverlapped.Dispose();
-                ArrayPool<byte>.Shared.Return(copyBuffer, clearArray: true);
+
+                Array.Clear(copyBuffer, 0, bufferSize);
+                ArrayPool<byte>.Shared.Return(copyBuffer, clearArray: false);
 
                 // Make sure the stream's current position reflects where we ended up
                 if (!_handle.IsClosed && _parent.CanSeek)