Implement BinaryReader.ReadExactly

src/libraries/System.Private.CoreLib/src/System/IO/BinaryReader.cs

@@ -453,6 +453,22 @@ public virtual byte[] ReadBytes(int count)
             return result;
         }
 
+        /// <summary>
+        /// Reads bytes from the current stream and advances the position within the stream until the <paramref name="buffer" /> is filled.
+        /// </summary>
+        /// <remarks>
+        /// When <paramref name="buffer"/> is empty, this read operation will be completed without waiting for available data in the stream.
+        /// </remarks>
+        /// <param name="buffer">A region of memory. When this method returns, the contents of this region are replaced by the bytes read from the current stream.</param>
+        /// <exception cref="ObjectDisposedException">The stream is closed.</exception>
+        /// <exception cref="IOException">An I/O error occurred.</exception>
+        /// <exception cref="EndOfStreamException">The end of the stream is reached before filling the <paramref name="buffer" />.</exception>
+        public virtual void ReadExactly(Span<byte> buffer)
+        {
+            ThrowIfDisposed();
+            _stream.ReadExactly(buffer);
+        }
+
         private ReadOnlySpan<byte> InternalRead(Span<byte> buffer)
         {
             Debug.Assert(buffer.Length != 1, "length of 1 should use ReadByte.");

src/libraries/System.Runtime/ref/System.Runtime.cs

@@ -9913,6 +9913,7 @@ protected virtual void FillBuffer(int numBytes) { }
         public virtual int Read(char[] buffer, int index, int count) { throw null; }
         public virtual int Read(System.Span<byte> buffer) { throw null; }
         public virtual int Read(System.Span<char> buffer) { throw null; }
+        public virtual void ReadExactly(System.Span<byte> buffer) { throw null; }
         public int Read7BitEncodedInt() { throw null; }
         public long Read7BitEncodedInt64() { throw null; }
         public virtual bool ReadBoolean() { throw null; }

src/libraries/System.Runtime/tests/System.IO.Tests/BinaryReader/BinaryReaderTests.cs

@@ -103,6 +103,11 @@ public void BinaryReader_EofReachedEarlyTests_ThrowsException()
             RunTest(writer => writer.Write("hello world"), reader => reader.ReadString());
             RunTest(writer => writer.Write(new string('x', 1024 * 1024)), reader => reader.ReadString());
 
+            // test reading into a buffer
+            byte[] byteBuffer = new byte[10];
+
+            RunTest(writer => writer.Write(byteBuffer), reader => reader.ReadExactly(byteBuffer));
+
             void RunTest(Action<BinaryWriter> writeAction, Action<BinaryReader> readAction)
             {
                 UTF8Encoding encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
@@ -195,6 +200,7 @@ private void ValidateDisposedExceptions(BinaryReader binaryReader)
             Assert.Throws<ObjectDisposedException>(() => binaryReader.Read());
             Assert.Throws<ObjectDisposedException>(() => binaryReader.Read(byteBuffer, 0, 1));
             Assert.Throws<ObjectDisposedException>(() => binaryReader.Read(charBuffer, 0, 1));
+            Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadExactly(byteBuffer));
             Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadBoolean());
             Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadByte());
             Assert.Throws<ObjectDisposedException>(() => binaryReader.ReadBytes(1));
@@ -438,6 +444,31 @@ public void Read_CharSpan_ThrowIfDisposed()
             }
         }
 
+        [Theory]
+        [InlineData(100, 10)]
+        [InlineData(10, 10)]
+        [InlineData(10, 0)]
+        [InlineData(0, 0)]
+        public void ReadExactly_ByteSpan(int sourceSize, int destinationSize)
+        {
+            using (var stream = CreateStream())
+            {
+                byte[] source = new byte[sourceSize];
+                new Random(345).NextBytes(source);
+                stream.Write(source);
+                stream.Position = 0;
+
+                using (var reader = new BinaryReader(stream))
+                {
+                    byte[] destination = new byte[destinationSize];
+
+                    reader.ReadExactly(destination);
+
+                    Assert.Equal(source[..destinationSize], destination);
+                }
+            }
+        }
+
         private class DerivedBinaryReader : BinaryReader
         {
             public DerivedBinaryReader(Stream input) : base(input) { }