MoveToNextAttribute() public method

public MoveToNextAttribute ( ) : bool
return bool
示例#1
0
		[Test] // bug #550379
		public void MoveToNextAttributeFromValue ()
		{
			document.LoadXml ("<ul test='xxx'></ul>");
			XmlNodeReader nr = new XmlNodeReader (document);
			nr.Read ();
			//nr.Read (); // why twice?
			Assert.IsTrue (nr.MoveToFirstAttribute (), "#1");
			Assert.IsTrue (nr.ReadAttributeValue (), "#2");
			Assert.IsFalse (nr.MoveToNextAttribute (), "#3");
		}
 /// <summary>
 /// This removes namespaces from an XML Element (Scott)
 /// </summary>
 /// <param name="xeElement"></param>
 /// <returns></returns>
 protected string RemoveNamespaces(XmlNode xeElement)
 {
     StringWriter swOutput = new System.IO.StringWriter();
     XmlTextWriter xtwWriter = new XmlTextWriter(swOutput);
     //xtwWriter.WriteStartDocument();
     XmlNodeReader xnrReader = new XmlNodeReader(xeElement);
     while (xnrReader.Read())
     {
         switch (xnrReader.NodeType)
         {
             case XmlNodeType.Element:
                 xtwWriter.WriteStartElement(xnrReader.Name);
                 if (xnrReader.HasAttributes)
                 {
                     while (xnrReader.MoveToNextAttribute())
                     {
                         if (xnrReader.Name != "xmlns")
                         {
                             xtwWriter.WriteAttributeString(xnrReader.Name, xnrReader.Value);
                         }
                     }
                     xnrReader.MoveToElement();
                 }
                 if (xnrReader.IsEmptyElement)
                 {
                     xtwWriter.WriteEndElement();
                 }
                 break;
             case XmlNodeType.Text:
                 xtwWriter.WriteString(xnrReader.Value);
                 break;
             case XmlNodeType.CDATA:
                 xtwWriter.WriteCData(xnrReader.Value);
                 break;
             case XmlNodeType.ProcessingInstruction:
                 xtwWriter.WriteProcessingInstruction(xnrReader.Name, xnrReader.Value);
                 break;
             case XmlNodeType.Comment:
                 xtwWriter.WriteComment(xnrReader.Value);
                 break;
             case XmlNodeType.EntityReference:
                 xtwWriter.WriteEntityRef(xnrReader.Name);
                 break;
             case XmlNodeType.EndElement:
                 xtwWriter.WriteEndElement();
                 break;
         }
     }
     //xtwWriter.WriteEndDocument();
     xtwWriter.Flush();
     xtwWriter.Close();
     xnrReader.Close();
     string sOutput = swOutput.ToString();
     return sOutput;
 }
        private abstract_Element process_element( XmlNodeReader nodeReader, int current_page_count )
        {
            string type = String.Empty;
            string subtype = String.Empty;

            // Step through all the attributes until the type is found
            nodeReader.MoveToFirstAttribute();
            do
            {
                // Get the type attribute
                if ( nodeReader.Name.ToUpper().Trim() == "TYPE" )
                {
                    type = nodeReader.Value;
                }

                // Get the subtype attribute
                if ( nodeReader.Name.ToUpper().Trim() == "SUBTYPE" )
                {
                    subtype = nodeReader.Value;
                }

            } while (nodeReader.MoveToNextAttribute() );

            // Make sure a type was specified
            if ( type == String.Empty )
                return null;

            // Build the element
            abstract_Element newElement = Element_Factory.getElement( type, subtype );

            // If thie element was null, return null
            if (newElement == null)
                return null;

            // Set the page number for post back reasons
            newElement.Template_Page = current_page_count;

            // Some special logic here
            if ((newElement.Type == Element_Type.Type) && ( newElement.Display_SubType == "form" ))
            {
                (( Type_Format_Form_Element )newElement).Set_Postback("javascript:__doPostBack('newpagebutton" + current_page_count + "','')");
            }

            if ((newElement.Type == Element_Type.Title) && (newElement.Display_SubType == "form"))
            {
                complexMainTitleExists = true;
            }

            if ((newElement.Type == Element_Type.Note) && (newElement.Display_SubType == "complex"))
            {
                ((Note_Complex_Element)newElement).Include_Statement_Responsibility = !complexMainTitleExists;
            }

            // Now, step through all the attributes again
            nodeReader.MoveToFirstAttribute();
            do
            {

                    switch( nodeReader.Name.ToUpper().Trim() )
                    {
                        case "REPEATABLE":
                            bool repeatable;
                            if ( Boolean.TryParse( nodeReader.Value, out repeatable ))
                                newElement.Repeatable = repeatable;
                            break;
                        case "MANDATORY":
                            bool mandatory;
                            if (Boolean.TryParse(nodeReader.Value, out mandatory))
                                newElement.Mandatory = mandatory;
                            break;
                        case "READONLY":
                            bool isReadOnly;
                            if (Boolean.TryParse(nodeReader.Value, out isReadOnly))
                                newElement.Read_Only = isReadOnly;
                            break;
                        case "ACRONYM":
                            newElement.Acronym = nodeReader.Value;
                            break;
                    }
            } while (nodeReader.MoveToNextAttribute() );

            // Move back to the element, if there were attributes (should be)
            nodeReader.MoveToElement();

            // Is there element_data?
            if ( !nodeReader.IsEmptyElement )
            {
                nodeReader.Read();
                if (( nodeReader.NodeType == XmlNodeType.Element ) && ( nodeReader.Name.ToLower() == "element_data" ))
                {
                    // Create the new tree
                    StringWriter sw = new StringWriter();
                    XmlTextWriter tw = new XmlTextWriter( sw );
                    tw.WriteNode( nodeReader, true );
                    tw.Close();

                    // Let the element process this inner data
                    newElement.Read_XML( new XmlTextReader( new StringReader( sw.ToString() )));
                }
            }

            // Return this built element
            return newElement;
        }