mcs/class/referencesource/mscorlib/system/io/stringwriter.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 /*============================================================
   7 **
   8 ** Class:  StringWriter
   9 **
  10 ** <OWNER>Microsoft</OWNER>
  11 **
  12 ** Purpose: For writing text to a string
  13 **
  14 **
  15 ===========================================================*/
  16
  17 using System;
  18 using System.Runtime;
  19 using System.Text;
  20 using System.Globalization;
  21 using System.Diagnostics.Contracts;
  22 using System.Runtime.InteropServices;
  23 using System.Security.Permissions;
  24 #if FEATURE_ASYNC_IO
  25 using System.Threading.Tasks;
  26 #endif
  27
  28 namespace System.IO {
  29     // This class implements a text writer that writes to a string buffer and allows
  30     // the resulting sequence of characters to be presented as a string.
  31     //
  32     [Serializable]
  33     [ComVisible(true)]
  34     public class StringWriter : TextWriter
  35     {
  36         private static volatile UnicodeEncoding m_encoding=null;
  37
  38         private StringBuilder _sb;
  39         private bool _isOpen;
  40
  41         // Constructs a new StringWriter. A new StringBuilder is automatically
  42         // created and associated with the new StringWriter.
  43         public StringWriter()
  44             : this(new StringBuilder(), CultureInfo.CurrentCulture)
  45         {
  46         }
  47
  48         public StringWriter(IFormatProvider formatProvider)
  49             : this(new StringBuilder(), formatProvider) {
  50         }
  51
  52         // Constructs a new StringWriter that writes to the given StringBuilder.
  53         //
  54         public StringWriter(StringBuilder sb) : this(sb, CultureInfo.CurrentCulture) {
  55         }
  56
  57         public StringWriter(StringBuilder sb, IFormatProvider formatProvider) : base(formatProvider) {
  58             if (sb==null)
  59                 throw new ArgumentNullException("sb", Environment.GetResourceString("ArgumentNull_Buffer"));
  60             Contract.EndContractBlock();
  61             _sb = sb;
  62             _isOpen = true;
  63         }
  64
  65         public override void Close()
  66         {
  67             Dispose(true);
  68         }
  69
  70         protected override void Dispose(bool disposing)
  71         {
  72             // Do not destroy _sb, so that we can extract this after we are
  73             // done writing (similar to MemoryStream's GetBuffer & ToArray methods)
  74             _isOpen = false;
  75             base.Dispose(disposing);
  76         }
  77
  78
  79         public override Encoding Encoding {
  80             get {
  81                 if (m_encoding==null) {
  82                     m_encoding = new UnicodeEncoding(false, false);
  83                 }
  84                 return m_encoding;
  85             }
  86         }
  87
  88         // Returns the underlying StringBuilder. This is either the StringBuilder
  89         // that was passed to the constructor, or the StringBuilder that was
  90         // automatically created.
  91         //
  92         public virtual StringBuilder GetStringBuilder() {
  93             return _sb;
  94         }
  95
  96         // Writes a character to the underlying string buffer.
  97         //
  98         public override void Write(char value) {
  99             if (!_isOpen)
 100                 __Error.WriterClosed();
 101             _sb.Append(value);
 102         }
 103
 104         // Writes a range of a character array to the underlying string buffer.
 105         // This method will write count characters of data into this
 106         // StringWriter from the buffer character array starting at position
 107         // index.
 108         //
 109         public override void Write(char[] buffer, int index, int count) {
 110             if (buffer==null)
 111                 throw new ArgumentNullException("buffer", Environment.GetResourceString("ArgumentNull_Buffer"));
 112             if (index < 0)
 113                 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
 114             if (count < 0)
 115                 throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
 116             if (buffer.Length - index < count)
 117                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
 118             Contract.EndContractBlock();
 119
 120             if (!_isOpen)
 121                 __Error.WriterClosed();
 122
 123             _sb.Append(buffer, index, count);
 124         }
 125
 126         // Writes a string to the underlying string buffer. If the given string is
 127         // null, nothing is written.
 128         //
 129         public override void Write(String value) {
 130             if (!_isOpen)
 131                 __Error.WriterClosed();
 132             if (value != null) _sb.Append(value);
 133         }
 134
 135
 136 #if FEATURE_ASYNC_IO
 137         #region Task based Async APIs
 138         [HostProtection(ExternalThreading = true)]
 139         [ComVisible(false)]
 140         public override Task WriteAsync(char value)
 141         {
 142             Write(value);
 143             return Task.CompletedTask;
 144         }
 145
 146         [HostProtection(ExternalThreading = true)]
 147         [ComVisible(false)]
 148         public override Task WriteAsync(String value)
 149         {
 150             Write(value);
 151             return Task.CompletedTask;
 152         }
 153
 154         [HostProtection(ExternalThreading = true)]
 155         [ComVisible(false)]
 156         public override Task WriteAsync(char[] buffer, int index, int count)
 157         {
 158             Write(buffer, index, count);
 159             return Task.CompletedTask;
 160         }
 161
 162         [HostProtection(ExternalThreading = true)]
 163         [ComVisible(false)]
 164         public override Task WriteLineAsync(char value)
 165         {
 166             WriteLine(value);
 167             return Task.CompletedTask;
 168         }
 169
 170         [HostProtection(ExternalThreading = true)]
 171         [ComVisible(false)]
 172         public override Task WriteLineAsync(String value)
 173         {
 174             WriteLine(value);
 175             return Task.CompletedTask;
 176         }
 177
 178         [HostProtection(ExternalThreading = true)]
 179         [ComVisible(false)]
 180         public override Task WriteLineAsync(char[] buffer, int index, int count)
 181         {
 182             WriteLine(buffer, index, count);
 183             return Task.CompletedTask;
 184         }
 185
 186         [HostProtection(ExternalThreading = true)]
 187         [ComVisible(false)]
 188         public override Task FlushAsync()
 189         {
 190             return Task.CompletedTask;
 191         }
 192         #endregion
 193 #endif //FEATURE_ASYNC_IO
 194
 195         // Returns a string containing the characters written to this TextWriter
 196         // so far.
 197         //
 198         public override String ToString() {
 199             return _sb.ToString();
 200         }
 201     }
 202 }