◆ ReadDataAsync()

async Task< int > System.Xml.XmlTextReaderImpl.ReadDataAsync ( )
inlineprivate
Definition at line 9401 of file XmlTextReaderImpl.cs.
    {
        if (_ps.isEof)
        {
            return 0;
        }
        int charsRead;
        if (_ps.appendMode)
        {
            if (_ps.charsUsed == _ps.chars.Length - 1)
            {
                for (int i = 0; i < _attrCount; i++)
                {
                    _nodes[_index + i + 1].OnBufferInvalidated();
                }
                char[] array = new char[_ps.chars.Length * 2];
                BlockCopyChars(_ps.chars, 0, array, 0, _ps.chars.Length);
                _ps.chars = array;
            }
            if (_ps.stream != null && _ps.bytesUsed - _ps.bytePos < 6 && _ps.bytes.Length - _ps.bytesUsed < 6)
            {
                byte[] array2 = new byte[_ps.bytes.Length * 2];
                BlockCopy(_ps.bytes, 0, array2, 0, _ps.bytesUsed);
                _ps.bytes = array2;
            }
            charsRead = _ps.chars.Length - _ps.charsUsed - 1;
            if (charsRead > 80)
            {
                charsRead = 80;
            }
        }
        else
        {
            int num = _ps.chars.Length;
            if (num - _ps.charsUsed <= num / 2)
            {
                for (int j = 0; j < _attrCount; j++)
                {
                    _nodes[_index + j + 1].OnBufferInvalidated();
                }
                int num2 = _ps.charsUsed - _ps.charPos;
                if (num2 < num - 1)
                {
                    _ps.lineStartPos -= _ps.charPos;
                    if (num2 > 0)
                    {
                        BlockCopyChars(_ps.chars, _ps.charPos, _ps.chars, 0, num2);
                    }
                    _ps.charPos = 0;
                    _ps.charsUsed = num2;
                }
                else
                {
                    char[] array3 = new char[_ps.chars.Length * 2];
                    BlockCopyChars(_ps.chars, 0, array3, 0, _ps.chars.Length);
                    _ps.chars = array3;
                }
            }
            if (_ps.stream != null)
            {
                int num3 = _ps.bytesUsed - _ps.bytePos;
                if (num3 <= 128)
                {
                    if (num3 == 0)
                    {
                        _ps.bytesUsed = 0;
                    }
                    else
                    {
                        BlockCopy(_ps.bytes, _ps.bytePos, _ps.bytes, 0, num3);
                        _ps.bytesUsed = num3;
                    }
                    _ps.bytePos = 0;
                }
            }
            charsRead = _ps.chars.Length - _ps.charsUsed - 1;
        }
        if (_ps.stream != null)
        {
            if (!_ps.isStreamEof && _ps.bytePos == _ps.bytesUsed && _ps.bytes.Length - _ps.bytesUsed > 0)
            {
                int num4 = await _ps.stream.ReadAsync(_ps.bytes.AsMemory(_ps.bytesUsed)).ConfigureAwait(continueOnCapturedContext: false);
                if (num4 == 0)
                {
                    _ps.isStreamEof = true;
                }
                _ps.bytesUsed += num4;
            }
            int bytePos = _ps.bytePos;
            charsRead = GetChars(charsRead);
            if (charsRead == 0 && _ps.bytePos != bytePos)
            {
                return await ReadDataAsync().ConfigureAwait(continueOnCapturedContext: false);
            }
        }
        else if (_ps.textReader != null)
        {
            charsRead = await _ps.textReader.ReadAsync(_ps.chars.AsMemory(_ps.charsUsed, _ps.chars.Length - _ps.charsUsed - 1)).ConfigureAwait(continueOnCapturedContext: false);
            _ps.charsUsed += charsRead;
        }
        else
        {
            charsRead = 0;
        }
        RegisterConsumedCharacters(charsRead, InEntity);
        if (charsRead == 0)
        {
            _ps.isEof = true;
        }
        _ps.chars[_ps.charsUsed] = '\0';
        return charsRead;
    }