XmlReader.cs

using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Schema;

namespace System.Xml
{
    [DebuggerDisplay("{debuggerDisplayProxy}")]
    [DebuggerDisplay("{debuggerDisplayProxy}")]
    [global::__DynamicallyInvokable]
    public abstract class XmlReader : IDisposable
    {
        [DebuggerDisplay("{ToString()}")]
        private struct XmlReaderDebuggerDisplayProxy
        {
            private XmlReader reader;

            internal XmlReaderDebuggerDisplayProxy(XmlReader reader)
            {
                this.reader = reader;
            }

            public override string ToString()
            {
                XmlNodeType nodeType = reader.NodeType;
                string text = nodeType.ToString();
                switch (nodeType)
                {
                case XmlNodeType.Element:
                case XmlNodeType.EntityReference:
                case XmlNodeType.EndElement:
                case XmlNodeType.EndEntity:
                    text = text + ", Name=\"" + reader.Name + "\"";
                    break;
                case XmlNodeType.Attribute:
                case XmlNodeType.ProcessingInstruction:
                    text = text + ", Name=\"" + reader.Name + "\", Value=\"" + XmlConvert.EscapeValueForDebuggerDisplay(reader.Value) + "\"";
                    break;
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                case XmlNodeType.Comment:
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                case XmlNodeType.XmlDeclaration:
                    text = text + ", Value=\"" + XmlConvert.EscapeValueForDebuggerDisplay(reader.Value) + "\"";
                    break;
                case XmlNodeType.DocumentType:
                    text = text + ", Name=\"" + reader.Name + "'";
                    text = text + ", SYSTEM=\"" + reader.GetAttribute("SYSTEM") + "\"";
                    text = text + ", PUBLIC=\"" + reader.GetAttribute("PUBLIC") + "\"";
                    text = text + ", Value=\"" + XmlConvert.EscapeValueForDebuggerDisplay(reader.Value) + "\"";
                    break;
                }
                return text;
            }
        }

        private static uint IsTextualNodeBitmap = 24600u;

        private static uint CanReadContentAsBitmap = 123324u;

        private static uint HasValueBitmap = 157084u;

        internal const int DefaultBufferSize = 4096;

        internal const int BiggerBufferSize = 8192;

        internal const int MaxStreamLengthForDefaultBufferSize = 65536;

        internal const int AsyncBufferSize = 65536;

        [global::__DynamicallyInvokable]
        public virtual XmlReaderSettings Settings
        {
            [global::__DynamicallyInvokable]
            get
            {
                return null;
            }
        }

        [global::__DynamicallyInvokable]
        public abstract XmlNodeType NodeType
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public virtual string Name
        {
            [global::__DynamicallyInvokable]
            get
            {
                if (Prefix.Length == 0)
                {
                    return LocalName;
                }
                return NameTable.Add(Prefix + ":" + LocalName);
            }
        }

        [global::__DynamicallyInvokable]
        public abstract string LocalName
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public abstract string NamespaceURI
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public abstract string Prefix
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public virtual bool HasValue
        {
            [global::__DynamicallyInvokable]
            get
            {
                return HasValueInternal(NodeType);
            }
        }

        [global::__DynamicallyInvokable]
        public abstract string Value
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public abstract int Depth
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public abstract string BaseURI
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public abstract bool IsEmptyElement
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public virtual bool IsDefault
        {
            [global::__DynamicallyInvokable]
            get
            {
                return false;
            }
        }

        public virtual char QuoteChar => '"';

        [global::__DynamicallyInvokable]
        public virtual XmlSpace XmlSpace
        {
            [global::__DynamicallyInvokable]
            get
            {
                return XmlSpace.None;
            }
        }

        [global::__DynamicallyInvokable]
        public virtual string XmlLang
        {
            [global::__DynamicallyInvokable]
            get
            {
                return string.Empty;
            }
        }

        public virtual IXmlSchemaInfo SchemaInfo => this as IXmlSchemaInfo;

        [global::__DynamicallyInvokable]
        public virtual Type ValueType
        {
            [global::__DynamicallyInvokable]
            get
            {
                return typeof(string);
            }
        }

        [global::__DynamicallyInvokable]
        public abstract int AttributeCount
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public virtual string this[int i]
        {
            [global::__DynamicallyInvokable]
            get
            {
                return GetAttribute(i);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual string this[string name]
        {
            [global::__DynamicallyInvokable]
            get
            {
                return GetAttribute(name);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual string this[string name, string namespaceURI]
        {
            [global::__DynamicallyInvokable]
            get
            {
                return GetAttribute(name, namespaceURI);
            }
        }

        [global::__DynamicallyInvokable]
        public abstract bool EOF
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public abstract ReadState ReadState
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public abstract XmlNameTable NameTable
        {
            [global::__DynamicallyInvokable]
            get;
        }

        [global::__DynamicallyInvokable]
        public virtual bool CanResolveEntity
        {
            [global::__DynamicallyInvokable]
            get
            {
                return false;
            }
        }

        [global::__DynamicallyInvokable]
        public virtual bool CanReadBinaryContent
        {
            [global::__DynamicallyInvokable]
            get
            {
                return false;
            }
        }

        [global::__DynamicallyInvokable]
        public virtual bool CanReadValueChunk
        {
            [global::__DynamicallyInvokable]
            get
            {
                return false;
            }
        }

        [global::__DynamicallyInvokable]
        public virtual bool HasAttributes
        {
            [global::__DynamicallyInvokable]
            get
            {
                return AttributeCount > 0;
            }
        }

        internal virtual XmlNamespaceManager NamespaceManager => null;

        internal bool IsDefaultInternal
        {
            get
            {
                if (IsDefault)
                {
                    return true;
                }
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null && schemaInfo.IsDefault)
                {
                    return true;
                }
                return false;
            }
        }

        internal virtual IDtdInfo DtdInfo => null;

        private object debuggerDisplayProxy => new XmlReaderDebuggerDisplayProxy(this);

        [global::__DynamicallyInvokable]
        public virtual object ReadContentAsObject()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsObject");
            }
            return InternalReadContentAsString();
        }

        [global::__DynamicallyInvokable]
        public virtual bool ReadContentAsBoolean()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsBoolean");
            }
            try
            {
                return XmlConvert.ToBoolean(InternalReadContentAsString());
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", "Boolean", innerException, this as IXmlLineInfo);
            }
        }

        public virtual DateTime ReadContentAsDateTime()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsDateTime");
            }
            try
            {
                return XmlConvert.ToDateTime(InternalReadContentAsString(), XmlDateTimeSerializationMode.RoundtripKind);
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", "DateTime", innerException, this as IXmlLineInfo);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual DateTimeOffset ReadContentAsDateTimeOffset()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsDateTimeOffset");
            }
            try
            {
                return XmlConvert.ToDateTimeOffset(InternalReadContentAsString());
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", "DateTimeOffset", innerException, this as IXmlLineInfo);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual double ReadContentAsDouble()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsDouble");
            }
            try
            {
                return XmlConvert.ToDouble(InternalReadContentAsString());
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", "Double", innerException, this as IXmlLineInfo);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual float ReadContentAsFloat()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsFloat");
            }
            try
            {
                return XmlConvert.ToSingle(InternalReadContentAsString());
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", "Float", innerException, this as IXmlLineInfo);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual decimal ReadContentAsDecimal()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsDecimal");
            }
            try
            {
                return XmlConvert.ToDecimal(InternalReadContentAsString());
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", "Decimal", innerException, this as IXmlLineInfo);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual int ReadContentAsInt()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsInt");
            }
            try
            {
                return XmlConvert.ToInt32(InternalReadContentAsString());
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", "Int", innerException, this as IXmlLineInfo);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual long ReadContentAsLong()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsLong");
            }
            try
            {
                return XmlConvert.ToInt64(InternalReadContentAsString());
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", "Long", innerException, this as IXmlLineInfo);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual string ReadContentAsString()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsString");
            }
            return InternalReadContentAsString();
        }

        [global::__DynamicallyInvokable]
        public virtual object ReadContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver)
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAs");
            }
            string text = InternalReadContentAsString();
            if (returnType == typeof(string))
            {
                return text;
            }
            try
            {
                return XmlUntypedConverter.Untyped.ChangeType(text, returnType, (namespaceResolver == null) ? (this as IXmlNamespaceResolver) : namespaceResolver);
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", returnType.ToString(), innerException, this as IXmlLineInfo);
            }
            catch (InvalidCastException innerException2)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", returnType.ToString(), innerException2, this as IXmlLineInfo);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual object ReadElementContentAsObject()
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAsObject"))
            {
                object result = ReadContentAsObject();
                FinishReadElementContentAsXxx();
                return result;
            }
            return string.Empty;
        }

        [global::__DynamicallyInvokable]
        public virtual object ReadElementContentAsObject(string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAsObject();
        }

        [global::__DynamicallyInvokable]
        public virtual bool ReadElementContentAsBoolean()
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAsBoolean"))
            {
                bool result = ReadContentAsBoolean();
                FinishReadElementContentAsXxx();
                return result;
            }
            return XmlConvert.ToBoolean(string.Empty);
        }

        [global::__DynamicallyInvokable]
        public virtual bool ReadElementContentAsBoolean(string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAsBoolean();
        }

        public virtual DateTime ReadElementContentAsDateTime()
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAsDateTime"))
            {
                DateTime result = ReadContentAsDateTime();
                FinishReadElementContentAsXxx();
                return result;
            }
            return XmlConvert.ToDateTime(string.Empty, XmlDateTimeSerializationMode.RoundtripKind);
        }

        public virtual DateTime ReadElementContentAsDateTime(string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAsDateTime();
        }

        [global::__DynamicallyInvokable]
        public virtual double ReadElementContentAsDouble()
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAsDouble"))
            {
                double result = ReadContentAsDouble();
                FinishReadElementContentAsXxx();
                return result;
            }
            return XmlConvert.ToDouble(string.Empty);
        }

        [global::__DynamicallyInvokable]
        public virtual double ReadElementContentAsDouble(string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAsDouble();
        }

        [global::__DynamicallyInvokable]
        public virtual float ReadElementContentAsFloat()
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAsFloat"))
            {
                float result = ReadContentAsFloat();
                FinishReadElementContentAsXxx();
                return result;
            }
            return XmlConvert.ToSingle(string.Empty);
        }

        [global::__DynamicallyInvokable]
        public virtual float ReadElementContentAsFloat(string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAsFloat();
        }

        [global::__DynamicallyInvokable]
        public virtual decimal ReadElementContentAsDecimal()
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAsDecimal"))
            {
                decimal result = ReadContentAsDecimal();
                FinishReadElementContentAsXxx();
                return result;
            }
            return XmlConvert.ToDecimal(string.Empty);
        }

        [global::__DynamicallyInvokable]
        public virtual decimal ReadElementContentAsDecimal(string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAsDecimal();
        }

        [global::__DynamicallyInvokable]
        public virtual int ReadElementContentAsInt()
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAsInt"))
            {
                int result = ReadContentAsInt();
                FinishReadElementContentAsXxx();
                return result;
            }
            return XmlConvert.ToInt32(string.Empty);
        }

        [global::__DynamicallyInvokable]
        public virtual int ReadElementContentAsInt(string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAsInt();
        }

        [global::__DynamicallyInvokable]
        public virtual long ReadElementContentAsLong()
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAsLong"))
            {
                long result = ReadContentAsLong();
                FinishReadElementContentAsXxx();
                return result;
            }
            return XmlConvert.ToInt64(string.Empty);
        }

        [global::__DynamicallyInvokable]
        public virtual long ReadElementContentAsLong(string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAsLong();
        }

        [global::__DynamicallyInvokable]
        public virtual string ReadElementContentAsString()
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAsString"))
            {
                string result = ReadContentAsString();
                FinishReadElementContentAsXxx();
                return result;
            }
            return string.Empty;
        }

        [global::__DynamicallyInvokable]
        public virtual string ReadElementContentAsString(string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAsString();
        }

        [global::__DynamicallyInvokable]
        public virtual object ReadElementContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver)
        {
            if (SetupReadElementContentAsXxx("ReadElementContentAs"))
            {
                object result = ReadContentAs(returnType, namespaceResolver);
                FinishReadElementContentAsXxx();
                return result;
            }
            if (!(returnType == typeof(string)))
            {
                return XmlUntypedConverter.Untyped.ChangeType(string.Empty, returnType, namespaceResolver);
            }
            return string.Empty;
        }

        [global::__DynamicallyInvokable]
        public virtual object ReadElementContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver, string localName, string namespaceURI)
        {
            CheckElement(localName, namespaceURI);
            return ReadElementContentAs(returnType, namespaceResolver);
        }

        [global::__DynamicallyInvokable]
        public abstract string GetAttribute(string name);

        [global::__DynamicallyInvokable]
        public abstract string GetAttribute(string name, string namespaceURI);

        [global::__DynamicallyInvokable]
        public abstract string GetAttribute(int i);

        [global::__DynamicallyInvokable]
        public abstract bool MoveToAttribute(string name);

        [global::__DynamicallyInvokable]
        public abstract bool MoveToAttribute(string name, string ns);

        [global::__DynamicallyInvokable]
        public virtual void MoveToAttribute(int i)
        {
            if (i < 0 || i >= AttributeCount)
            {
                throw new ArgumentOutOfRangeException("i");
            }
            MoveToElement();
            MoveToFirstAttribute();
            for (int j = 0; j < i; j++)
            {
                MoveToNextAttribute();
            }
        }

        [global::__DynamicallyInvokable]
        public abstract bool MoveToFirstAttribute();

        [global::__DynamicallyInvokable]
        public abstract bool MoveToNextAttribute();

        [global::__DynamicallyInvokable]
        public abstract bool MoveToElement();

        [global::__DynamicallyInvokable]
        public abstract bool ReadAttributeValue();

        [global::__DynamicallyInvokable]
        public abstract bool Read();

        public virtual void Close()
        {
        }

        [global::__DynamicallyInvokable]
        public virtual void Skip()
        {
            if (ReadState == ReadState.Interactive)
            {
                SkipSubtree();
            }
        }

        [global::__DynamicallyInvokable]
        public abstract string LookupNamespace(string prefix);

        [global::__DynamicallyInvokable]
        public abstract void ResolveEntity();

        [global::__DynamicallyInvokable]
        public virtual int ReadContentAsBase64(byte[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadBinaryContentNotSupported", "ReadContentAsBase64"));
        }

        [global::__DynamicallyInvokable]
        public virtual int ReadElementContentAsBase64(byte[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadBinaryContentNotSupported", "ReadElementContentAsBase64"));
        }

        [global::__DynamicallyInvokable]
        public virtual int ReadContentAsBinHex(byte[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadBinaryContentNotSupported", "ReadContentAsBinHex"));
        }

        [global::__DynamicallyInvokable]
        public virtual int ReadElementContentAsBinHex(byte[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadBinaryContentNotSupported", "ReadElementContentAsBinHex"));
        }

        [global::__DynamicallyInvokable]
        public virtual int ReadValueChunk(char[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadValueChunkNotSupported"));
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public virtual string ReadString()
        {
            if (ReadState != ReadState.Interactive)
            {
                return string.Empty;
            }
            MoveToElement();
            if (NodeType == XmlNodeType.Element)
            {
                if (IsEmptyElement)
                {
                    return string.Empty;
                }
                if (!Read())
                {
                    throw new InvalidOperationException(Res.GetString("Xml_InvalidOperation"));
                }
                if (NodeType == XmlNodeType.EndElement)
                {
                    return string.Empty;
                }
            }
            string text = string.Empty;
            while (IsTextualNode(NodeType))
            {
                text += Value;
                if (!Read())
                {
                    break;
                }
            }
            return text;
        }

        [global::__DynamicallyInvokable]
        public virtual XmlNodeType MoveToContent()
        {
            do
            {
                switch (NodeType)
                {
                case XmlNodeType.Attribute:
                    MoveToElement();
                    break;
                case XmlNodeType.Element:
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                case XmlNodeType.EntityReference:
                case XmlNodeType.EndElement:
                case XmlNodeType.EndEntity:
                    break;
                default:
                    continue;
                }
                return NodeType;
            }
            while (Read());
            return NodeType;
        }

        [global::__DynamicallyInvokable]
        public virtual void ReadStartElement()
        {
            if (MoveToContent() != XmlNodeType.Element)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
            }
            Read();
        }

        [global::__DynamicallyInvokable]
        public virtual void ReadStartElement(string name)
        {
            if (MoveToContent() != XmlNodeType.Element)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
            }
            if (Name == name)
            {
                Read();
                return;
            }
            throw new XmlException("Xml_ElementNotFound", name, this as IXmlLineInfo);
        }

        [global::__DynamicallyInvokable]
        public virtual void ReadStartElement(string localname, string ns)
        {
            if (MoveToContent() != XmlNodeType.Element)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
            }
            if (LocalName == localname && NamespaceURI == ns)
            {
                Read();
                return;
            }
            throw new XmlException("Xml_ElementNotFoundNs", new string[2]
            {
                localname,
                ns
            }, this as IXmlLineInfo);
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public virtual string ReadElementString()
        {
            string result = string.Empty;
            if (MoveToContent() != XmlNodeType.Element)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
            }
            if (!IsEmptyElement)
            {
                Read();
                result = ReadString();
                if (NodeType != XmlNodeType.EndElement)
                {
                    throw new XmlException("Xml_UnexpectedNodeInSimpleContent", new string[2]
                    {
                        NodeType.ToString(),
                        "ReadElementString"
                    }, this as IXmlLineInfo);
                }
                Read();
            }
            else
            {
                Read();
            }
            return result;
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public virtual string ReadElementString(string name)
        {
            string result = string.Empty;
            if (MoveToContent() != XmlNodeType.Element)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
            }
            if (Name != name)
            {
                throw new XmlException("Xml_ElementNotFound", name, this as IXmlLineInfo);
            }
            if (!IsEmptyElement)
            {
                result = ReadString();
                if (NodeType != XmlNodeType.EndElement)
                {
                    throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
                }
                Read();
            }
            else
            {
                Read();
            }
            return result;
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public virtual string ReadElementString(string localname, string ns)
        {
            string result = string.Empty;
            if (MoveToContent() != XmlNodeType.Element)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
            }
            if (LocalName != localname || NamespaceURI != ns)
            {
                throw new XmlException("Xml_ElementNotFoundNs", new string[2]
                {
                    localname,
                    ns
                }, this as IXmlLineInfo);
            }
            if (!IsEmptyElement)
            {
                result = ReadString();
                if (NodeType != XmlNodeType.EndElement)
                {
                    throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
                }
                Read();
            }
            else
            {
                Read();
            }
            return result;
        }

        [global::__DynamicallyInvokable]
        public virtual void ReadEndElement()
        {
            if (MoveToContent() != XmlNodeType.EndElement)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
            }
            Read();
        }

        [global::__DynamicallyInvokable]
        public virtual bool IsStartElement()
        {
            return MoveToContent() == XmlNodeType.Element;
        }

        [global::__DynamicallyInvokable]
        public virtual bool IsStartElement(string name)
        {
            if (MoveToContent() == XmlNodeType.Element)
            {
                return Name == name;
            }
            return false;
        }

        [global::__DynamicallyInvokable]
        public virtual bool IsStartElement(string localname, string ns)
        {
            if (MoveToContent() == XmlNodeType.Element)
            {
                if (LocalName == localname)
                {
                    return NamespaceURI == ns;
                }
                return false;
            }
            return false;
        }

        [global::__DynamicallyInvokable]
        public virtual bool ReadToFollowing(string name)
        {
            if (name == null || name.Length == 0)
            {
                throw XmlConvert.CreateInvalidNameArgumentException(name, "name");
            }
            name = NameTable.Add(name);
            while (Read())
            {
                if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name))
                {
                    return true;
                }
            }
            return false;
        }

        [global::__DynamicallyInvokable]
        public virtual bool ReadToFollowing(string localName, string namespaceURI)
        {
            if (localName == null || localName.Length == 0)
            {
                throw XmlConvert.CreateInvalidNameArgumentException(localName, "localName");
            }
            if (namespaceURI == null)
            {
                throw new ArgumentNullException("namespaceURI");
            }
            localName = NameTable.Add(localName);
            namespaceURI = NameTable.Add(namespaceURI);
            while (Read())
            {
                if (NodeType == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI))
                {
                    return true;
                }
            }
            return false;
        }

        [global::__DynamicallyInvokable]
        public virtual bool ReadToDescendant(string name)
        {
            if (name == null || name.Length == 0)
            {
                throw XmlConvert.CreateInvalidNameArgumentException(name, "name");
            }
            int num = Depth;
            if (NodeType != XmlNodeType.Element)
            {
                if (ReadState != 0)
                {
                    return false;
                }
                num--;
            }
            else if (IsEmptyElement)
            {
                return false;
            }
            name = NameTable.Add(name);
            while (Read() && Depth > num)
            {
                if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name))
                {
                    return true;
                }
            }
            return false;
        }

        [global::__DynamicallyInvokable]
        public virtual bool ReadToDescendant(string localName, string namespaceURI)
        {
            if (localName == null || localName.Length == 0)
            {
                throw XmlConvert.CreateInvalidNameArgumentException(localName, "localName");
            }
            if (namespaceURI == null)
            {
                throw new ArgumentNullException("namespaceURI");
            }
            int num = Depth;
            if (NodeType != XmlNodeType.Element)
            {
                if (ReadState != 0)
                {
                    return false;
                }
                num--;
            }
            else if (IsEmptyElement)
            {
                return false;
            }
            localName = NameTable.Add(localName);
            namespaceURI = NameTable.Add(namespaceURI);
            while (Read() && Depth > num)
            {
                if (NodeType == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI))
                {
                    return true;
                }
            }
            return false;
        }

        [global::__DynamicallyInvokable]
        public virtual bool ReadToNextSibling(string name)
        {
            if (name == null || name.Length == 0)
            {
                throw XmlConvert.CreateInvalidNameArgumentException(name, "name");
            }
            name = NameTable.Add(name);
            while (SkipSubtree())
            {
                XmlNodeType nodeType = NodeType;
                if (nodeType == XmlNodeType.Element && Ref.Equal(name, Name))
                {
                    return true;
                }
                if (nodeType == XmlNodeType.EndElement || EOF)
                {
                    break;
                }
            }
            return false;
        }

        [global::__DynamicallyInvokable]
        public virtual bool ReadToNextSibling(string localName, string namespaceURI)
        {
            if (localName == null || localName.Length == 0)
            {
                throw XmlConvert.CreateInvalidNameArgumentException(localName, "localName");
            }
            if (namespaceURI == null)
            {
                throw new ArgumentNullException("namespaceURI");
            }
            localName = NameTable.Add(localName);
            namespaceURI = NameTable.Add(namespaceURI);
            while (SkipSubtree())
            {
                XmlNodeType nodeType = NodeType;
                if (nodeType == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI))
                {
                    return true;
                }
                if (nodeType == XmlNodeType.EndElement || EOF)
                {
                    break;
                }
            }
            return false;
        }

        [global::__DynamicallyInvokable]
        public static bool IsName(string str)
        {
            if (str == null)
            {
                throw new NullReferenceException();
            }
            return ValidateNames.IsNameNoNamespaces(str);
        }

        [global::__DynamicallyInvokable]
        public static bool IsNameToken(string str)
        {
            if (str == null)
            {
                throw new NullReferenceException();
            }
            return ValidateNames.IsNmtokenNoNamespaces(str);
        }

        [global::__DynamicallyInvokable]
        public virtual string ReadInnerXml()
        {
            if (ReadState != ReadState.Interactive)
            {
                return string.Empty;
            }
            if (NodeType != XmlNodeType.Attribute && NodeType != XmlNodeType.Element)
            {
                Read();
                return string.Empty;
            }
            StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
            XmlWriter xmlWriter = CreateWriterForInnerOuterXml(stringWriter);
            try
            {
                if (NodeType == XmlNodeType.Attribute)
                {
                    ((XmlTextWriter)xmlWriter).QuoteChar = QuoteChar;
                    WriteAttributeValue(xmlWriter);
                }
                if (NodeType == XmlNodeType.Element)
                {
                    WriteNode(xmlWriter, defattr: false);
                }
            }
            finally
            {
                xmlWriter.Close();
            }
            return stringWriter.ToString();
        }

        private void WriteNode(XmlWriter xtw, bool defattr)
        {
            int num = (NodeType == XmlNodeType.None) ? (-1) : Depth;
            while (Read() && num < Depth)
            {
                switch (NodeType)
                {
                case XmlNodeType.Element:
                    xtw.WriteStartElement(Prefix, LocalName, NamespaceURI);
                    ((XmlTextWriter)xtw).QuoteChar = QuoteChar;
                    xtw.WriteAttributes(this, defattr);
                    if (IsEmptyElement)
                    {
                        xtw.WriteEndElement();
                    }
                    break;
                case XmlNodeType.Text:
                    xtw.WriteString(Value);
                    break;
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    xtw.WriteWhitespace(Value);
                    break;
                case XmlNodeType.CDATA:
                    xtw.WriteCData(Value);
                    break;
                case XmlNodeType.EntityReference:
                    xtw.WriteEntityRef(Name);
                    break;
                case XmlNodeType.ProcessingInstruction:
                case XmlNodeType.XmlDeclaration:
                    xtw.WriteProcessingInstruction(Name, Value);
                    break;
                case XmlNodeType.DocumentType:
                    xtw.WriteDocType(Name, GetAttribute("PUBLIC"), GetAttribute("SYSTEM"), Value);
                    break;
                case XmlNodeType.Comment:
                    xtw.WriteComment(Value);
                    break;
                case XmlNodeType.EndElement:
                    xtw.WriteFullEndElement();
                    break;
                }
            }
            if (num == Depth && NodeType == XmlNodeType.EndElement)
            {
                Read();
            }
        }

        private void WriteAttributeValue(XmlWriter xtw)
        {
            string name = Name;
            while (ReadAttributeValue())
            {
                if (NodeType == XmlNodeType.EntityReference)
                {
                    xtw.WriteEntityRef(Name);
                }
                else
                {
                    xtw.WriteString(Value);
                }
            }
            MoveToAttribute(name);
        }

        [global::__DynamicallyInvokable]
        public virtual string ReadOuterXml()
        {
            if (ReadState != ReadState.Interactive)
            {
                return string.Empty;
            }
            if (NodeType != XmlNodeType.Attribute && NodeType != XmlNodeType.Element)
            {
                Read();
                return string.Empty;
            }
            StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
            XmlWriter xmlWriter = CreateWriterForInnerOuterXml(stringWriter);
            try
            {
                if (NodeType == XmlNodeType.Attribute)
                {
                    xmlWriter.WriteStartAttribute(Prefix, LocalName, NamespaceURI);
                    WriteAttributeValue(xmlWriter);
                    xmlWriter.WriteEndAttribute();
                }
                else
                {
                    xmlWriter.WriteNode(this, defattr: false);
                }
            }
            finally
            {
                xmlWriter.Close();
            }
            return stringWriter.ToString();
        }

        private XmlWriter CreateWriterForInnerOuterXml(StringWriter sw)
        {
            XmlTextWriter xmlTextWriter = new XmlTextWriter(sw);
            SetNamespacesFlag(xmlTextWriter);
            return xmlTextWriter;
        }

        private void SetNamespacesFlag(XmlTextWriter xtw)
        {
            XmlTextReader xmlTextReader = this as XmlTextReader;
            if (xmlTextReader != null)
            {
                xtw.Namespaces = xmlTextReader.Namespaces;
                return;
            }
            XmlValidatingReader xmlValidatingReader = this as XmlValidatingReader;
            if (xmlValidatingReader != null)
            {
                xtw.Namespaces = xmlValidatingReader.Namespaces;
            }
        }

        [global::__DynamicallyInvokable]
        public virtual XmlReader ReadSubtree()
        {
            if (NodeType != XmlNodeType.Element)
            {
                throw new InvalidOperationException(Res.GetString("Xml_ReadSubtreeNotOnElement"));
            }
            return new XmlSubtreeReader(this);
        }

        [global::__DynamicallyInvokable]
        public void Dispose()
        {
            Dispose(disposing: true);
        }

        [global::__DynamicallyInvokable]
        protected virtual void Dispose(bool disposing)
        {
            if (disposing && ReadState != ReadState.Closed)
            {
                Close();
            }
        }

        internal static bool IsTextualNode(XmlNodeType nodeType)
        {
            return (IsTextualNodeBitmap & (1 << (int)nodeType)) != 0;
        }

        internal static bool CanReadContentAs(XmlNodeType nodeType)
        {
            return (CanReadContentAsBitmap & (1 << (int)nodeType)) != 0;
        }

        internal static bool HasValueInternal(XmlNodeType nodeType)
        {
            return (HasValueBitmap & (1 << (int)nodeType)) != 0;
        }

        private bool SkipSubtree()
        {
            MoveToElement();
            if (NodeType == XmlNodeType.Element && !IsEmptyElement)
            {
                int depth = Depth;
                while (Read() && depth < Depth)
                {
                }
                if (NodeType == XmlNodeType.EndElement)
                {
                    return Read();
                }
                return false;
            }
            return Read();
        }

        internal void CheckElement(string localName, string namespaceURI)
        {
            if (localName == null || localName.Length == 0)
            {
                throw XmlConvert.CreateInvalidNameArgumentException(localName, "localName");
            }
            if (namespaceURI == null)
            {
                throw new ArgumentNullException("namespaceURI");
            }
            if (NodeType != XmlNodeType.Element)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString(), this as IXmlLineInfo);
            }
            if (LocalName != localName || NamespaceURI != namespaceURI)
            {
                throw new XmlException("Xml_ElementNotFoundNs", new string[2]
                {
                    localName,
                    namespaceURI
                }, this as IXmlLineInfo);
            }
        }

        internal Exception CreateReadContentAsException(string methodName)
        {
            return CreateReadContentAsException(methodName, NodeType, this as IXmlLineInfo);
        }

        internal Exception CreateReadElementContentAsException(string methodName)
        {
            return CreateReadElementContentAsException(methodName, NodeType, this as IXmlLineInfo);
        }

        internal bool CanReadContentAs()
        {
            return CanReadContentAs(NodeType);
        }

        internal static Exception CreateReadContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo lineInfo)
        {
            return new InvalidOperationException(AddLineInfo(Res.GetString("Xml_InvalidReadContentAs", methodName, nodeType.ToString()), lineInfo));
        }

        internal static Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo lineInfo)
        {
            return new InvalidOperationException(AddLineInfo(Res.GetString("Xml_InvalidReadElementContentAs", methodName, nodeType.ToString()), lineInfo));
        }

        private static string AddLineInfo(string message, IXmlLineInfo lineInfo)
        {
            if (lineInfo != null)
            {
                message = message + " " + Res.GetString("Xml_ErrorPosition", lineInfo.LineNumber.ToString(CultureInfo.InvariantCulture), lineInfo.LinePosition.ToString(CultureInfo.InvariantCulture));
            }
            return message;
        }

        internal string InternalReadContentAsString()
        {
            string text = string.Empty;
            StringBuilder stringBuilder = null;
            bool num;
            do
            {
                switch (NodeType)
                {
                case XmlNodeType.Attribute:
                    return Value;
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    if (text.Length == 0)
                    {
                        text = Value;
                    }
                    else
                    {
                        if (stringBuilder == null)
                        {
                            stringBuilder = new StringBuilder();
                            stringBuilder.Append(text);
                        }
                        stringBuilder.Append(Value);
                    }
                    goto case XmlNodeType.ProcessingInstruction;
                case XmlNodeType.EntityReference:
                    if (!CanResolveEntity)
                    {
                        break;
                    }
                    ResolveEntity();
                    goto case XmlNodeType.ProcessingInstruction;
                case XmlNodeType.ProcessingInstruction:
                case XmlNodeType.Comment:
                case XmlNodeType.EndEntity:
                    num = ((AttributeCount != 0) ? ReadAttributeValue() : Read());
                    continue;
                }
                break;
            }
            while (num);
            if (stringBuilder != null)
            {
                return stringBuilder.ToString();
            }
            return text;
        }

        private bool SetupReadElementContentAsXxx(string methodName)
        {
            if (NodeType != XmlNodeType.Element)
            {
                throw CreateReadElementContentAsException(methodName);
            }
            bool isEmptyElement = IsEmptyElement;
            Read();
            if (isEmptyElement)
            {
                return false;
            }
            switch (NodeType)
            {
            case XmlNodeType.EndElement:
                Read();
                return false;
            case XmlNodeType.Element:
                throw new XmlException("Xml_MixedReadElementContentAs", string.Empty, this as IXmlLineInfo);
            default:
                return true;
            }
        }

        private void FinishReadElementContentAsXxx()
        {
            if (NodeType != XmlNodeType.EndElement)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString());
            }
            Read();
        }

        internal static Encoding GetEncoding(XmlReader reader)
        {
            return GetXmlTextReaderImpl(reader)?.Encoding;
        }

        internal static ConformanceLevel GetV1ConformanceLevel(XmlReader reader)
        {
            return GetXmlTextReaderImpl(reader)?.V1ComformanceLevel ?? ConformanceLevel.Document;
        }

        private static XmlTextReaderImpl GetXmlTextReaderImpl(XmlReader reader)
        {
            XmlTextReaderImpl xmlTextReaderImpl = reader as XmlTextReaderImpl;
            if (xmlTextReaderImpl != null)
            {
                return xmlTextReaderImpl;
            }
            XmlTextReader xmlTextReader = reader as XmlTextReader;
            if (xmlTextReader != null)
            {
                return xmlTextReader.Impl;
            }
            XmlValidatingReaderImpl xmlValidatingReaderImpl = reader as XmlValidatingReaderImpl;
            if (xmlValidatingReaderImpl != null)
            {
                return xmlValidatingReaderImpl.ReaderImpl;
            }
            return (reader as XmlValidatingReader)?.Impl.ReaderImpl;
        }

        [global::__DynamicallyInvokable]
        public static XmlReader Create(string inputUri)
        {
            return Create(inputUri, null, null);
        }

        [global::__DynamicallyInvokable]
        public static XmlReader Create(string inputUri, XmlReaderSettings settings)
        {
            return Create(inputUri, settings, null);
        }

        public static XmlReader Create(string inputUri, XmlReaderSettings settings, XmlParserContext inputContext)
        {
            if (settings == null)
            {
                settings = new XmlReaderSettings();
            }
            return settings.CreateReader(inputUri, inputContext);
        }

        [global::__DynamicallyInvokable]
        public static XmlReader Create(Stream input)
        {
            return Create(input, null, string.Empty);
        }

        [global::__DynamicallyInvokable]
        public static XmlReader Create(Stream input, XmlReaderSettings settings)
        {
            return Create(input, settings, string.Empty);
        }

        public static XmlReader Create(Stream input, XmlReaderSettings settings, string baseUri)
        {
            if (settings == null)
            {
                settings = new XmlReaderSettings();
            }
            return settings.CreateReader(input, null, baseUri, null);
        }

        [global::__DynamicallyInvokable]
        public static XmlReader Create(Stream input, XmlReaderSettings settings, XmlParserContext inputContext)
        {
            if (settings == null)
            {
                settings = new XmlReaderSettings();
            }
            return settings.CreateReader(input, null, string.Empty, inputContext);
        }

        [global::__DynamicallyInvokable]
        public static XmlReader Create(TextReader input)
        {
            return Create(input, null, string.Empty);
        }

        [global::__DynamicallyInvokable]
        public static XmlReader Create(TextReader input, XmlReaderSettings settings)
        {
            return Create(input, settings, string.Empty);
        }

        public static XmlReader Create(TextReader input, XmlReaderSettings settings, string baseUri)
        {
            if (settings == null)
            {
                settings = new XmlReaderSettings();
            }
            return settings.CreateReader(input, baseUri, null);
        }

        [global::__DynamicallyInvokable]
        public static XmlReader Create(TextReader input, XmlReaderSettings settings, XmlParserContext inputContext)
        {
            if (settings == null)
            {
                settings = new XmlReaderSettings();
            }
            return settings.CreateReader(input, string.Empty, inputContext);
        }

        [global::__DynamicallyInvokable]
        public static XmlReader Create(XmlReader reader, XmlReaderSettings settings)
        {
            if (settings == null)
            {
                settings = new XmlReaderSettings();
            }
            return settings.CreateReader(reader);
        }

        internal static XmlReader CreateSqlReader(Stream input, XmlReaderSettings settings, XmlParserContext inputContext)
        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }
            if (settings == null)
            {
                settings = new XmlReaderSettings();
            }
            byte[] array = new byte[CalcBufferSize(input)];
            int num = 0;
            int num2;
            do
            {
                num2 = input.Read(array, num, array.Length - num);
                num += num2;
            }
            while (num2 > 0 && num < 2);
            XmlReader xmlReader;
            if (num >= 2 && array[0] == 223 && array[1] == byte.MaxValue)
            {
                if (inputContext != null)
                {
                    throw new ArgumentException(Res.GetString("XmlBinary_NoParserContext"), "inputContext");
                }
                xmlReader = new XmlSqlBinaryReader(input, array, num, string.Empty, settings.CloseInput, settings);
            }
            else
            {
                xmlReader = new XmlTextReaderImpl(input, array, num, settings, null, string.Empty, inputContext, settings.CloseInput);
            }
            if (settings.ValidationType != 0)
            {
                xmlReader = settings.AddValidation(xmlReader);
            }
            if (settings.Async)
            {
                xmlReader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(xmlReader);
            }
            return xmlReader;
        }

        internal static int CalcBufferSize(Stream input)
        {
            int num = 4096;
            if (input.CanSeek)
            {
                long length = input.Length;
                if (length < num)
                {
                    num = checked((int)length);
                }
                else if (length > 65536)
                {
                    num = 8192;
                }
            }
            return num;
        }

        [global::__DynamicallyInvokable]
        public virtual Task<string> GetValueAsync()
        {
            throw new NotImplementedException();
        }

        [global::__DynamicallyInvokable]
        public virtual async Task<object> ReadContentAsObjectAsync()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsObject");
            }
            return await InternalReadContentAsStringAsync().ConfigureAwait(continueOnCapturedContext: false);
        }

        [global::__DynamicallyInvokable]
        public virtual Task<string> ReadContentAsStringAsync()
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAsString");
            }
            return InternalReadContentAsStringAsync();
        }

        [global::__DynamicallyInvokable]
        public virtual async Task<object> ReadContentAsAsync(Type returnType, IXmlNamespaceResolver namespaceResolver)
        {
            if (!CanReadContentAs())
            {
                throw CreateReadContentAsException("ReadContentAs");
            }
            string text = await InternalReadContentAsStringAsync().ConfigureAwait(continueOnCapturedContext: false);
            if (returnType == typeof(string))
            {
                return text;
            }
            try
            {
                return XmlUntypedConverter.Untyped.ChangeType(text, returnType, (namespaceResolver == null) ? (this as IXmlNamespaceResolver) : namespaceResolver);
            }
            catch (FormatException innerException)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", returnType.ToString(), innerException, this as IXmlLineInfo);
            }
            catch (InvalidCastException innerException2)
            {
                throw new XmlException("Xml_ReadContentAsFormatException", returnType.ToString(), innerException2, this as IXmlLineInfo);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual async Task<object> ReadElementContentAsObjectAsync()
        {
            if (await SetupReadElementContentAsXxxAsync("ReadElementContentAsObject").ConfigureAwait(continueOnCapturedContext: false))
            {
                object value = await ReadContentAsObjectAsync().ConfigureAwait(continueOnCapturedContext: false);
                await FinishReadElementContentAsXxxAsync().ConfigureAwait(continueOnCapturedContext: false);
                return value;
            }
            return string.Empty;
        }

        [global::__DynamicallyInvokable]
        public virtual async Task<string> ReadElementContentAsStringAsync()
        {
            if (await SetupReadElementContentAsXxxAsync("ReadElementContentAsString").ConfigureAwait(continueOnCapturedContext: false))
            {
                string value = await ReadContentAsStringAsync().ConfigureAwait(continueOnCapturedContext: false);
                await FinishReadElementContentAsXxxAsync().ConfigureAwait(continueOnCapturedContext: false);
                return value;
            }
            return string.Empty;
        }

        [global::__DynamicallyInvokable]
        public virtual async Task<object> ReadElementContentAsAsync(Type returnType, IXmlNamespaceResolver namespaceResolver)
        {
            if (await SetupReadElementContentAsXxxAsync("ReadElementContentAs").ConfigureAwait(continueOnCapturedContext: false))
            {
                object value = await ReadContentAsAsync(returnType, namespaceResolver).ConfigureAwait(continueOnCapturedContext: false);
                await FinishReadElementContentAsXxxAsync().ConfigureAwait(continueOnCapturedContext: false);
                return value;
            }
            return (returnType == typeof(string)) ? string.Empty : XmlUntypedConverter.Untyped.ChangeType(string.Empty, returnType, namespaceResolver);
        }

        [global::__DynamicallyInvokable]
        public virtual Task<bool> ReadAsync()
        {
            throw new NotImplementedException();
        }

        [global::__DynamicallyInvokable]
        public virtual Task SkipAsync()
        {
            if (ReadState != ReadState.Interactive)
            {
                return AsyncHelper.DoneTask;
            }
            return SkipSubtreeAsync();
        }

        [global::__DynamicallyInvokable]
        public virtual Task<int> ReadContentAsBase64Async(byte[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadBinaryContentNotSupported", "ReadContentAsBase64"));
        }

        [global::__DynamicallyInvokable]
        public virtual Task<int> ReadElementContentAsBase64Async(byte[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadBinaryContentNotSupported", "ReadElementContentAsBase64"));
        }

        [global::__DynamicallyInvokable]
        public virtual Task<int> ReadContentAsBinHexAsync(byte[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadBinaryContentNotSupported", "ReadContentAsBinHex"));
        }

        [global::__DynamicallyInvokable]
        public virtual Task<int> ReadElementContentAsBinHexAsync(byte[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadBinaryContentNotSupported", "ReadElementContentAsBinHex"));
        }

        [global::__DynamicallyInvokable]
        public virtual Task<int> ReadValueChunkAsync(char[] buffer, int index, int count)
        {
            throw new NotSupportedException(Res.GetString("Xml_ReadValueChunkNotSupported"));
        }

        [global::__DynamicallyInvokable]
        public virtual async Task<XmlNodeType> MoveToContentAsync()
        {
            do
            {
                switch (NodeType)
                {
                case XmlNodeType.Attribute:
                    MoveToElement();
                    break;
                case XmlNodeType.Element:
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                case XmlNodeType.EntityReference:
                case XmlNodeType.EndElement:
                case XmlNodeType.EndEntity:
                    break;
                default:
                    continue;
                }
                return NodeType;
            }
            while (await ReadAsync().ConfigureAwait(continueOnCapturedContext: false));
            return NodeType;
        }

        [global::__DynamicallyInvokable]
        public virtual async Task<string> ReadInnerXmlAsync()
        {
            if (ReadState != ReadState.Interactive)
            {
                return string.Empty;
            }
            if (NodeType != XmlNodeType.Attribute && NodeType != XmlNodeType.Element)
            {
                await ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
                return string.Empty;
            }
            StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
            XmlWriter xtw = CreateWriterForInnerOuterXml(sw);
            try
            {
                if (NodeType == XmlNodeType.Attribute)
                {
                    ((XmlTextWriter)xtw).QuoteChar = QuoteChar;
                    WriteAttributeValue(xtw);
                }
                if (NodeType == XmlNodeType.Element)
                {
                    await WriteNodeAsync(xtw, defattr: false).ConfigureAwait(continueOnCapturedContext: false);
                }
            }
            finally
            {
                xtw.Close();
            }
            return sw.ToString();
        }

        private async Task WriteNodeAsync(XmlWriter xtw, bool defattr)
        {
            int d = (NodeType == XmlNodeType.None) ? (-1) : Depth;
            while (await ReadAsync().ConfigureAwait(continueOnCapturedContext: false) && d < Depth)
            {
                switch (NodeType)
                {
                case XmlNodeType.Element:
                    xtw.WriteStartElement(Prefix, LocalName, NamespaceURI);
                    ((XmlTextWriter)xtw).QuoteChar = QuoteChar;
                    xtw.WriteAttributes(this, defattr);
                    if (IsEmptyElement)
                    {
                        xtw.WriteEndElement();
                    }
                    break;
                case XmlNodeType.Text:
                    xtw.WriteString(await GetValueAsync().ConfigureAwait(continueOnCapturedContext: false));
                    break;
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    xtw.WriteWhitespace(await GetValueAsync().ConfigureAwait(continueOnCapturedContext: false));
                    break;
                case XmlNodeType.CDATA:
                    xtw.WriteCData(Value);
                    break;
                case XmlNodeType.EntityReference:
                    xtw.WriteEntityRef(Name);
                    break;
                case XmlNodeType.ProcessingInstruction:
                case XmlNodeType.XmlDeclaration:
                    xtw.WriteProcessingInstruction(Name, Value);
                    break;
                case XmlNodeType.DocumentType:
                    xtw.WriteDocType(Name, GetAttribute("PUBLIC"), GetAttribute("SYSTEM"), Value);
                    break;
                case XmlNodeType.Comment:
                    xtw.WriteComment(Value);
                    break;
                case XmlNodeType.EndElement:
                    xtw.WriteFullEndElement();
                    break;
                }
            }
            if (d == Depth && NodeType == XmlNodeType.EndElement)
            {
                await ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
            }
        }

        [global::__DynamicallyInvokable]
        public virtual async Task<string> ReadOuterXmlAsync()
        {
            if (ReadState != ReadState.Interactive)
            {
                return string.Empty;
            }
            if (NodeType != XmlNodeType.Attribute && NodeType != XmlNodeType.Element)
            {
                await ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
                return string.Empty;
            }
            StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
            XmlWriter xmlWriter = CreateWriterForInnerOuterXml(stringWriter);
            try
            {
                if (NodeType == XmlNodeType.Attribute)
                {
                    xmlWriter.WriteStartAttribute(Prefix, LocalName, NamespaceURI);
                    WriteAttributeValue(xmlWriter);
                    xmlWriter.WriteEndAttribute();
                }
                else
                {
                    xmlWriter.WriteNode(this, defattr: false);
                }
            }
            finally
            {
                xmlWriter.Close();
            }
            return stringWriter.ToString();
        }

        private async Task<bool> SkipSubtreeAsync()
        {
            MoveToElement();
            if (NodeType == XmlNodeType.Element && !IsEmptyElement)
            {
                int depth = Depth;
                while (await ReadAsync().ConfigureAwait(continueOnCapturedContext: false) && depth < Depth)
                {
                }
                if (NodeType == XmlNodeType.EndElement)
                {
                    return await ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
                }
                return false;
            }
            return await ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
        }

        internal async Task<string> InternalReadContentAsStringAsync()
        {
            string value = string.Empty;
            StringBuilder sb = null;
            bool flag;
            do
            {
                switch (NodeType)
                {
                case XmlNodeType.Attribute:
                    return Value;
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    if (value.Length == 0)
                    {
                        value = await GetValueAsync().ConfigureAwait(continueOnCapturedContext: false);
                    }
                    else
                    {
                        if (sb == null)
                        {
                            sb = new StringBuilder();
                            sb.Append(value);
                        }
                        StringBuilder stringBuilder = sb;
                        stringBuilder.Append(await GetValueAsync().ConfigureAwait(continueOnCapturedContext: false));
                    }
                    goto case XmlNodeType.ProcessingInstruction;
                case XmlNodeType.EntityReference:
                    if (!CanResolveEntity)
                    {
                        break;
                    }
                    ResolveEntity();
                    goto case XmlNodeType.ProcessingInstruction;
                case XmlNodeType.ProcessingInstruction:
                case XmlNodeType.Comment:
                case XmlNodeType.EndEntity:
                    flag = ((AttributeCount == 0) ? (await ReadAsync().ConfigureAwait(continueOnCapturedContext: false)) : ReadAttributeValue());
                    continue;
                }
                break;
            }
            while (flag);
            return (sb == null) ? value : sb.ToString();
        }

        private async Task<bool> SetupReadElementContentAsXxxAsync(string methodName)
        {
            if (NodeType != XmlNodeType.Element)
            {
                throw CreateReadElementContentAsException(methodName);
            }
            bool isEmptyElement = IsEmptyElement;
            await ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
            if (isEmptyElement)
            {
                return false;
            }
            switch (NodeType)
            {
            case XmlNodeType.EndElement:
                await ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
                return false;
            case XmlNodeType.Element:
                throw new XmlException("Xml_MixedReadElementContentAs", string.Empty, this as IXmlLineInfo);
            default:
                return true;
            }
        }

        private Task FinishReadElementContentAsXxxAsync()
        {
            if (NodeType != XmlNodeType.EndElement)
            {
                throw new XmlException("Xml_InvalidNodeType", NodeType.ToString());
            }
            return ReadAsync();
        }

        [global::__DynamicallyInvokable]
        protected XmlReader()
        {
        }
    }
}