StringWriter

StringWriter

public class StringWriter : TextWriter
{
    private static volatile UnicodeEncoding m_encoding = null;

    private StringBuilder _sb;
    private bool _isOpen;

    public StringWriter()
        : this(new StringBuilder(), CultureInfo.CurrentCulture)
    {
    }
    public StringWriter(IFormatProvider formatProvider)
        : this(new StringBuilder(), formatProvider)
    {
    }
    public StringWriter(StringBuilder sb)
        : this(sb, CultureInfo.CurrentCulture)
    {
    }

    public override void Close()
    {
        Dispose(true);
    }

    protected override void Dispose(bool disposing)
    {
        _isOpen = false;
        base.Dispose(disposing);
    }


    public override Encoding Encoding
    {
        get
        {
            if (m_encoding == null)
            {
                m_encoding = new UnicodeEncoding(false, false);
            }
            return m_encoding;
        }
    }

    public override void Write(char value)
    {
        if (!_isOpen)
            __Error.WriterClosed();
        _sb.Append(value);
    }

    public override void Write(String value)
    {
        if (!_isOpen)
            __Error.WriterClosed();
        if (value != null) _sb.Append(value);
    }


    #region ASYNC_IO

    public override Task WriteAsync(char value)
    {
        Write(value);

        return Task.CompletedTask;
    }

    public override Task WriteAsync(String value)
    {
        Write(value);

        return Task.CompletedTask;
    }

    #endregion

    /*
    public static Task CompletedTask
    {
        get
        {
            var completedTask = s_completedTask;
            if (completedTask == null)
                s_completedTask = completedTask = new Task(false, (TaskCreationOptions)InternalTaskOptions.DoNotDispose, default(CancellationToken)); 
            return completedTask;
        }
    }
    */
}

 

TextWriter

public abstract class TextWriter : MarshalByRefObject, IDisposable
{
    public virtual void Close()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

　　 protected virtual void Dispose(bool disposing)
    {
    }


    public abstract Encoding Encoding
    {
        get;
    }


    #region Task based Async APIs

    public virtual Task WriteAsync(char value)
    {
        Tuple<TextWriter, char> tuple = new Tuple<TextWriter, char>(this, value);

        return Task.Factory.StartNew(_WriteCharDelegate, tuple, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
    }

    public virtual Task WriteAsync(String value)
    {
        Tuple<TextWriter, string> tuple = new Tuple<TextWriter, string>(this, value);

        return Task.Factory.StartNew(_WriteStringDelegate, tuple, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
    }

    #endregion
}