◆ ReadValueChunk()

override int System.Xml.XmlTextReaderImpl.ReadValueChunk	(	char[]	buffer,
		int	index,
		int	count )
inlinevirtual
Reimplemented from System.Xml.XmlReader.
Definition at line 2474 of file XmlTextReaderImpl.cs.
    {
        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 num = 0;
        int num2 = _curNode.CopyTo(_readValueOffset, buffer, index + num, count - num);
        num += num2;
        _readValueOffset += num2;
        if (num == count)
        {
            char ch = buffer[index + count - 1];
            if (XmlCharType.IsHighSurrogate(ch))
            {
                num--;
                _readValueOffset--;
                if (num == 0)
                {
                    Throw(System.SR.Xml_NotEnoughSpaceForSurrogatePair);
                }
            }
            return num;
        }
        if (_incReadState == IncrementalReadState.ReadValueChunk_OnPartialValue)
        {
            _curNode.SetValue(string.Empty);
            bool flag = false;
            int startPos = 0;
            int endPos = 0;
            while (num < count && !flag)
            {
                int outOrChars = 0;
                flag = ParseText(out startPos, out endPos, ref outOrChars);
                int num3 = count - num;
                if (num3 > endPos - startPos)
                {
                    num3 = endPos - startPos;
                }
                BlockCopyChars(_ps.chars, startPos, buffer, index + num, num3);
                num += num3;
                startPos += num3;
            }
            _incReadState = (flag ? IncrementalReadState.ReadValueChunk_OnCachedValue : IncrementalReadState.ReadValueChunk_OnPartialValue);
            if (num == count)
            {
                char ch2 = buffer[index + count - 1];
                if (XmlCharType.IsHighSurrogate(ch2))
                {
                    num--;
                    startPos--;
                    if (num == 0)
                    {
                        Throw(System.SR.Xml_NotEnoughSpaceForSurrogatePair);
                    }
                }
            }
            _readValueOffset = 0;
            _curNode.SetValue(_ps.chars, startPos, endPos - startPos);
        }
        return num;
    }