Add BinaryWriter perf tests

src/benchmarks/micro/libraries/System.IO/BinaryWriterExtendedTests.cs

@@ -0,0 +1,41 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using BenchmarkDotNet.Attributes;
+using MicroBenchmarks;
+
+namespace System.IO.Tests
+{
+    [BenchmarkCategory(Categories.Libraries)]
+    public class BinaryWriterExtendedTests
+    {
+        private string _input;
+        private char[] _inputAsChars;
+        private BinaryWriter _bw;
+
+        [Params(4, 16, 512, 10_000, 100_000, 500_000, 2_000_000)]
+        public int StringLengthInChars;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            _bw = new BinaryWriter(new NullWriteStream());
+
+            _input = new string('x', StringLengthInChars);
+            _inputAsChars = _input.ToCharArray();
+        }
+
+        [Benchmark]
+        public void WriteAsciiCharArray()
+        {
+            _bw.Write(_inputAsChars);
+        }
+
+        [Benchmark]
+        public void WriteAsciiString()
+        {
+            _bw.Write(_input);
+        }
+    }
+}

src/benchmarks/micro/libraries/System.IO/BinaryWriterTests.cs

@@ -0,0 +1,72 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using BenchmarkDotNet.Attributes;
+using MicroBenchmarks;
+
+namespace System.IO.Tests
+{
+    [BenchmarkCategory(Categories.Libraries)]
+    public class BinaryWriterTests
+    {
+        private BinaryWriter _bw;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            _bw = new BinaryWriter(new NullWriteStream());
+        }
+
+        [Benchmark]
+        public BinaryWriter DefaultCtor() => new BinaryWriter(Stream.Null);
+
+        [Benchmark]
+        public void WriteBool()
+        {
+            _bw.Write(true);
+        }
+
+        [Benchmark]
+        public void WriteAsciiChar()
+        {
+            _bw.Write('a');
+        }
+
+        [Benchmark]
+        public void WriteNonAsciiChar()
+        {
+            _bw.Write('\u00E0');
+        }
+
+        [Benchmark]
+        public void WriteUInt16()
+        {
+            _bw.Write((ushort)0xabcd);
+        }
+
+        [Benchmark]
+        public void WriteUInt32()
+        {
+            _bw.Write((uint)0xdeadbeef);
+        }
+
+        [Benchmark]
+        public void WriteUInt64()
+        {
+            _bw.Write((ulong)0xdeadbeef_aabbccdd);
+        }
+
+        [Benchmark]
+        public void WriteSingle()
+        {
+            _bw.Write((float)Math.PI);
+        }
+
+        [Benchmark]
+        public void WriteDouble()
+        {
+            _bw.Write((double)Math.PI);
+        }
+    }
+}

src/benchmarks/micro/libraries/System.IO/NullWriteStream.cs

@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.IO.Tests
+{
+    /// <summary>
+    /// A <see cref="Stream"/> that acts as a null sink for data. Overrides members that
+    /// <see cref="Stream.Null"/> does not. Used for benchmarking wrappers around Stream
+    /// without benchmarking the implementation of the inner Stream itself.
+    /// </summary>
+    internal sealed class NullWriteStream : Stream
+    {
+        public override bool CanRead => false;
+
+        public override bool CanSeek => false;
+
+        public override bool CanWrite => true;
+
+        public override long Length => throw new NotSupportedException();
+
+        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
+
+        public override void Flush() { }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count) { }
+
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
+        }
+
+        public override void WriteByte(byte value) { }
+
+#if NETCOREAPP2_1_OR_GREATER // these virtual methods only exist in .NET Core 2.1+
+        public override void Write(ReadOnlySpan<byte> buffer) { }
+
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            return ValueTask.CompletedTask;
+        }
+#endif
+    }
+}