netcore/System.Private.CoreLib/shared/System/IO/StreamWriter.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Diagnostics;
   6 using System.Diagnostics.CodeAnalysis;
   7 using System.Runtime.CompilerServices;
   8 using System.Runtime.InteropServices;
   9 using System.Text;
  10 using System.Threading;
  11 using System.Threading.Tasks;
  12
  13 namespace System.IO
  14 {
  15     // This class implements a TextWriter for writing characters to a Stream.
  16     // This is designed for character output in a particular Encoding,
  17     // whereas the Stream class is designed for byte input and output.
  18     public class StreamWriter : TextWriter
  19     {
  20         // For UTF-8, the values of 1K for the default buffer size and 4K for the
  21         // file stream buffer size are reasonable & give very reasonable
  22         // performance for in terms of construction time for the StreamWriter and
  23         // write perf.  Note that for UTF-8, we end up allocating a 4K byte buffer,
  24         // which means we take advantage of adaptive buffering code.
  25         // The performance using UnicodeEncoding is acceptable.
  26         private const int DefaultBufferSize = 1024;   // char[]
  27         private const int DefaultFileStreamBufferSize = 4096;
  28         private const int MinBufferSize = 128;
  29
  30         // Bit bucket - Null has no backing store. Non closable.
  31         public static new readonly StreamWriter Null = new StreamWriter(Stream.Null, UTF8NoBOM, MinBufferSize, leaveOpen: true);
  32
  33         private readonly Stream _stream;
  34         private readonly Encoding _encoding;
  35         private readonly Encoder _encoder;
  36         private readonly byte[] _byteBuffer;
  37         private readonly char[] _charBuffer;
  38         private int _charPos;
  39         private int _charLen;
  40         private bool _autoFlush;
  41         private bool _haveWrittenPreamble;
  42         private readonly bool _closable;
  43         private bool _disposed;
  44
  45         // We don't guarantee thread safety on StreamWriter, but we should at
  46         // least prevent users from trying to write anything while an Async
  47         // write from the same thread is in progress.
  48         private Task _asyncWriteTask = Task.CompletedTask;
  49
  50         private void CheckAsyncTaskInProgress()
  51         {
  52             // We are not locking the access to _asyncWriteTask because this is not meant to guarantee thread safety.
  53             // We are simply trying to deter calling any Write APIs while an async Write from the same thread is in progress.
  54             if (!_asyncWriteTask.IsCompleted)
  55             {
  56                 ThrowAsyncIOInProgress();
  57             }
  58         }
  59
  60         [DoesNotReturn]
  61         private static void ThrowAsyncIOInProgress() =>
  62             throw new InvalidOperationException(SR.InvalidOperation_AsyncIOInProgress);
  63
  64         // The high level goal is to be tolerant of encoding errors when we read and very strict
  65         // when we write. Hence, default StreamWriter encoding will throw on encoding error.
  66         // Note: when StreamWriter throws on invalid encoding chars (for ex, high surrogate character
  67         // D800-DBFF without a following low surrogate character DC00-DFFF), it will cause the
  68         // internal StreamWriter's state to be irrecoverable as it would have buffered the
  69         // illegal chars and any subsequent call to Flush() would hit the encoding error again.
  70         // Even Close() will hit the exception as it would try to flush the unwritten data.
  71         // Maybe we can add a DiscardBufferedData() method to get out of such situation (like
  72         // StreamReader though for different reason). Either way, the buffered data will be lost!
  73         private static Encoding UTF8NoBOM => EncodingCache.UTF8NoBOM;
  74
  75         public StreamWriter(Stream stream)
  76             : this(stream, UTF8NoBOM, DefaultBufferSize, false)
  77         {
  78         }
  79
  80         public StreamWriter(Stream stream, Encoding encoding)
  81             : this(stream, encoding, DefaultBufferSize, false)
  82         {
  83         }
  84
  85         // Creates a new StreamWriter for the given stream.  The
  86         // character encoding is set by encoding and the buffer size,
  87         // in number of 16-bit characters, is set by bufferSize.
  88         //
  89         public StreamWriter(Stream stream, Encoding encoding, int bufferSize)
  90             : this(stream, encoding, bufferSize, false)
  91         {
  92         }
  93
  94         public StreamWriter(Stream stream, Encoding? encoding = null, int bufferSize = -1, bool leaveOpen = false)
  95             : base(null) // Ask for CurrentCulture all the time
  96         {
  97             if (stream == null)
  98             {
  99                 throw new ArgumentNullException(nameof(stream));
 100             }
 101             if (encoding == null)
 102             {
 103                 encoding = UTF8NoBOM;
 104             }
 105             if (!stream.CanWrite)
 106             {
 107                 throw new ArgumentException(SR.Argument_StreamNotWritable);
 108             }
 109             if (bufferSize == -1)
 110             {
 111                 bufferSize = DefaultBufferSize;
 112             }
 113             else if (bufferSize <= 0)
 114             {
 115                 throw new ArgumentOutOfRangeException(nameof(bufferSize), SR.ArgumentOutOfRange_NeedPosNum);
 116             }
 117
 118             _stream = stream;
 119             _encoding = encoding;
 120             _encoder = _encoding.GetEncoder();
 121             if (bufferSize < MinBufferSize)
 122             {
 123                 bufferSize = MinBufferSize;
 124             }
 125
 126             _charBuffer = new char[bufferSize];
 127             _byteBuffer = new byte[_encoding.GetMaxByteCount(bufferSize)];
 128             _charLen = bufferSize;
 129             // If we're appending to a Stream that already has data, don't write
 130             // the preamble.
 131             if (_stream.CanSeek && _stream.Position > 0)
 132             {
 133                 _haveWrittenPreamble = true;
 134             }
 135
 136             _closable = !leaveOpen;
 137         }
 138
 139         public StreamWriter(string path)
 140             : this(path, false, UTF8NoBOM, DefaultBufferSize)
 141         {
 142         }
 143
 144         public StreamWriter(string path, bool append)
 145             : this(path, append, UTF8NoBOM, DefaultBufferSize)
 146         {
 147         }
 148
 149         public StreamWriter(string path, bool append, Encoding encoding)
 150             : this(path, append, encoding, DefaultBufferSize)
 151         {
 152         }
 153
 154         public StreamWriter(string path, bool append, Encoding encoding, int bufferSize) :
 155             this(ValidateArgsAndOpenPath(path, append, encoding, bufferSize), encoding, bufferSize, leaveOpen: false)
 156         {
 157         }
 158
 159         private static Stream ValidateArgsAndOpenPath(string path, bool append, Encoding encoding, int bufferSize)
 160         {
 161             if (path == null)
 162                 throw new ArgumentNullException(nameof(path));
 163             if (encoding == null)
 164                 throw new ArgumentNullException(nameof(encoding));
 165             if (path.Length == 0)
 166                 throw new ArgumentException(SR.Argument_EmptyPath);
 167             if (bufferSize <= 0)
 168                 throw new ArgumentOutOfRangeException(nameof(bufferSize), SR.ArgumentOutOfRange_NeedPosNum);
 169
 170             return new FileStream(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.Read, DefaultFileStreamBufferSize, FileOptions.SequentialScan);
 171         }
 172
 173         public override void Close()
 174         {
 175             Dispose(true);
 176             GC.SuppressFinalize(this);
 177         }
 178
 179         protected override void Dispose(bool disposing)
 180         {
 181             try
 182             {
 183                 // We need to flush any buffered data if we are being closed/disposed.
 184                 // Also, we never close the handles for stdout & friends.  So we can safely
 185                 // write any buffered data to those streams even during finalization, which
 186                 // is generally the right thing to do.
 187                 if (!_disposed && disposing)
 188                 {
 189                     // Note: flush on the underlying stream can throw (ex., low disk space)
 190                     CheckAsyncTaskInProgress();
 191                     Flush(flushStream: true, flushEncoder: true);
 192                 }
 193             }
 194             finally
 195             {
 196                 CloseStreamFromDispose(disposing);
 197             }
 198         }
 199
 200         private void CloseStreamFromDispose(bool disposing)
 201         {
 202             // Dispose of our resources if this StreamWriter is closable.
 203             if (_closable && !_disposed)
 204             {
 205                 try
 206                 {
 207                     // Attempt to close the stream even if there was an IO error from Flushing.
 208                     // Note that Stream.Close() can potentially throw here (may or may not be
 209                     // due to the same Flush error). In this case, we still need to ensure
 210                     // cleaning up internal resources, hence the finally block.
 211                     if (disposing)
 212                     {
 213                         _stream.Close();
 214                     }
 215                 }
 216                 finally
 217                 {
 218                     _disposed = true;
 219                     _charLen = 0;
 220                     base.Dispose(disposing);
 221                 }
 222             }
 223         }
 224
 225         public override ValueTask DisposeAsync() =>
 226             GetType() != typeof(StreamWriter) ?
 227                 base.DisposeAsync() :
 228                 DisposeAsyncCore();
 229
 230         private async ValueTask DisposeAsyncCore()
 231         {
 232             // Same logic as in Dispose(), but with async flushing.
 233             Debug.Assert(GetType() == typeof(StreamWriter));
 234             try
 235             {
 236                 if (!_disposed)
 237                 {
 238                     await FlushAsync().ConfigureAwait(false);
 239                 }
 240             }
 241             finally
 242             {
 243                 CloseStreamFromDispose(disposing: true);
 244             }
 245             GC.SuppressFinalize(this);
 246         }
 247
 248         public override void Flush()
 249         {
 250             CheckAsyncTaskInProgress();
 251
 252             Flush(true, true);
 253         }
 254
 255         private void Flush(bool flushStream, bool flushEncoder)
 256         {
 257             // flushEncoder should be true at the end of the file and if
 258             // the user explicitly calls Flush (though not if AutoFlush is true).
 259             // This is required to flush any dangling characters from our UTF-7
 260             // and UTF-8 encoders.
 261             ThrowIfDisposed();
 262
 263             // Perf boost for Flush on non-dirty writers.
 264             if (_charPos == 0 && !flushStream && !flushEncoder)
 265             {
 266                 return;
 267             }
 268
 269             if (!_haveWrittenPreamble)
 270             {
 271                 _haveWrittenPreamble = true;
 272                 ReadOnlySpan<byte> preamble = _encoding.Preamble;
 273                 if (preamble.Length > 0)
 274                 {
 275                     _stream.Write(preamble);
 276                 }
 277             }
 278
 279             int count = _encoder.GetBytes(_charBuffer, 0, _charPos, _byteBuffer, 0, flushEncoder);
 280             _charPos = 0;
 281             if (count > 0)
 282             {
 283                 _stream.Write(_byteBuffer, 0, count);
 284             }
 285             // By definition, calling Flush should flush the stream, but this is
 286             // only necessary if we passed in true for flushStream.  The Web
 287             // Services guys have some perf tests where flushing needlessly hurts.
 288             if (flushStream)
 289             {
 290                 _stream.Flush();
 291             }
 292         }
 293
 294         public virtual bool AutoFlush
 295         {
 296             get { return _autoFlush; }
 297
 298             set
 299             {
 300                 CheckAsyncTaskInProgress();
 301
 302                 _autoFlush = value;
 303                 if (value)
 304                 {
 305                     Flush(true, false);
 306                 }
 307             }
 308         }
 309
 310         public virtual Stream BaseStream => _stream;
 311
 312         public override Encoding Encoding => _encoding;
 313
 314         public override void Write(char value)
 315         {
 316             CheckAsyncTaskInProgress();
 317
 318             if (_charPos == _charLen)
 319             {
 320                 Flush(false, false);
 321             }
 322
 323             _charBuffer[_charPos] = value;
 324             _charPos++;
 325             if (_autoFlush)
 326             {
 327                 Flush(true, false);
 328             }
 329         }
 330
 331         [MethodImpl(MethodImplOptions.NoInlining)] // prevent WriteSpan from bloating call sites
 332         public override void Write(char[]? buffer)
 333         {
 334             WriteSpan(buffer, appendNewLine: false);
 335         }
 336
 337         [MethodImpl(MethodImplOptions.NoInlining)] // prevent WriteSpan from bloating call sites
 338         public override void Write(char[] buffer, int index, int count)
 339         {
 340             if (buffer == null)
 341             {
 342                 throw new ArgumentNullException(nameof(buffer), SR.ArgumentNull_Buffer);
 343             }
 344             if (index < 0)
 345             {
 346                 throw new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_NeedNonNegNum);
 347             }
 348             if (count < 0)
 349             {
 350                 throw new ArgumentOutOfRangeException(nameof(count), SR.ArgumentOutOfRange_NeedNonNegNum);
 351             }
 352             if (buffer.Length - index < count)
 353             {
 354                 throw new ArgumentException(SR.Argument_InvalidOffLen);
 355             }
 356
 357             WriteSpan(buffer.AsSpan(index, count), appendNewLine: false);
 358         }
 359
 360         [MethodImpl(MethodImplOptions.NoInlining)] // prevent WriteSpan from bloating call sites
 361         public override void Write(ReadOnlySpan<char> buffer)
 362         {
 363             if (GetType() == typeof(StreamWriter))
 364             {
 365                 WriteSpan(buffer, appendNewLine: false);
 366             }
 367             else
 368             {
 369                 // If a derived class may have overridden existing Write behavior,
 370                 // we need to make sure we use it.
 371                 base.Write(buffer);
 372             }
 373         }
 374
 375         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 376         private unsafe void WriteSpan(ReadOnlySpan<char> buffer, bool appendNewLine)
 377         {
 378             CheckAsyncTaskInProgress();
 379
 380             if (buffer.Length <= 4 && // Threshold of 4 chosen based on perf experimentation
 381                 buffer.Length <= _charLen - _charPos)
 382             {
 383                 // For very short buffers and when we don't need to worry about running out of space
 384                 // in the char buffer, just copy the chars individually.
 385                 for (int i = 0; i < buffer.Length; i++)
 386                 {
 387                     _charBuffer[_charPos++] = buffer[i];
 388                 }
 389             }
 390             else
 391             {
 392                 // For larger buffers or when we may run out of room in the internal char buffer, copy in chunks.
 393                 // Use unsafe code until https://github.com/dotnet/coreclr/issues/13827 is addressed, as spans are
 394                 // resulting in significant overhead (even when the if branch above is taken rather than this
 395                 // else) due to temporaries that need to be cleared.  Given the use of unsafe code, we also
 396                 // make local copies of instance state to protect against potential concurrent misuse.
 397
 398                 ThrowIfDisposed();
 399                 char[] charBuffer = _charBuffer;
 400
 401                 fixed (char* bufferPtr = &MemoryMarshal.GetReference(buffer))
 402                 fixed (char* dstPtr = &charBuffer[0])
 403                 {
 404                     char* srcPtr = bufferPtr;
 405                     int count = buffer.Length;
 406                     int dstPos = _charPos; // use a local copy of _charPos for safety
 407                     while (count > 0)
 408                     {
 409                         if (dstPos == charBuffer.Length)
 410                         {
 411                             Flush(false, false);
 412                             dstPos = 0;
 413                         }
 414
 415                         int n = Math.Min(charBuffer.Length - dstPos, count);
 416                         int bytesToCopy = n * sizeof(char);
 417
 418                         Buffer.MemoryCopy(srcPtr, dstPtr + dstPos, bytesToCopy, bytesToCopy);
 419
 420                         _charPos += n;
 421                         dstPos += n;
 422                         srcPtr += n;
 423                         count -= n;
 424                     }
 425                 }
 426             }
 427
 428             if (appendNewLine)
 429             {
 430                 char[] coreNewLine = CoreNewLine;
 431                 for (int i = 0; i < coreNewLine.Length; i++) // Generally 1 (\n) or 2 (\r\n) iterations
 432                 {
 433                     if (_charPos == _charLen)
 434                     {
 435                         Flush(false, false);
 436                     }
 437
 438                     _charBuffer[_charPos] = coreNewLine[i];
 439                     _charPos++;
 440                 }
 441             }
 442
 443             if (_autoFlush)
 444             {
 445                 Flush(true, false);
 446             }
 447         }
 448
 449         [MethodImpl(MethodImplOptions.NoInlining)] // prevent WriteSpan from bloating call sites
 450         public override void Write(string? value)
 451         {
 452             WriteSpan(value, appendNewLine: false);
 453         }
 454
 455         [MethodImpl(MethodImplOptions.NoInlining)] // prevent WriteSpan from bloating call sites
 456         public override void WriteLine(string? value)
 457         {
 458             CheckAsyncTaskInProgress();
 459             WriteSpan(value, appendNewLine: true);
 460         }
 461
 462         [MethodImpl(MethodImplOptions.NoInlining)] // prevent WriteSpan from bloating call sites
 463         public override void WriteLine(ReadOnlySpan<char> value)
 464         {
 465             if (GetType() == typeof(StreamWriter))
 466             {
 467                 CheckAsyncTaskInProgress();
 468                 WriteSpan(value, appendNewLine: true);
 469             }
 470             else
 471             {
 472                 // If a derived class may have overridden existing WriteLine behavior,
 473                 // we need to make sure we use it.
 474                 base.WriteLine(value);
 475             }
 476         }
 477
 478         private void WriteFormatHelper(string format, ParamsArray args, bool appendNewLine)
 479         {
 480             StringBuilder sb =
 481                 StringBuilderCache.Acquire((format?.Length ?? 0) + args.Length * 8)
 482                 .AppendFormatHelper(null, format!, args); // AppendFormatHelper will appropriately throw ArgumentNullException for a null format
 483
 484             StringBuilder.ChunkEnumerator chunks = sb.GetChunks();
 485
 486             bool more = chunks.MoveNext();
 487             while (more)
 488             {
 489                 ReadOnlySpan<char> current = chunks.Current.Span;
 490                 more = chunks.MoveNext();
 491
 492                 // If final chunk, include the newline if needed
 493                 WriteSpan(current, appendNewLine: more ? false : appendNewLine);
 494             }
 495
 496             StringBuilderCache.Release(sb);
 497         }
 498
 499         public override void Write(string format, object? arg0)
 500         {
 501             if (GetType() == typeof(StreamWriter))
 502             {
 503                 WriteFormatHelper(format, new ParamsArray(arg0), appendNewLine: false);
 504             }
 505             else
 506             {
 507                 base.Write(format, arg0);
 508             }
 509         }
 510
 511         public override void Write(string format, object? arg0, object? arg1)
 512         {
 513             if (GetType() == typeof(StreamWriter))
 514             {
 515                 WriteFormatHelper(format, new ParamsArray(arg0, arg1), appendNewLine: false);
 516             }
 517             else
 518             {
 519                 base.Write(format, arg0, arg1);
 520             }
 521         }
 522
 523         public override void Write(string format, object? arg0, object? arg1, object? arg2)
 524         {
 525             if (GetType() == typeof(StreamWriter))
 526             {
 527                 WriteFormatHelper(format, new ParamsArray(arg0, arg1, arg2), appendNewLine: false);
 528             }
 529             else
 530             {
 531                 base.Write(format, arg0, arg1, arg2);
 532             }
 533         }
 534
 535         public override void Write(string format, params object?[] arg)
 536         {
 537             if (GetType() == typeof(StreamWriter))
 538             {
 539                 if (arg == null)
 540                 {
 541                     throw new ArgumentNullException((format == null) ? nameof(format) : nameof(arg)); // same as base logic
 542                 }
 543                 WriteFormatHelper(format, new ParamsArray(arg), appendNewLine: false);
 544             }
 545             else
 546             {
 547                 base.Write(format, arg);
 548             }
 549         }
 550
 551         public override void WriteLine(string format, object? arg0)
 552         {
 553             if (GetType() == typeof(StreamWriter))
 554             {
 555                 WriteFormatHelper(format, new ParamsArray(arg0), appendNewLine: true);
 556             }
 557             else
 558             {
 559                 base.WriteLine(format, arg0);
 560             }
 561         }
 562
 563         public override void WriteLine(string format, object? arg0, object? arg1)
 564         {
 565             if (GetType() == typeof(StreamWriter))
 566             {
 567                 WriteFormatHelper(format, new ParamsArray(arg0, arg1), appendNewLine: true);
 568             }
 569             else
 570             {
 571                 base.WriteLine(format, arg0, arg1);
 572             }
 573         }
 574
 575         public override void WriteLine(string format, object? arg0, object? arg1, object? arg2)
 576         {
 577             if (GetType() == typeof(StreamWriter))
 578             {
 579                 WriteFormatHelper(format, new ParamsArray(arg0, arg1, arg2), appendNewLine: true);
 580             }
 581             else
 582             {
 583                 base.WriteLine(format, arg0, arg1, arg2);
 584             }
 585         }
 586
 587         public override void WriteLine(string format, params object?[] arg)
 588         {
 589             if (GetType() == typeof(StreamWriter))
 590             {
 591                 if (arg == null)
 592                 {
 593                     throw new ArgumentNullException(nameof(arg));
 594                 }
 595                 WriteFormatHelper(format, new ParamsArray(arg), appendNewLine: true);
 596             }
 597             else
 598             {
 599                 base.WriteLine(format, arg);
 600             }
 601         }
 602
 603         public override Task WriteAsync(char value)
 604         {
 605             // If we have been inherited into a subclass, the following implementation could be incorrect
 606             // since it does not call through to Write() which a subclass might have overridden.
 607             // To be safe we will only use this implementation in cases where we know it is safe to do so,
 608             // and delegate to our base class (which will call into Write) when we are not sure.
 609             if (GetType() != typeof(StreamWriter))
 610             {
 611                 return base.WriteAsync(value);
 612             }
 613
 614             ThrowIfDisposed();
 615             CheckAsyncTaskInProgress();
 616
 617             Task task = WriteAsyncInternal(this, value, _charBuffer, _charPos, _charLen, CoreNewLine, _autoFlush, appendNewLine: false);
 618             _asyncWriteTask = task;
 619
 620             return task;
 621         }
 622
 623         // We pass in private instance fields of this MarshalByRefObject-derived type as local params
 624         // to ensure performant access inside the state machine that corresponds this async method.
 625         // Fields that are written to must be assigned at the end of the method *and* before instance invocations.
 626         private static async Task WriteAsyncInternal(StreamWriter _this, char value,
 627                                                      char[] charBuffer, int charPos, int charLen, char[] coreNewLine,
 628                                                      bool autoFlush, bool appendNewLine)
 629         {
 630             if (charPos == charLen)
 631             {
 632                 await _this.FlushAsyncInternal(false, false, charBuffer, charPos).ConfigureAwait(false);
 633                 Debug.Assert(_this._charPos == 0);
 634                 charPos = 0;
 635             }
 636
 637             charBuffer[charPos] = value;
 638             charPos++;
 639
 640             if (appendNewLine)
 641             {
 642                 for (int i = 0; i < coreNewLine.Length; i++)   // Expect 2 iterations, no point calling BlockCopy
 643                 {
 644                     if (charPos == charLen)
 645                     {
 646                         await _this.FlushAsyncInternal(false, false, charBuffer, charPos).ConfigureAwait(false);
 647                         Debug.Assert(_this._charPos == 0);
 648                         charPos = 0;
 649                     }
 650
 651                     charBuffer[charPos] = coreNewLine[i];
 652                     charPos++;
 653                 }
 654             }
 655
 656             if (autoFlush)
 657             {
 658                 await _this.FlushAsyncInternal(true, false, charBuffer, charPos).ConfigureAwait(false);
 659                 Debug.Assert(_this._charPos == 0);
 660                 charPos = 0;
 661             }
 662
 663             _this._charPos = charPos;
 664         }
 665
 666         public override Task WriteAsync(string? value)
 667         {
 668             // If we have been inherited into a subclass, the following implementation could be incorrect
 669             // since it does not call through to Write() which a subclass might have overridden.
 670             // To be safe we will only use this implementation in cases where we know it is safe to do so,
 671             // and delegate to our base class (which will call into Write) when we are not sure.
 672             if (GetType() != typeof(StreamWriter))
 673             {
 674                 return base.WriteAsync(value);
 675             }
 676
 677             if (value != null)
 678             {
 679                 ThrowIfDisposed();
 680                 CheckAsyncTaskInProgress();
 681
 682                 Task task = WriteAsyncInternal(this, value, _charBuffer, _charPos, _charLen, CoreNewLine, _autoFlush, appendNewLine: false);
 683                 _asyncWriteTask = task;
 684
 685                 return task;
 686             }
 687             else
 688             {
 689                 return Task.CompletedTask;
 690             }
 691         }
 692
 693         // We pass in private instance fields of this MarshalByRefObject-derived type as local params
 694         // to ensure performant access inside the state machine that corresponds this async method.
 695         // Fields that are written to must be assigned at the end of the method *and* before instance invocations.
 696         private static async Task WriteAsyncInternal(StreamWriter _this, string value,
 697                                                      char[] charBuffer, int charPos, int charLen, char[] coreNewLine,
 698                                                      bool autoFlush, bool appendNewLine)
 699         {
 700             Debug.Assert(value != null);
 701
 702             int count = value.Length;
 703             int index = 0;
 704
 705             while (count > 0)
 706             {
 707                 if (charPos == charLen)
 708                 {
 709                     await _this.FlushAsyncInternal(false, false, charBuffer, charPos).ConfigureAwait(false);
 710                     Debug.Assert(_this._charPos == 0);
 711                     charPos = 0;
 712                 }
 713
 714                 int n = charLen - charPos;
 715                 if (n > count)
 716                 {
 717                     n = count;
 718                 }
 719
 720                 Debug.Assert(n > 0, "StreamWriter::Write(String) isn't making progress!  This is most likely a race condition in user code.");
 721
 722                 value.CopyTo(index, charBuffer, charPos, n);
 723
 724                 charPos += n;
 725                 index += n;
 726                 count -= n;
 727             }
 728
 729             if (appendNewLine)
 730             {
 731                 for (int i = 0; i < coreNewLine.Length; i++)   // Expect 2 iterations, no point calling BlockCopy
 732                 {
 733                     if (charPos == charLen)
 734                     {
 735                         await _this.FlushAsyncInternal(false, false, charBuffer, charPos).ConfigureAwait(false);
 736                         Debug.Assert(_this._charPos == 0);
 737                         charPos = 0;
 738                     }
 739
 740                     charBuffer[charPos] = coreNewLine[i];
 741                     charPos++;
 742                 }
 743             }
 744
 745             if (autoFlush)
 746             {
 747                 await _this.FlushAsyncInternal(true, false, charBuffer, charPos).ConfigureAwait(false);
 748                 Debug.Assert(_this._charPos == 0);
 749                 charPos = 0;
 750             }
 751
 752             _this._charPos = charPos;
 753         }
 754
 755         public override Task WriteAsync(char[] buffer, int index, int count)
 756         {
 757             if (buffer == null)
 758             {
 759                 throw new ArgumentNullException(nameof(buffer), SR.ArgumentNull_Buffer);
 760             }
 761             if (index < 0)
 762             {
 763                 throw new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_NeedNonNegNum);
 764             }
 765             if (count < 0)
 766             {
 767                 throw new ArgumentOutOfRangeException(nameof(count), SR.ArgumentOutOfRange_NeedNonNegNum);
 768             }
 769             if (buffer.Length - index < count)
 770             {
 771                 throw new ArgumentException(SR.Argument_InvalidOffLen);
 772             }
 773
 774             // If we have been inherited into a subclass, the following implementation could be incorrect
 775             // since it does not call through to Write() which a subclass might have overridden.
 776             // To be safe we will only use this implementation in cases where we know it is safe to do so,
 777             // and delegate to our base class (which will call into Write) when we are not sure.
 778             if (GetType() != typeof(StreamWriter))
 779             {
 780                 return base.WriteAsync(buffer, index, count);
 781             }
 782
 783             ThrowIfDisposed();
 784             CheckAsyncTaskInProgress();
 785
 786             Task task = WriteAsyncInternal(this, new ReadOnlyMemory<char>(buffer, index, count), _charBuffer, _charPos, _charLen, CoreNewLine, _autoFlush, appendNewLine: false, cancellationToken: default);
 787             _asyncWriteTask = task;
 788
 789             return task;
 790         }
 791
 792         public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default)
 793         {
 794             if (GetType() != typeof(StreamWriter))
 795             {
 796                 // If a derived type may have overridden existing WriteASync(char[], ...) behavior, make sure we use it.
 797                 return base.WriteAsync(buffer, cancellationToken);
 798             }
 799
 800             ThrowIfDisposed();
 801             CheckAsyncTaskInProgress();
 802
 803             if (cancellationToken.IsCancellationRequested)
 804             {
 805                 return Task.FromCanceled(cancellationToken);
 806             }
 807
 808             Task task = WriteAsyncInternal(this, buffer, _charBuffer, _charPos, _charLen, CoreNewLine, _autoFlush, appendNewLine: false, cancellationToken: cancellationToken);
 809             _asyncWriteTask = task;
 810             return task;
 811         }
 812
 813         // We pass in private instance fields of this MarshalByRefObject-derived type as local params
 814         // to ensure performant access inside the state machine that corresponds this async method.
 815         // Fields that are written to must be assigned at the end of the method *and* before instance invocations.
 816         private static async Task WriteAsyncInternal(StreamWriter _this, ReadOnlyMemory<char> source,
 817                                                      char[] charBuffer, int charPos, int charLen, char[] coreNewLine,
 818                                                      bool autoFlush, bool appendNewLine, CancellationToken cancellationToken)
 819         {
 820             int copied = 0;
 821             while (copied < source.Length)
 822             {
 823                 if (charPos == charLen)
 824                 {
 825                     await _this.FlushAsyncInternal(false, false, charBuffer, charPos, cancellationToken).ConfigureAwait(false);
 826                     Debug.Assert(_this._charPos == 0);
 827                     charPos = 0;
 828                 }
 829
 830                 int n = Math.Min(charLen - charPos, source.Length - copied);
 831                 Debug.Assert(n > 0, "StreamWriter::Write(char[], int, int) isn't making progress!  This is most likely a race condition in user code.");
 832
 833                 source.Span.Slice(copied, n).CopyTo(new Span<char>(charBuffer, charPos, n));
 834                 charPos += n;
 835                 copied += n;
 836             }
 837
 838             if (appendNewLine)
 839             {
 840                 for (int i = 0; i < coreNewLine.Length; i++)   // Expect 2 iterations, no point calling BlockCopy
 841                 {
 842                     if (charPos == charLen)
 843                     {
 844                         await _this.FlushAsyncInternal(false, false, charBuffer, charPos, cancellationToken).ConfigureAwait(false);
 845                         Debug.Assert(_this._charPos == 0);
 846                         charPos = 0;
 847                     }
 848
 849                     charBuffer[charPos] = coreNewLine[i];
 850                     charPos++;
 851                 }
 852             }
 853
 854             if (autoFlush)
 855             {
 856                 await _this.FlushAsyncInternal(true, false, charBuffer, charPos, cancellationToken).ConfigureAwait(false);
 857                 Debug.Assert(_this._charPos == 0);
 858                 charPos = 0;
 859             }
 860
 861             _this._charPos = charPos;
 862         }
 863
 864         public override Task WriteLineAsync()
 865         {
 866             // If we have been inherited into a subclass, the following implementation could be incorrect
 867             // since it does not call through to Write() which a subclass might have overridden.
 868             // To be safe we will only use this implementation in cases where we know it is safe to do so,
 869             // and delegate to our base class (which will call into Write) when we are not sure.
 870             if (GetType() != typeof(StreamWriter))
 871             {
 872                 return base.WriteLineAsync();
 873             }
 874
 875             ThrowIfDisposed();
 876             CheckAsyncTaskInProgress();
 877
 878             Task task = WriteAsyncInternal(this, ReadOnlyMemory<char>.Empty, _charBuffer, _charPos, _charLen, CoreNewLine, _autoFlush, appendNewLine: true, cancellationToken: default);
 879             _asyncWriteTask = task;
 880
 881             return task;
 882         }
 883
 884
 885         public override Task WriteLineAsync(char value)
 886         {
 887             // If we have been inherited into a subclass, the following implementation could be incorrect
 888             // since it does not call through to Write() which a subclass might have overridden.
 889             // To be safe we will only use this implementation in cases where we know it is safe to do so,
 890             // and delegate to our base class (which will call into Write) when we are not sure.
 891             if (GetType() != typeof(StreamWriter))
 892             {
 893                 return base.WriteLineAsync(value);
 894             }
 895
 896             ThrowIfDisposed();
 897             CheckAsyncTaskInProgress();
 898
 899             Task task = WriteAsyncInternal(this, value, _charBuffer, _charPos, _charLen, CoreNewLine, _autoFlush, appendNewLine: true);
 900             _asyncWriteTask = task;
 901
 902             return task;
 903         }
 904
 905
 906         public override Task WriteLineAsync(string? value)
 907         {
 908             if (value == null)
 909             {
 910                 return WriteLineAsync();
 911             }
 912
 913             // If we have been inherited into a subclass, the following implementation could be incorrect
 914             // since it does not call through to Write() which a subclass might have overridden.
 915             // To be safe we will only use this implementation in cases where we know it is safe to do so,
 916             // and delegate to our base class (which will call into Write) when we are not sure.
 917             if (GetType() != typeof(StreamWriter))
 918             {
 919                 return base.WriteLineAsync(value);
 920             }
 921
 922             ThrowIfDisposed();
 923             CheckAsyncTaskInProgress();
 924
 925             Task task = WriteAsyncInternal(this, value, _charBuffer, _charPos, _charLen, CoreNewLine, _autoFlush, appendNewLine: true);
 926             _asyncWriteTask = task;
 927
 928             return task;
 929         }
 930
 931
 932         public override Task WriteLineAsync(char[] buffer, int index, int count)
 933         {
 934             if (buffer == null)
 935             {
 936                 throw new ArgumentNullException(nameof(buffer), SR.ArgumentNull_Buffer);
 937             }
 938             if (index < 0)
 939             {
 940                 throw new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_NeedNonNegNum);
 941             }
 942             if (count < 0)
 943             {
 944                 throw new ArgumentOutOfRangeException(nameof(count), SR.ArgumentOutOfRange_NeedNonNegNum);
 945             }
 946             if (buffer.Length - index < count)
 947             {
 948                 throw new ArgumentException(SR.Argument_InvalidOffLen);
 949             }
 950
 951             // If we have been inherited into a subclass, the following implementation could be incorrect
 952             // since it does not call through to Write() which a subclass might have overridden.
 953             // To be safe we will only use this implementation in cases where we know it is safe to do so,
 954             // and delegate to our base class (which will call into Write) when we are not sure.
 955             if (GetType() != typeof(StreamWriter))
 956             {
 957                 return base.WriteLineAsync(buffer, index, count);
 958             }
 959
 960             ThrowIfDisposed();
 961             CheckAsyncTaskInProgress();
 962
 963             Task task = WriteAsyncInternal(this, new ReadOnlyMemory<char>(buffer, index, count), _charBuffer, _charPos, _charLen, CoreNewLine, _autoFlush, appendNewLine: true, cancellationToken: default);
 964             _asyncWriteTask = task;
 965
 966             return task;
 967         }
 968
 969         public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default)
 970         {
 971             if (GetType() != typeof(StreamWriter))
 972             {
 973                 return base.WriteLineAsync(buffer, cancellationToken);
 974             }
 975
 976             ThrowIfDisposed();
 977             CheckAsyncTaskInProgress();
 978
 979             if (cancellationToken.IsCancellationRequested)
 980             {
 981                 return Task.FromCanceled(cancellationToken);
 982             }
 983
 984             Task task = WriteAsyncInternal(this, buffer, _charBuffer, _charPos, _charLen, CoreNewLine, _autoFlush, appendNewLine: true, cancellationToken: cancellationToken);
 985             _asyncWriteTask = task;
 986
 987             return task;
 988         }
 989
 990
 991         public override Task FlushAsync()
 992         {
 993             // If we have been inherited into a subclass, the following implementation could be incorrect
 994             // since it does not call through to Flush() which a subclass might have overridden.  To be safe
 995             // we will only use this implementation in cases where we know it is safe to do so,
 996             // and delegate to our base class (which will call into Flush) when we are not sure.
 997             if (GetType() != typeof(StreamWriter))
 998             {
 999                 return base.FlushAsync();
1000             }
1001
1002             // flushEncoder should be true at the end of the file and if
1003             // the user explicitly calls Flush (though not if AutoFlush is true).
1004             // This is required to flush any dangling characters from our UTF-7
1005             // and UTF-8 encoders.
1006             ThrowIfDisposed();
1007             CheckAsyncTaskInProgress();
1008
1009             Task task = FlushAsyncInternal(true, true, _charBuffer, _charPos);
1010             _asyncWriteTask = task;
1011
1012             return task;
1013         }
1014
1015         private Task FlushAsyncInternal(bool flushStream, bool flushEncoder,
1016                                         char[] sCharBuffer, int sCharPos, CancellationToken cancellationToken = default)
1017         {
1018             if (cancellationToken.IsCancellationRequested)
1019             {
1020                 return Task.FromCanceled(cancellationToken);
1021             }
1022
1023             // Perf boost for Flush on non-dirty writers.
1024             if (sCharPos == 0 && !flushStream && !flushEncoder)
1025             {
1026                 return Task.CompletedTask;
1027             }
1028
1029             Task flushTask = FlushAsyncInternal(this, flushStream, flushEncoder, sCharBuffer, sCharPos, _haveWrittenPreamble,
1030                                                 _encoding, _encoder, _byteBuffer, _stream, cancellationToken);
1031
1032             _charPos = 0;
1033             return flushTask;
1034         }
1035
1036
1037         // We pass in private instance fields of this MarshalByRefObject-derived type as local params
1038         // to ensure performant access inside the state machine that corresponds this async method.
1039         private static async Task FlushAsyncInternal(StreamWriter _this, bool flushStream, bool flushEncoder,
1040                                                      char[] charBuffer, int charPos, bool haveWrittenPreamble,
1041                                                      Encoding encoding, Encoder encoder, byte[] byteBuffer, Stream stream, CancellationToken cancellationToken)
1042         {
1043             if (!haveWrittenPreamble)
1044             {
1045                 _this._haveWrittenPreamble = true;
1046                 byte[] preamble = encoding.GetPreamble();
1047                 if (preamble.Length > 0)
1048                 {
1049                     await stream.WriteAsync(new ReadOnlyMemory<byte>(preamble), cancellationToken).ConfigureAwait(false);
1050                 }
1051             }
1052
1053             int count = encoder.GetBytes(charBuffer, 0, charPos, byteBuffer, 0, flushEncoder);
1054             if (count > 0)
1055             {
1056                 await stream.WriteAsync(new ReadOnlyMemory<byte>(byteBuffer, 0, count), cancellationToken).ConfigureAwait(false);
1057             }
1058
1059             // By definition, calling Flush should flush the stream, but this is
1060             // only necessary if we passed in true for flushStream.  The Web
1061             // Services guys have some perf tests where flushing needlessly hurts.
1062             if (flushStream)
1063             {
1064                 await stream.FlushAsync(cancellationToken).ConfigureAwait(false);
1065             }
1066         }
1067
1068         private void ThrowIfDisposed()
1069         {
1070             if (_disposed)
1071             {
1072                 ThrowObjectDisposedException();
1073             }
1074
1075             void ThrowObjectDisposedException() => throw new ObjectDisposedException(GetType().Name, SR.ObjectDisposed_WriterClosed);
1076         }
1077     }  // class StreamWriter
1078 }  // namespace