QuoteChar

override char System.Xml.XmlTextReaderImpl.QuoteChar

get

Definition at line 1101 of file XmlTextReaderImpl.cs.

    {
        get
        {
            if (_curNode.type != XmlNodeType.Attribute)
            {
                return '"';
            }
            return _curNode.quoteChar;
        }
    }
 
    public override XmlSpace XmlSpace => _xmlContext.xmlSpace;
 
    public override string XmlLang => _xmlContext.xmlLang;
 
    public override ReadState ReadState => _readState;
 
    public override bool EOF => _parsingFunction == ParsingFunction.Eof;
 
    public override XmlNameTable NameTable => _nameTable;
 
    public override bool CanResolveEntity => true;
 
    public override int AttributeCount => _attrCount;
 
    internal XmlReader OuterReader
    {
        set
        {
            _outerReader = value;
        }
    }
 
    public override bool CanReadBinaryContent => true;
 
    public override bool CanReadValueChunk => true;
 
    public int LineNumber => _curNode.LineNo;
 
    public int LinePosition => _curNode.LinePos;
 
    internal bool Namespaces
    {
        get
        {
            return _supportNamespaces;
        }
        set
        {
            if (_readState != 0)
            {
                throw new InvalidOperationException(System.SR.Xml_InvalidOperation);
            }
            _supportNamespaces = value;
            if (value)
            {
                if (_namespaceManager is NoNamespaceManager)
                {
                    if (_fragment && _fragmentParserContext != null && _fragmentParserContext.NamespaceManager != null)
                    {
                        _namespaceManager = _fragmentParserContext.NamespaceManager;
                    }
                    else
                    {
                        _namespaceManager = new XmlNamespaceManager(_nameTable);
                    }
                }
                _xmlContext.defaultNamespace = _namespaceManager.LookupNamespace(string.Empty);
            }
            else
            {
                if (!(_namespaceManager is NoNamespaceManager))
                {
                    _namespaceManager = new NoNamespaceManager();
                }
                _xmlContext.defaultNamespace = string.Empty;
            }
        }
    }
 
    internal bool Normalization
    {
        get
        {
            return _normalize;
        }
        set
        {
            if (_readState == ReadState.Closed)
            {
                throw new InvalidOperationException(System.SR.Xml_InvalidOperation);
            }
            _normalize = value;
            if (_ps.entity == null || _ps.entity.IsExternal)
            {
                _ps.eolNormalized = !value;
            }
        }
    }
 
    internal Encoding Encoding
    {
        get
        {
            if (_readState != ReadState.Interactive)
            {
                return null;
            }
            return _reportedEncoding;
        }
    }
 
    internal WhitespaceHandling WhitespaceHandling
    {
        get
        {
            return _whitespaceHandling;
        }
        set
        {
            if (_readState == ReadState.Closed)
            {
                throw new InvalidOperationException(System.SR.Xml_InvalidOperation);
            }
            if ((uint)value > 2u)
            {
                throw new XmlException(System.SR.Xml_WhitespaceHandling, string.Empty);
            }
            _whitespaceHandling = value;
        }
    }
 
    internal DtdProcessing DtdProcessing
    {
        get
        {
            return _dtdProcessing;
        }
        set
        {
            if ((uint)value > 2u)
            {
                throw new ArgumentOutOfRangeException("value");
            }
            _dtdProcessing = value;
        }
    }
 
    internal EntityHandling EntityHandling
    {
        get
        {
            return _entityHandling;
        }
        set
        {
            if (value != EntityHandling.ExpandEntities && value != EntityHandling.ExpandCharEntities)
            {
                throw new XmlException(System.SR.Xml_EntityHandling, string.Empty);
            }
            _entityHandling = value;
        }
    }
 
    internal bool IsResolverSet => _xmlResolverIsSet;
 
    internal XmlResolver XmlResolver
    {
        set
        {
            _xmlResolver = value;
            _xmlResolverIsSet = true;
            _ps.baseUri = null;
            for (int i = 0; i <= _parsingStatesStackTop; i++)
            {
                _parsingStatesStack[i].baseUri = null;
            }
        }
    }
 
    internal XmlNameTable DtdParserProxy_NameTable => _nameTable;
 
    internal IXmlNamespaceResolver DtdParserProxy_NamespaceResolver => _namespaceManager;
 
    internal bool DtdParserProxy_DtdValidation => DtdValidation;
 
    internal bool DtdParserProxy_Normalization => _normalize;
 
    internal bool DtdParserProxy_Namespaces => _supportNamespaces;
 
    internal bool DtdParserProxy_V1CompatibilityMode => _v1Compat;
 
    internal Uri DtdParserProxy_BaseUri
    {
        get
        {
            if (_ps.baseUriStr.Length > 0 && _ps.baseUri == null && _xmlResolver != null)
            {
                _ps.baseUri = _xmlResolver.ResolveUri(null, _ps.baseUriStr);
            }
            return _ps.baseUri;
        }
    }
 
    internal bool DtdParserProxy_IsEof => _ps.isEof;
 
    internal char[] DtdParserProxy_ParsingBuffer => _ps.chars;
 
    internal int DtdParserProxy_ParsingBufferLength => _ps.charsUsed;
 
    internal int DtdParserProxy_CurrentPosition
    {
        get
        {
            return _ps.charPos;
        }
        set
        {
            _ps.charPos = value;
        }
    }
 
    internal int DtdParserProxy_EntityStackLength => _parsingStatesStackTop + 1;
 
    internal bool DtdParserProxy_IsEntityEolNormalized => _ps.eolNormalized;
 
    internal IValidationEventHandling DtdParserProxy_ValidationEventHandling => _validationEventHandling;
 
    internal int DtdParserProxy_LineNo => _ps.LineNo;
 
    internal int DtdParserProxy_LineStartPosition => _ps.lineStartPos;
 
    private bool IsResolverNull
    {
        get
        {
            if (_xmlResolver != null)
            {
                return !_xmlResolverIsSet;
            }
            return true;
        }
    }
 
    private bool InAttributeValueIterator
    {
        get
        {
            if (_attrCount > 0)
            {
                return _parsingFunction >= ParsingFunction.InReadAttributeValue;
            }
            return false;
        }
    }
 
    private bool DtdValidation => _validationEventHandling != null;
 
    private bool InEntity => _parsingStatesStackTop >= 0;
 
    internal override IDtdInfo DtdInfo => _dtdInfo;
 
    internal IValidationEventHandling ValidationEventHandling
    {
        set
        {
            _validationEventHandling = value;
        }
    }
 
    internal OnDefaultAttributeUseDelegate OnDefaultAttributeUse
    {
        set
        {
            _onDefaultAttributeUse = value;
        }
    }
 
    internal bool XmlValidatingReaderCompatibilityMode
    {
        set
        {
            _validatingReaderCompatFlag = value;
            if (value)
            {
                _nameTable.Add("http://www.w3.org/2001/XMLSchema");
                _nameTable.Add("http://www.w3.org/2001/XMLSchema-instance");
                _nameTable.Add("urn:schemas-microsoft-com:datatypes");
            }
        }
    }