C# XmlReader.Read方法代码示例

        public void StartParsing(XmlReader reader, string targetNamespace) {
            this.reader = reader;
            positionInfo = PositionInfo.GetPositionInfo(reader);
            namespaceManager = reader.NamespaceManager;
            if (namespaceManager == null) {
                namespaceManager = new XmlNamespaceManager(nameTable);
                isProcessNamespaces = true;
            } 
            else {
                isProcessNamespaces = false;
            }
            while (reader.NodeType != XmlNodeType.Element && reader.Read()) {}

            markupDepth = int.MaxValue;
            schemaXmlDepth = reader.Depth;
            SchemaType rootType = schemaNames.SchemaTypeFromRoot(reader.LocalName, reader.NamespaceURI);
            
            string code;
            if (!CheckSchemaRoot(rootType, out code)) {
                throw new XmlSchemaException(code, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition);
            }
            
            if (schemaType == SchemaType.XSD) {
                schema = new XmlSchema();
                schema.BaseUri = new Uri(reader.BaseURI, UriKind.RelativeOrAbsolute);
                builder = new XsdBuilder(reader, namespaceManager, schema, nameTable, schemaNames, eventHandler);
            }
            else {  
                Debug.Assert(schemaType == SchemaType.XDR);
                xdrSchema = new SchemaInfo();
                xdrSchema.SchemaType = SchemaType.XDR;
                builder = new XdrBuilder(reader, namespaceManager, xdrSchema, targetNamespace, nameTable, schemaNames, eventHandler);
                ((XdrBuilder)builder).XmlResolver = xmlResolver;
            }
        }

 internal XDeclaration(XmlReader r)
 {
     _version = r.GetAttribute("version");
     _encoding = r.GetAttribute("encoding");
     _standalone = r.GetAttribute("standalone");
     r.Read();
 }

        public bool CheckIgnores(XmlReader reader, bool pi, bool comm, bool ws)
        {
            if (reader == null)
                return false;

            _commentCount = 0;
            _piCount = 0;
            _wsCount = 0;

            while (reader.Read())
            {
                if (XmlNodeType.ProcessingInstruction == reader.NodeType)
                {
                    ++_piCount;
                }
                if (XmlNodeType.SignificantWhitespace == reader.NodeType)
                {
                    ++_wsCount;
                }
                if (XmlNodeType.Comment == reader.NodeType)
                {
                    ++_commentCount;
                }
            }

            if (pi && _piCount > 0)
            {
                CError.WriteLineIgnore("ProcessingInstruction Found");
                CError.WriteLineIgnore(reader.Name);
                CError.WriteLineIgnore(">" + reader.Value + "<");
                return false;
            }
            if (comm && _commentCount > 0)
            {
                CError.WriteLineIgnore("Comment Found");
                CError.WriteLineIgnore(reader.Name);
                CError.WriteLineIgnore(">" + reader.Value + "<");
                return false;
            }
            if (ws && _wsCount > 0)
            {
                CError.WriteLineIgnore("Significant Whitespace Found");
                CError.WriteLineIgnore(reader.Name);
                CError.WriteLineIgnore(">" + reader.Value + "<");
                return false;
            }
            return true;
        }

        protected void ConsumeReader(XmlReader reader)
        {
            while (reader.Read())
            {
                string x = reader.Name + reader.NodeType + reader.Value;
                if (reader.NodeType == XmlNodeType.Element)
                {
                    if (reader.HasAttributes)
                    {
                        reader.MoveToFirstAttribute();
                        int index = 0;
                        reader.MoveToAttribute(index);
                        index++;
                        while (reader.MoveToNextAttribute())
                        {
                            string name = reader.Name;
                            string value;

                            value = reader.GetAttribute(index);
                            value = reader.GetAttribute(name);
                            value = reader.GetAttribute(name, null);

                            reader.ReadAttributeValue();
                            reader.MoveToAttribute(index);
                            reader.MoveToAttribute(name, null);
                            index++;
                        }
                    }
                }
                if (reader.NodeType == XmlNodeType.EndElement)
                {
                    reader.Skip();
                }
            }
        }

 public SchemaType Parse(XmlReader reader, string targetNamespace)
 {
     StartParsing(reader, targetNamespace);
     while (ParseReaderNode() && reader.Read()) { }
     return FinishParsing();
 }

 private XmlReader NestRead(XmlReader r)
 {
     r.Read();
     r.Read();
     if (!(r.Name == "elem0" && r.NodeType == XmlNodeType.Element))
     {
         CError.WriteLine(r.Name);
         NestRead(r.ReadSubtree());
     }
     r.Dispose();
     return r;
 }

        /// <summary>
        /// Create a writer that can be used to create nodes in this document.  The root node will be assigned "baseUri", and flags
        /// can be passed to indicate that names should be atomized by the builder and/or a fragment should be created.
        /// </summary>
        internal void LoadFromReader(XmlReader reader, XmlSpace space)
        {
            XPathDocumentBuilder builder;
            IXmlLineInfo lineInfo;
            string xmlnsUri;
            bool topLevelReader;
            int initialDepth;

            if (reader == null)
                throw new ArgumentNullException(nameof(reader));

            // Determine line number provider
            lineInfo = reader as IXmlLineInfo;
            if (lineInfo == null || !lineInfo.HasLineInfo())
                lineInfo = null;
            _hasLineInfo = (lineInfo != null);

            _nameTable = reader.NameTable;
            builder = new XPathDocumentBuilder(this, lineInfo, reader.BaseURI, LoadFlags.None);

            try
            {
                // Determine whether reader is in initial state
                topLevelReader = (reader.ReadState == ReadState.Initial);
                initialDepth = reader.Depth;

                // Get atomized xmlns uri
                Debug.Assert((object)_nameTable.Get(string.Empty) == (object)string.Empty, "NameTable must contain atomized string.Empty");
                xmlnsUri = _nameTable.Get(XmlReservedNs.NsXmlNs);

                // Read past Initial state; if there are no more events then load is complete
                if (topLevelReader && !reader.Read())
                    return;

                // Read all events
                do
                {
                    // If reader began in intermediate state, return when all siblings have been read
                    if (!topLevelReader && reader.Depth < initialDepth)
                        return;

                    switch (reader.NodeType)
                    {
                        case XmlNodeType.Element:
                            {
                                bool isEmptyElement = reader.IsEmptyElement;

                                builder.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.BaseURI);

                                // Add attribute and namespace nodes to element
                                while (reader.MoveToNextAttribute())
                                {
                                    string namespaceUri = reader.NamespaceURI;

                                    if ((object)namespaceUri == (object)xmlnsUri)
                                    {
                                        if (reader.Prefix.Length == 0)
                                        {
                                            // Default namespace declaration "xmlns"
                                            Debug.Assert(reader.LocalName == "xmlns");
                                            builder.WriteNamespaceDeclaration(string.Empty, reader.Value);
                                        }
                                        else
                                        {
                                            Debug.Assert(reader.Prefix == "xmlns");
                                            builder.WriteNamespaceDeclaration(reader.LocalName, reader.Value);
                                        }
                                    }
                                    else
                                    {
                                        builder.WriteStartAttribute(reader.Prefix, reader.LocalName, namespaceUri);
                                        builder.WriteString(reader.Value, TextBlockType.Text);
                                        builder.WriteEndAttribute();
                                    }
                                }

                                if (isEmptyElement)
                                    builder.WriteEndElement(true);
                                break;
                            }

                        case XmlNodeType.EndElement:
                            builder.WriteEndElement(false);
                            break;

                        case XmlNodeType.Text:
                        case XmlNodeType.CDATA:
                            builder.WriteString(reader.Value, TextBlockType.Text);
                            break;

                        case XmlNodeType.SignificantWhitespace:
                            if (reader.XmlSpace == XmlSpace.Preserve)
                                builder.WriteString(reader.Value, TextBlockType.SignificantWhitespace);
                            else
                                // Significant whitespace without xml:space="preserve" is not significant in XPath/XQuery data model
                                goto case XmlNodeType.Whitespace;
//.........这里部分代码省略.........

        internal static void BuildSubtree(XmlReader reader, XmlWriter writer)
        {
            // important (perf) string literal...
            string xmlnsUri = XmlConst.ReservedNsXmlNs; // http://www.w3.org/2000/xmlns/
            ReadState readState = reader.ReadState;

            if (readState != ReadState.Initial
                && readState != ReadState.Interactive)
            {
                throw new ArgumentException(SR.Xml_InvalidOperation, "reader");
            }
            int level = 0;
            if (readState == ReadState.Initial)
            {
                if (!reader.Read())
                    return;
                level++; // if start in initial, read everything (not just first)
            }
            do
            {
                switch (reader.NodeType)
                {
                    case XmlNodeType.Element:
                        writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                        bool isEmptyElement = reader.IsEmptyElement;

                        while (reader.MoveToNextAttribute())
                        {
                            if ((object)reader.NamespaceURI == (object)xmlnsUri)
                            {
                                if (reader.Prefix.Length == 0)
                                {
                                    // Default namespace declaration "xmlns"
                                    Debug.Assert(reader.LocalName == "xmlns");
                                    writer.WriteAttributeString("", "xmlns", xmlnsUri, reader.Value);
                                }
                                else
                                {
                                    Debug.Assert(reader.Prefix == "xmlns");
                                    writer.WriteAttributeString("xmlns", reader.LocalName, xmlnsUri, reader.Value);
                                }
                            }
                            else
                            {
                                writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                                writer.WriteString(reader.Value);
                                writer.WriteEndAttribute();
                            }
                        }

                        reader.MoveToElement();
                        if (isEmptyElement)
                        {
                            // there might still be a value, if there is a default value specified in the schema
                            writer.WriteEndElement();
                        }
                        else
                        {
                            level++;
                        }
                        break;
                    case XmlNodeType.EndElement:
                        writer.WriteFullEndElement();
                        //should not read beyond the level of the reader's original position.
                        level--;
                        break;
                    case XmlNodeType.Text:
                    case XmlNodeType.CDATA:
                        writer.WriteString(reader.Value);
                        break;
                    case XmlNodeType.SignificantWhitespace:
                    case XmlNodeType.Whitespace:
                        writer.WriteString(reader.Value);
                        break;
                    case XmlNodeType.Comment:
                        writer.WriteComment(reader.Value);
                        break;
                    case XmlNodeType.ProcessingInstruction:
                        writer.WriteProcessingInstruction(reader.LocalName, reader.Value);
                        break;
                    case XmlNodeType.EntityReference:
                        reader.ResolveEntity();
                        break;
                    case XmlNodeType.EndEntity:
                    case XmlNodeType.None:
                    case XmlNodeType.DocumentType:
                    case XmlNodeType.XmlDeclaration:
                        break;
                    case XmlNodeType.Attribute:
                        if ((object)reader.NamespaceURI == (object)xmlnsUri)
                        {
                            if (reader.Prefix.Length == 0)
                            {
                                // Default namespace declaration "xmlns"
                                Debug.Assert(reader.LocalName == "xmlns");
                                writer.WriteAttributeString("", "xmlns", xmlnsUri, reader.Value);
                            }
                            else
                            {
                                Debug.Assert(reader.Prefix == "xmlns");
//.........这里部分代码省略.........

 private void ReadElementFrom(XmlReader r, LoadOptions o)
 {
     if (r.ReadState != ReadState.Interactive) throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
     name = XNamespace.Get(r.NamespaceURI).GetName(r.LocalName);
     if ((o & LoadOptions.SetBaseUri) != 0)
     {
         string baseUri = r.BaseURI;
         if (!string.IsNullOrEmpty(baseUri))
         {
             SetBaseUri(baseUri);
         }
     }
     IXmlLineInfo li = null;
     if ((o & LoadOptions.SetLineInfo) != 0)
     {
         li = r as IXmlLineInfo;
         if (li != null && li.HasLineInfo())
         {
             SetLineInfo(li.LineNumber, li.LinePosition);
         }
     }
     if (r.MoveToFirstAttribute())
     {
         do
         {
             XAttribute a = new XAttribute(XNamespace.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value);
             if (li != null && li.HasLineInfo())
             {
                 a.SetLineInfo(li.LineNumber, li.LinePosition);
             }
             AppendAttributeSkipNotify(a);
         } while (r.MoveToNextAttribute());
         r.MoveToElement();
     }
     if (!r.IsEmptyElement)
     {
         r.Read();
         ReadContentFrom(r, o);
     }
     r.Read();
 }

	    private void ReadChildNodes( XPathContainer parent, string parentBaseUri, XmlReader reader, PositionInfo positionInfo ) {
		    do {
		        documentIndex++;
			    switch( reader.NodeType ) {
				case XmlNodeType.Element: {
                    string baseUri = reader.BaseURI;
                    XPathElement e = null;
                    if( reader.IsEmptyElement ) {
                        e = new XPathEmptyElement( reader.Prefix, reader.LocalName, reader.NamespaceURI, positionInfo.LineNumber, positionInfo.LinePosition, parent.topNamespace, documentIndex );
    					ReadAttributes( e, reader );
                    }
                    else {
                        e = new XPathElement( reader.Prefix, reader.LocalName, reader.NamespaceURI, positionInfo.LineNumber, positionInfo.LinePosition, parent.topNamespace, documentIndex );
    					ReadAttributes( e, reader );
    					reader.Read();
	    				ReadChildNodes( e, baseUri, reader, positionInfo );
                    }
                    if (parentBaseUri != baseUri) {
                        // We can't user Ref.Equial Because Reader fails to fully atomize base Uri.
                        if (elementBaseUriMap == null) {
                            elementBaseUriMap = new Hashtable();
                        }
                        elementBaseUriMap[e] = baseUri;
                    }
                    parent.AppendChild( e );
                    break;
				}	

				case XmlNodeType.Comment:
                    parent.AppendChild( new XPathComment( reader.Value, documentIndex ) );
                    break;

				case XmlNodeType.ProcessingInstruction:
                    parent.AppendChild( new XPathProcessingInstruction( reader.LocalName, reader.Value, documentIndex ) );
                    break;

				case XmlNodeType.SignificantWhitespace:
                    if( reader.XmlSpace == XmlSpace.Preserve ) {
                        parent.AppendSignificantWhitespace( reader.Value, positionInfo.LineNumber, positionInfo.LinePosition, documentIndex );
                    }
                    else {
                        // SWS without xml:space='preserve' is not really significant for XPath.
                        // so we treat it as just WS
                        goto case XmlNodeType.Whitespace;
                    }
                    break;

				case XmlNodeType.Whitespace:
                    if( space == XmlSpace.Preserve ) {
                        parent.AppendWhitespace( reader.Value, positionInfo.LineNumber, positionInfo.LinePosition, documentIndex );
                    }
                    break;

				case XmlNodeType.CDATA:
				case XmlNodeType.Text:
                    parent.AppendText( reader.Value, positionInfo.LineNumber, positionInfo.LinePosition, documentIndex );
                    break;

                case XmlNodeType.EntityReference:
                    reader.ResolveEntity();
                    reader.Read();
                    ReadChildNodes( parent, parentBaseUri, reader, positionInfo);
                    break;

                case XmlNodeType.EndEntity:
				case XmlNodeType.EndElement:
                case XmlNodeType.None:
					return;

                case XmlNodeType.DocumentType:
                    XmlValidatingReader vr = reader as XmlValidatingReader;
                    if ( vr != null ) {
                        SchemaInfo info = vr.GetSchemaInfo();
                        if ( info != null ) {
                            GetIDInfo( info);
                        }
                    }
                    break;
                case XmlNodeType.XmlDeclaration:
                default:
                    break;
			    }
		    }while( reader.Read() );
	    }

	    private void Load( XmlReader reader ) {
            nt = reader.NameTable;
            baseURI = reader.BaseURI;
            Debug.Assert(baseURI != null, "uri can't be null, isn't it?");
            xmlnsUri = (nt != null ? nt.Add(XmlReservedNs.NsXmlNs) : XmlReservedNs.NsXmlNs);
	        PositionInfo positionInfo = PositionInfo.GetPositionInfo(reader);
            if ( reader.ReadState == ReadState.Initial ) {
                if ( !reader.Read() )
                    return;
            }
		    ReadChildNodes( root, baseURI, reader, positionInfo );
	    }

        private static object DeserializeArray(XmlReader xmlReader)
        {
            string startingElementName = xmlReader.Name;
            xmlReader.Read();
            string arrayType = xmlReader.Name;

            ArrayList array = new ArrayList();
            Type returnType = null;

            while (xmlReader.Name != startingElementName)
            {
                string tempValue = xmlReader.ReadElementString();

                switch (arrayType)
                {
                    case "boolean":
                        returnType = returnType ?? typeof(bool);
                        array.Add(tempValue == "true");
                        break;

                    // TODO: this is not an array but a base64 encoded string
                    //case "byte":
                    //    //returnType = returnType ?? typeof(bool);
                    //    //return Convert.FromBase64String(tempValue);
                    //    //throw new Exception("Should never reach this");
                    //    break;

                    case "byte":
                        returnType = returnType ?? typeof(sbyte);
                        array.Add(Convert.ToSByte(tempValue));
                        break;

                    case "char":
                        returnType = returnType ?? typeof(char);
                        array.Add(Convert.ToChar(Convert.ToByte(tempValue)));
                        break;

                    case "dateTime":
                        returnType = returnType ?? typeof(DateTime);
                        array.Add(GetDateTimeFromString(tempValue));
                        break;

                    case "double":
                        returnType = returnType ?? typeof(double);
                        array.Add(Convert.ToDouble(tempValue));
                        break;

                    case "guid":
                        returnType = returnType ?? typeof(Guid);
                        array.Add(GetGuidFromString(tempValue));
                        break;

                    case "short":
                        returnType = returnType ?? typeof(short);
                        array.Add(Convert.ToInt16(tempValue));
                        break;
                    case "unsignedShort":
                        returnType = returnType ?? typeof(ushort);
                        array.Add(Convert.ToUInt16(tempValue));
                        break;

                    case "int":
                        returnType = returnType ?? typeof(int);
                        array.Add(Convert.ToInt32(tempValue));
                        break;
                    case "unsignedInt":
                        returnType = returnType ?? typeof(uint);
                        array.Add(Convert.ToUInt32(tempValue));
                        break;

                    case "long":
                        returnType = returnType ?? typeof(long);
                        array.Add(Convert.ToInt64(tempValue));
                        break;
                    case "unsignedLong":
                        returnType = returnType ?? typeof(ulong);
                        array.Add(Convert.ToUInt64(tempValue));
                        break;

                    case "float":
                        returnType = returnType ?? typeof(float);
                        array.Add((Single)Convert.ToDouble(tempValue));
                        break;

                    case "string":
                        returnType = returnType ?? typeof(string);
                        array.Add(tempValue);
                        break;

                    default:
                        returnType = returnType ?? typeof(object);
                        break;
                }
            }

            return array.ToArray(returnType);
        }