public object GetRealObject (StreamingContext context)
		{
			if (this.realObject == null)
				this.realObject = this.encoding.GetEncoder ();

			return this.realObject;
		}

 // Protected default constructor that sets the output stream
 // to a null stream (a bit bucket).
 protected EndianWriter()
 {
     OutStream = Stream.Null;
     buffer = new byte[16];
     Encoding = new UTF8Encoding(false, true);
     encoder = Encoding.GetEncoder();
 }

 public XmlEncodedRawTextWriter(Stream stream, XmlWriterSettings settings) : this(settings)
 {
     this.stream = stream;
     this.encoding = settings.Encoding;
     this.bufChars = new char[0x1820];
     this.bufBytes = new byte[this.bufChars.Length];
     this.bufBytesUsed = 0;
     this.trackTextContent = true;
     this.inTextContent = false;
     this.lastMarkPos = 0;
     this.textContentMarks = new int[0x40];
     this.textContentMarks[0] = 1;
     this.charEntityFallback = new CharEntityEncoderFallback();
     this.encoding = (Encoding) settings.Encoding.Clone();
     this.encoding.EncoderFallback = this.charEntityFallback;
     this.encoder = this.encoding.GetEncoder();
     if (!stream.CanSeek || (stream.Position == 0L))
     {
         byte[] preamble = this.encoding.GetPreamble();
         if (preamble.Length != 0)
         {
             this.stream.Write(preamble, 0, preamble.Length);
         }
     }
     if (settings.AutoXmlDeclaration)
     {
         this.WriteXmlDeclaration(this.standalone);
         this.autoXmlDeclaration = true;
     }
 }

 // Protected default constructor that sets the output stream
 // to a null stream (a bit bucket).
 protected BinaryWriter()
 {
     OutStream = Stream.Null;
     _buffer = new byte[16];
     _encoding = new UTF8Encoding(false, true);
     _encoder = _encoding.GetEncoder();
 }

 public MemoryPoolTextWriter(IMemoryPool memory)
 {
     _memory = memory;
     _textArray = _memory.AllocChar(_textLength);
     _dataArray = _memory.Empty;
     _encoder = Encoding.UTF8.GetEncoder();
 }

 /// <summary>
 /// 构造函数
 /// </summary>
 public ByteBuffer()
 {
     this.BaseStream = new MemoryStream();
     this._buffer = new byte[0x10];
     this._encoding = Encoding.Default;//(false, true);
     this._encoder = this._encoding.GetEncoder();
 }

        static StaticUtils()
        {
            asciiDecoder = Encoding.ASCII.GetDecoder();

            utf8Encoder = Encoding.UTF8.GetEncoder();
            utf8Decoder = Encoding.UTF8.GetDecoder();
        }

        public HttpResponseStreamWriter(Stream stream, Encoding encoding, int bufferSize)
        {
            if (stream == null)
            {
                throw new ArgumentNullException(nameof(stream));
            }

            if (!stream.CanWrite)
            {
                throw new ArgumentException(Resources.HttpResponseStreamWriter_StreamNotWritable, nameof(stream));
            }

            if (encoding == null)
            {
                throw new ArgumentNullException(nameof(encoding));
            }

            _stream = stream;
            Encoding = encoding;
            _charBufferSize = bufferSize;

            if (bufferSize < MinBufferSize)
            {
                bufferSize = MinBufferSize;
            }

            _encoder = encoding.GetEncoder();
            _byteBuffer = new byte[encoding.GetMaxByteCount(bufferSize)];
            _charBuffer = new char[bufferSize];
        }

 // Protected default constructor that sets the output stream
 // to a null stream (a bit bucket).
 protected BinaryWriter()
 {
     OutStream = Stream.Null;
     _buffer = new byte[16];
     _encoding = EncodingCache.UTF8NoBOM;
     _encoder = _encoding.GetEncoder();
 }

 public MemoryPoolTextWriter(IMemoryPool memory)
     : base(CultureInfo.InvariantCulture)
 {
     _memory = memory;
     _textArray = _memory.AllocChar(_textLength);
     _dataArray = MemoryPool.EmptyArray;
     _encoder = Encoding.UTF8.GetEncoder();
 }

 public static int Hash(string data, Encoder enc)
 {
     var arr = data.ToCharArray();
     int count = enc.GetByteCount(arr, 0, arr.Length, false);
     var bytes = new byte[count];
     enc.GetBytes(arr, 0, arr.Length, bytes, 0, false);
     return Hash(bytes);
 }

 protected BinaryWriter()
 {
     this._tmpOneCharBuffer = new char[1];
     this.OutStream = Stream.Null;
     this._buffer = new byte[0x10];
     this._encoding = new UTF8Encoding(false, true);
     this._encoder = this._encoding.GetEncoder();
 }

 public TextReaderStream(TextReader textReader, Encoding encoding, int bufferSize = 4096)
 {
     _textReader = textReader;
     _encoding = encoding;
     _maxByteCountPerChar = _encoding.GetMaxByteCount(1);
     _encoder = encoding.GetEncoder();
     if (bufferSize <= 0) throw new ArgumentOutOfRangeException("bufferSize", "zero or negative");
     _charBuffer = new char[bufferSize];
 }

 public HttpResponseStreamWriter(Stream stream, Encoding encoding, int bufferSize)
 {
     _stream = stream;
     Encoding = encoding;
     _encoder = encoding.GetEncoder();
     _charBufferSize = bufferSize;
     _charBuffer = new ArraySegment<char>(new char[bufferSize]);
     _byteBuffer = new ArraySegment<byte>(new byte[encoding.GetMaxByteCount(bufferSize)]);
 }

		public LineWriter(Stream stream, int bufferSize) {
			if (bufferSize < 1024)
				bufferSize = 1024;

			this.stream = stream;
			writeBuffer = new byte[bufferSize];
			writeBufferOffset = 0;
			encoder = Encoding.UTF8.GetEncoder();
		}

 public HttpResponseStreamWriter([NotNull] Stream stream, [NotNull] Encoding encoding, int bufferSize)
 {
     _stream = stream;
     Encoding = encoding;
     _encoder = encoding.GetEncoder();
     _charBufferSize = bufferSize;
     _charBuffer = new char[bufferSize];
     _byteBuffer = new byte[encoding.GetMaxByteCount(bufferSize)];
 }

        public MemoryPoolTextWriter(IMemoryPool memory)
        {
            _memory = memory;
            _textArray = _memory.AllocChar(_textLength);
            _dataArray = _memory.Empty;
            _encoder = Encoding.UTF8.GetEncoder();

            // Default new lines to \n
            NewLine = "\n";
        }

        private int GetByteCount(char[] chars, int index, int count,
            bool flush, Encoder encoder) {
            if (chars == null) {
                throw new ArgumentNullException("chars", 
                    Environment.GetResourceString("ArgumentNull_Array"));
            }
            if (index < 0 || count < 0) {
                throw new ArgumentOutOfRangeException((index<0 ? "index" : "count"),
                    Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            }
            if (chars.Length - index < count) {
                throw new ArgumentOutOfRangeException("chars",
                      Environment.GetResourceString("ArgumentOutOfRange_IndexCountBuffer"));
            }
            int bitCount = -1;
            if (encoder != null) bitCount = encoder.bitCount;
            int end = index + count;
            int byteCount = 0;
            while (index < end && byteCount >= 0) {
                int c = chars[index++];
                if (c < 0x80 && directEncode[c]) {
                    if (bitCount >= 0) {
                        if (bitCount > 0) byteCount++;
                        byteCount++;
                        bitCount = -1;
                    }
                    byteCount++;
                }
                else if (bitCount < 0 && c == '+') {
                    byteCount += 2;
                }
                else {
                    if (bitCount < 0) {
                        byteCount++;
                        bitCount = 0;
                    }
                    bitCount += 16;
                    while (bitCount >= 6) {
                        bitCount -= 6;
                        byteCount++;
                    }
                }
            }
            if (flush && bitCount >= 0) {
                if (bitCount > 0) byteCount++;
                byteCount++;
            }

            // Check for overflows.
            if (byteCount < 0)
                throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_GetByteCountOverflow"));

            return byteCount;
        }

 public SourceTextStream(SourceText source, int bufferSize = 2048)
 {
     _source = source;
     _encoder = source.Encoding.GetEncoder();
     _sourceOffset = 0;
     _position = 0;
     _charBuffer = new char[Math.Min(bufferSize, _source.Length)];
     _bufferOffset = 0;
     _bufferUnreadChars = 0;
     _preambleWritten = false;
 }

        private TranscodingStream(Stream stream, Encoding outEncoding)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

            if (outEncoding == null)
                throw new ArgumentNullException("outEncoding");

            this._stream = stream;
            this._encoder = outEncoding.GetEncoder();
        }