Minimize buffer allocations in Stream.CopyTo for seekable streams (#4540)

The current implementation of  Stream.CopyTo  allocates a giant, 81920-byte buffer if no  bufferSize  parameter is passed. This is incredibly wasteful if the stream we're copying from can seek, because then we can use the  Length  and  Position  properties to determine how many bytes are left and allocate a buffer of that size.

Author: jamesqo

src/mscorlib/src/System/IO/Stream.cs

@@ -116,7 +116,40 @@ public virtual int WriteTimeout {
         [ComVisible(false)]
         public Task CopyToAsync(Stream destination)
         {
-            return CopyToAsync(destination, _DefaultCopyBufferSize);
+            int bufferSize = _DefaultCopyBufferSize;
+
+#if FEATURE_CORECLR
+            if (CanSeek)
+            {
+                long length = Length;
+                long position = Position;
+                if (length <= position) // Handles negative overflows
+                {
+                    // If we go down this branch, it means there are
+                    // no bytes left in this stream.
+
+                    // Ideally we would just return Task.CompletedTask here,
+                    // but CopyToAsync(Stream, int, CancellationToken) was already
+                    // virtual at the time this optimization was introduced. So
+                    // if it does things like argument validation (checking if destination
+                    // is null and throwing an exception), then await fooStream.CopyToAsync(null)
+                    // would no longer throw if there were no bytes left. On the other hand,
+                    // we also can't roll our own argument validation and return Task.CompletedTask,
+                    // because it would be a breaking change if the stream's override didn't throw before,
+                    // or in a different order. So for simplicity, we just set the bufferSize to 1
+                    // (not 0 since the default implementation throws for 0) and forward to the virtual method.
+                    bufferSize = 1; 
+                }
+                else
+                {
+                    long remaining = length - position;
+                    if (remaining > 0) // In the case of a positive overflow, stick to the default size
+                        bufferSize = (int)Math.Min(bufferSize, remaining);
+                }
+            }
+#endif // FEATURE_CORECLR
+            
+            return CopyToAsync(destination, bufferSize);
         }
 
         [HostProtection(ExternalThreading = true)]
@@ -155,7 +188,30 @@ private async Task CopyToAsyncInternal(Stream destination, Int32 bufferSize, Can
         // the current position.
         public void CopyTo(Stream destination)
         {
-            CopyTo(destination, _DefaultCopyBufferSize);
+            int bufferSize = _DefaultCopyBufferSize;
+
+#if FEATURE_CORECLR
+            if (CanSeek)
+            {
+                long length = Length;
+                long position = Position;
+                if (length <= position) // Handles negative overflows
+                {
+                    // No bytes left in stream
+                    // Call the other overload with a bufferSize of 1,
+                    // in case it's made virtual in the future
+                    bufferSize = 1;
+                }
+                else
+                {
+                    long remaining = length - position;
+                    if (remaining > 0) // In the case of a positive overflow, stick to the default size
+                        bufferSize = (int)Math.Min(bufferSize, remaining);
+                }
+            }
+#endif // FEATURE_CORECLR
+            
+            CopyTo(destination, bufferSize);
         }
 
         public void CopyTo(Stream destination, int bufferSize)