Write and WriteAsync overloads for StringBuilder. (#18281)

* Write and WriteAsync overloads for StringBuilder.

Addresses issue https://github.com/dotnet/corefx/issues/30048

Note that tests will come as a separate checking as part of the coreFX repo.

* Review feedback

* Review feedback

* Added WriteLine(StringBuilder overloads (review feedback)

* review feedback

* Fix configureAwait

* bug fix

* Bug fix

* review feedback

Author: vancem

src/System.Private.CoreLib/shared/System/IO/TextWriter.cs

@@ -283,6 +283,21 @@ public virtual void Write(object value)
             }
         }
 
+        /// <summary>
+        /// Equivalent to Write(stringBuilder.ToString()) however it uses the
+        /// StringBuilder.GetChunks() method to avoid creating the intermediate string 
+        /// </summary>
+        /// <param name="value">The string (as a StringBuilder) to write to the stream</param>
+        public virtual void Write(StringBuilder value)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(nameof(value));
+            }
+            foreach (ReadOnlyMemory<char> chunk in value.GetChunks())
+                Write(chunk);
+        }
+
         // Writes out a formatted string.  Uses the same semantics as
         // String.Format.
         // 
@@ -447,6 +462,16 @@ public virtual void WriteLine(string value)
             Write(CoreNewLineStr);
         }
 
+        /// <summary>
+        /// Equivalent to WriteLine(stringBuilder.ToString()) however it uses the
+        /// StringBuilder.GetChunks() method to avoid creating the intermediate string 
+        /// </summary>
+        public virtual void WriteLine(StringBuilder value)
+        {
+            Write(value);
+            WriteLine();
+        }
+
         // Writes the text representation of an object followed by a line
         // terminator to the text stream.
         //
@@ -527,6 +552,28 @@ public virtual Task WriteAsync(string value)
             tuple, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
         }
 
+        /// <summary>
+        /// Equivalent to WriteAsync(stringBuilder.ToString()) however it uses the
+        /// StringBuilder.GetChunks() method to avoid creating the intermediate string 
+        /// </summary>
+        /// <param name="value">The string (as a StringBuilder) to write to the stream</param>
+        public virtual Task WriteAsync(StringBuilder value, CancellationToken cancellationToken = default)
+        {
+            // Do the agument checking before 'going async' so you get it early 
+            if (value == null)
+            {
+                throw new ArgumentNullException(nameof(value));
+            }
+            // Then do the rest which may be deferred (done in the returned Task)
+            return WriteAsyncCore(value, cancellationToken);
+
+            async Task WriteAsyncCore(StringBuilder sb, CancellationToken ct)
+            {
+                foreach (ReadOnlyMemory<char> chunk in sb.GetChunks())
+                    await WriteAsync(chunk, ct).ConfigureAwait(false);
+            }
+        }
+
         public Task WriteAsync(char[] buffer)
         {
             if (buffer == null)
@@ -579,6 +626,17 @@ public virtual Task WriteLineAsync(string value)
             tuple, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
         }
 
+        /// <summary>
+        /// Equivalent to WriteLineAsync(stringBuilder.ToString()) however it uses the
+        /// StringBuilder.GetChunks() method to avoid creating the intermediate string 
+        /// </summary>
+        /// <param name="value">The string (as a StringBuilder) to write to the stream</param>
+        public async virtual Task WriteLineAsync(StringBuilder value, CancellationToken cancellationToken = default)
+        {
+            await WriteAsync(value, cancellationToken).ConfigureAwait(false);
+            await WriteAsync(CoreNewLine, cancellationToken).ConfigureAwait(false);
+        }
+
         public Task WriteLineAsync(char[] buffer)
         {
             if (buffer == null)
@@ -744,6 +802,9 @@ protected override void Dispose(bool disposing)
             [MethodImpl(MethodImplOptions.Synchronized)]
             public override void Write(string value) => _out.Write(value);
 
+            [MethodImpl(MethodImplOptions.Synchronized)]
+            public override void Write(StringBuilder value) => _out.Write(value);
+
             [MethodImpl(MethodImplOptions.Synchronized)]
             public override void Write(object value) => _out.Write(value);
 
@@ -798,6 +859,9 @@ protected override void Dispose(bool disposing)
             [MethodImpl(MethodImplOptions.Synchronized)]
             public override void WriteLine(string value) => _out.WriteLine(value);
 
+            [MethodImpl(MethodImplOptions.Synchronized)]
+            public override void WriteLine(StringBuilder value) => _out.WriteLine(value);
+
             [MethodImpl(MethodImplOptions.Synchronized)]
             public override void WriteLine(object value) => _out.WriteLine(value);
 
@@ -831,6 +895,13 @@ public override Task WriteAsync(string value)
                 return Task.CompletedTask;
             }
 
+            [MethodImpl(MethodImplOptions.Synchronized)]
+            public override Task WriteAsync(StringBuilder value, CancellationToken cancellationToken = default)
+            {
+                Write(value);
+                return Task.CompletedTask;
+            }
+
             [MethodImpl(MethodImplOptions.Synchronized)]
             public override Task WriteAsync(char[] buffer, int index, int count)
             {
@@ -852,6 +923,13 @@ public override Task WriteLineAsync(string value)
                 return Task.CompletedTask;
             }
 
+            [MethodImpl(MethodImplOptions.Synchronized)]
+            public override Task WriteLineAsync(StringBuilder value, CancellationToken cancellationToken = default)
+            {
+                WriteLine(value);
+                return Task.CompletedTask;
+            }
+
             [MethodImpl(MethodImplOptions.Synchronized)]
             public override Task WriteLineAsync(char[] buffer, int index, int count)
             {