Fix Console.Write on iOS

src/libraries/System.Console/src/System.Console.csproj

@@ -25,6 +25,7 @@
              Link="Common\Interop\Unix\Interop.Log.cs" />
     <Compile Include="$(CommonPath)Interop\Unix\Interop.Libraries.cs"
              Link="Common\Interop\Unix\Interop.Libraries.cs" />
+    <Compile Include="System\IO\StreamWriter.iOS.cs" />
   </ItemGroup>
   <!-- Android -->
   <ItemGroup Condition="'$(TargetsAndroid)' == 'true'">

src/libraries/System.Console/src/System/Console.cs

@@ -236,6 +236,15 @@ private static TextWriter CreateOutputWriter(Stream outputStream)
         {
             return TextWriter.Synchronized(outputStream == Stream.Null ?
                 StreamWriter.Null :
+                (OperatingSystem.IsIOS() || OperatingSystem.IsTvOS() || OperatingSystem.IsMacCatalyst()) ?
+                new IOSStreamWriter(
+                    stream: outputStream,
+                    encoding: OutputEncoding.RemovePreamble(), // This ensures no prefix is written to the stream.
+                    bufferSize: WriteBufferSize,
+                    leaveOpen: true)
+                {
+                    AutoFlush = true
+                } :
                 new StreamWriter(
                     stream: outputStream,
                     encoding: OutputEncoding.RemovePreamble(), // This ensures no prefix is written to the stream.

src/libraries/System.Console/src/System/IO/StreamWriter.iOS.cs

@@ -0,0 +1,104 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace System.IO
+{
+    internal class IOSStreamWriter : StreamWriter
+    {
+        private readonly List<byte> _acc = new List<byte>();
+        private int _lineStartPos;
+
+        public IOSStreamWriter(Stream stream, Encoding? encoding = null, int bufferSize = -1, bool leaveOpen = false)
+            : base(stream, encoding, bufferSize, leaveOpen)
+        {
+        }
+
+        protected override void Flush(bool flushStream, bool flushEncoder)
+        {
+            // flushEncoder should be true at the end of the file and if
+            // the user explicitly calls Flush (though not if AutoFlush is true).
+            // This is required to flush any dangling characters from our UTF-7
+            // and UTF-8 encoders.
+            ThrowIfDisposed();
+
+            // Perf boost for Flush on non-dirty writers.
+            if (innerCharPos == 0 && !flushStream && !flushEncoder)
+            {
+                return;
+            }
+
+            if (!innerHaveWrittenPreamble)
+            {
+                innerHaveWrittenPreamble = true;
+                ReadOnlySpan<byte> preamble = innerEncoding.Preamble;
+                if (preamble.Length > 0)
+                {
+                    innerStream.Write(preamble);
+                }
+            }
+
+            // For sufficiently small char data being flushed, try to encode to the stack.
+            // For anything else, fall back to allocating the byte[] buffer.
+            Span<byte> byteBuffer = stackalloc byte[0];
+            if (innerByteBuffer is not null)
+            {
+                byteBuffer = innerByteBuffer;
+            }
+            else
+            {
+                int maxBytesForCharPos = innerEncoding.GetMaxByteCount(innerCharPos);
+                byteBuffer = maxBytesForCharPos <= 1024 ? // arbitrary threshold
+                    stackalloc byte[1024] :
+                    (innerByteBuffer = new byte[innerEncoding.GetMaxByteCount(innerCharBuffer.Length)]);
+            }
+
+            for (int i = _lineStartPos; i < innerCharPos; i++)
+            {
+                if (innerCharBuffer[i] == '\n')
+                {
+                    int count = innerEncoder.GetBytes(new ReadOnlySpan<char>(innerCharBuffer, _lineStartPos, i - _lineStartPos), byteBuffer, flushEncoder);
+                    if (count > 0)
+                    {
+                        _acc.AddRange(byteBuffer.Slice(0, count).ToArray());
+                    }
+
+                    innerStream.Write(CollectionsMarshal.AsSpan(_acc));
+                    _acc.Clear();
+
+                    _lineStartPos = i + 1;
+                }
+            }
+
+            if (_lineStartPos < innerCharPos)
+            {
+                int count = innerEncoder.GetBytes(new ReadOnlySpan<char>(innerCharBuffer, _lineStartPos, innerCharPos - _lineStartPos), byteBuffer, flushEncoder);
+                if (count > 0)
+                {
+                    _acc.AddRange(byteBuffer.Slice(0, count).ToArray());
+                }
+            }
+
+            innerCharPos = 0;
+            _lineStartPos = 0;
+
+            if (flushStream && flushEncoder)
+            {
+                var accArray = _acc.ToArray();
+                if (accArray.Length > 0)
+                {
+                    innerStream.Write(accArray.AsSpan<byte>().Slice(0, accArray.Length));
+                    _acc.Clear();
+                }
+            }
+
+            if (flushStream)
+            {
+                innerStream.Flush();
+            }
+        }
+    }
+}

src/libraries/System.Console/tests/ReadAndWrite.cs

@@ -194,6 +194,25 @@ public static async Task OutWriteAndWriteLineOverloads()
         }
     }
 
+    [Fact]
+    [PlatformSpecific(TestPlatforms.iOS | TestPlatforms.MacCatalyst | TestPlatforms.tvOS)]
+    public void TestConsoleWrite()
+    {
+        Stream s = new MemoryStream();
+        TextWriter w = new StreamWriter(s);
+        ((StreamWriter)w).AutoFlush = true;
+        TextReader r = new StreamReader(s);
+        Console.SetOut(w);
+
+        Console.Write("A");
+        Console.Write("B");
+        Console.Write("C");
+
+        s.Position = 0;
+        string line = r.ReadToEnd();
+        Assert.Equal("ABC", line);
+    }
+
     private static unsafe void ValidateConsoleEncoding(Encoding encoding)
     {
         Assert.NotNull(encoding);