◆ ReadValueChunkAsync()

override async Task< int > System.Xml.XmlTextReaderImpl.ReadValueChunkAsync	(	char[]	buffer,
		int	index,
		int	count )
inlinevirtual
Reimplemented from System.Xml.XmlReader.
Definition at line 9077 of file XmlTextReaderImpl.cs.
    {
        CheckAsyncCall();
        if (!XmlReader.HasValueInternal(_curNode.type))
        {
            throw new InvalidOperationException(System.SR.Format(System.SR.Xml_InvalidReadValueChunk, _curNode.type));
        }
        if (buffer == null)
        {
            throw new ArgumentNullException("buffer");
        }
        if (count < 0)
        {
            throw new ArgumentOutOfRangeException("count");
        }
        if (index < 0)
        {
            throw new ArgumentOutOfRangeException("index");
        }
        if (buffer.Length - index < count)
        {
            throw new ArgumentOutOfRangeException("count");
        }
        if (_parsingFunction != ParsingFunction.InReadValueChunk)
        {
            if (_readState != ReadState.Interactive)
            {
                return 0;
            }
            if (_parsingFunction == ParsingFunction.PartialTextValue)
            {
                _incReadState = IncrementalReadState.ReadValueChunk_OnPartialValue;
            }
            else
            {
                _incReadState = IncrementalReadState.ReadValueChunk_OnCachedValue;
                _nextNextParsingFunction = _nextParsingFunction;
                _nextParsingFunction = _parsingFunction;
            }
            _parsingFunction = ParsingFunction.InReadValueChunk;
            _readValueOffset = 0;
        }
        if (count == 0)
        {
            return 0;
        }
        int readCount2 = 0;
        int num = _curNode.CopyTo(_readValueOffset, buffer, index + readCount2, count - readCount2);
        readCount2 += num;
        _readValueOffset += num;
        if (readCount2 == count)
        {
            char ch = buffer[index + count - 1];
            if (XmlCharType.IsHighSurrogate(ch))
            {
                readCount2--;
                _readValueOffset--;
                if (readCount2 == 0)
                {
                    Throw(System.SR.Xml_NotEnoughSpaceForSurrogatePair);
                }
            }
            return readCount2;
        }
        if (_incReadState == IncrementalReadState.ReadValueChunk_OnPartialValue)
        {
            _curNode.SetValue(string.Empty);
            bool flag = false;
            int num2 = 0;
            int num3 = 0;
            while (readCount2 < count && !flag)
            {
                int outOrChars = 0;
                (int, int, int, bool) tuple = await ParseTextAsync(outOrChars).ConfigureAwait(continueOnCapturedContext: false);
                (num2, num3, _, _) = tuple;
                _ = tuple.Item3;
                flag = tuple.Item4;
                int num4 = count - readCount2;
                if (num4 > num3 - num2)
                {
                    num4 = num3 - num2;
                }
                BlockCopyChars(_ps.chars, num2, buffer, index + readCount2, num4);
                readCount2 += num4;
                num2 += num4;
            }
            _incReadState = (flag ? IncrementalReadState.ReadValueChunk_OnCachedValue : IncrementalReadState.ReadValueChunk_OnPartialValue);
            if (readCount2 == count)
            {
                char ch2 = buffer[index + count - 1];
                if (XmlCharType.IsHighSurrogate(ch2))
                {
                    readCount2--;
                    num2--;
                    if (readCount2 == 0)
                    {
                        Throw(System.SR.Xml_NotEnoughSpaceForSurrogatePair);
                    }
                }
            }
            _readValueOffset = 0;
            _curNode.SetValue(_ps.chars, num2, num3 - num2);
        }
        return readCount2;
    }