C# XmlTextReader.ReadAttributeValue方法代码示例

 internal int AppendAttributeValue(XmlTextReader reader)
 {
     int num = 0;
     char quoteChar = reader.QuoteChar;
     if ((quoteChar != '"') && (quoteChar != '\''))
     {
         quoteChar = '"';
     }
     num += this.Write(quoteChar);
     while (reader.ReadAttributeValue())
     {
         if (reader.NodeType == XmlNodeType.Text)
         {
             num += this.AppendEscapeXmlString(reader.Value, true, quoteChar);
         }
         else
         {
             num += this.AppendEntityRef(reader.Name);
         }
     }
     return (num + this.Write(quoteChar));
 }

        internal int AppendAttributeValue(XmlTextReader reader)
        {
            int charactersWritten = 0;
            char quote = reader.QuoteChar;

            // In !DOCTYPE, quote is '\0' for second public attribute. 
            // Protect ourselves from writing invalid XML by always
            // supplying a valid quote char.
            if ((quote != '"') && (quote != '\'')) quote = '"';

            charactersWritten += Write(quote);
            while (reader.ReadAttributeValue())
                if (reader.NodeType == XmlNodeType.Text)
                    charactersWritten += AppendEscapeXmlString(reader.Value, true, quote);
                else charactersWritten += AppendEntityRef(reader.Name);

            charactersWritten += Write(quote);
            return charactersWritten;
        }

		public void PreserveEntity ()
		{
			string intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";
			string dtd = "<!DOCTYPE root [" + intSubset + "]>";
			string xml = dtd + "<root foo='&ent;' bar='internal &ent; value' />";
			XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
			dvr.EntityHandling = EntityHandling.ExpandCharEntities;
			dvr.Read ();	// DTD
			dvr.Read ();
			AssertEquals (XmlNodeType.Element, dvr.NodeType);
			AssertEquals ("root", dvr.Name);
			Assert (dvr.MoveToFirstAttribute ());
			AssertEquals ("foo", dvr.Name);
			// MS BUG: it returns "entity string", however, entity should not be exanded.
			AssertEquals ("&ent;", dvr.Value);
			//  ReadAttributeValue()
			Assert (dvr.ReadAttributeValue ());
			AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
			AssertEquals ("ent", dvr.Name);
			AssertEquals ("", dvr.Value);
			Assert (!dvr.ReadAttributeValue ());

			// bar
			Assert (dvr.MoveToNextAttribute ());
			AssertEquals ("bar", dvr.Name);
			AssertEquals ("internal &ent; value", dvr.Value);
			//  ReadAttributeValue()
			Assert (dvr.ReadAttributeValue ());
			AssertEquals (XmlNodeType.Text, dvr.NodeType);
			AssertEquals ("", dvr.Name);
			AssertEquals ("internal ", dvr.Value);
			Assert (dvr.ReadAttributeValue ());
			AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
			AssertEquals ("ent", dvr.Name);
			AssertEquals ("", dvr.Value);
			Assert (dvr.ReadAttributeValue ());
			AssertEquals (XmlNodeType.Text, dvr.NodeType);
			AssertEquals ("", dvr.Name);
			AssertEquals (" value", dvr.Value);

		}

		public void AttributeWithEntityReference ()
		{
			string xml = @"<a value='hello &ent; world' />";
			XmlReader xmlReader =
				new XmlTextReader (new StringReader (xml));
			xmlReader.Read ();
			xmlReader.MoveToFirstAttribute ();
			xmlReader.ReadAttributeValue ();
			AssertEquals ("hello ", xmlReader.Value);
			Assert (xmlReader.ReadAttributeValue ());
			AssertEquals (XmlNodeType.EntityReference, xmlReader.NodeType);
			AssertEquals ("ent", xmlReader.Name);
			AssertEquals (XmlNodeType.EntityReference, xmlReader.NodeType);
			Assert (xmlReader.ReadAttributeValue ());
			AssertEquals (" world", xmlReader.Value);
			AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
			Assert (!xmlReader.ReadAttributeValue ());
			AssertEquals (" world", xmlReader.Value); // remains
			AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
			xmlReader.ReadAttributeValue ();
			AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
		}

		public void XmlDeclarationReadAttributeValue2 ()
		{
			const string input = "<?xml version=\"1.0\" encoding=\"utf-8\"?><hello />";
			var reader = new XmlTextReader (new StringReader (input));
			reader.WhitespaceHandling = WhitespaceHandling.All;
			reader.Read ();
			Assert.IsTrue (reader.MoveToNextAttribute (), "#1a");
			Assert.IsTrue (reader.ReadAttributeValue (), "#1b");
			Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#1c");
			Assert.AreEqual ("1.0", reader.Value, "#1d");
			Assert.IsFalse (reader.ReadAttributeValue(), "#1e");

			Assert.IsTrue (reader.MoveToNextAttribute(), "#2a");
			Assert.IsTrue (reader.ReadAttributeValue(), "#2b");
			Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#2c");
			Assert.AreEqual ("utf-8", reader.Value, "#2d");
			Assert.IsFalse (reader.ReadAttributeValue(), "#2e");

			Assert.IsFalse (reader.MoveToNextAttribute(), "#3");
			Assert.IsFalse (reader.ReadAttributeValue(), "#4");
			Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#5");
		}

		public void XmlDeclarationReadAttributeValue ()
		{
			const string input = "<?xml version=\"1.0\" encoding=\"utf-8\"?><hello />";
			var reader = new XmlTextReader (new StringReader (input));
			reader.WhitespaceHandling = WhitespaceHandling.All;
			reader.Read ();
			
			Assert.AreEqual ("1.0", reader.GetAttribute ("version"), "#0");
			Assert.AreEqual ("utf-8", reader.GetAttribute ("encoding"), "#0-2");

			Assert.IsTrue (reader.MoveToNextAttribute (), "#1");
			Assert.AreEqual ("1.0", reader.Value, "#1-1");
			Assert.IsTrue (reader.ReadAttributeValue (), "#2");
			Assert.AreEqual ("1.0", reader.Value, "#3");
			Assert.IsFalse (reader.ReadAttributeValue (), "#4");

			Assert.IsTrue (reader.MoveToNextAttribute (), "#5");
			Assert.AreEqual ("utf-8", reader.Value, "#5-1");
			Assert.IsTrue (reader.ReadAttributeValue (), "#6");
			Assert.AreEqual ("utf-8", reader.Value, "#7");
			Assert.IsFalse (reader.ReadAttributeValue (), "#8");

			Assert.IsFalse (reader.MoveToNextAttribute (), "#9");
			Assert.IsFalse (reader.ReadAttributeValue (), "#10");
		}

		public override void Read (XmlTextReader xml, bool start)
		{
			if (CanSerialize) {
				base.Read (xml, start);

				if (start) {
					while (xml.MoveToNextAttribute()) {
						string name = xml.Name;

						xml.ReadAttributeValue();
						Attributes [name] = xml.Value;

						OnAttributeRead (name);
						Logger.Debug (
						        "NoteTag: {0} read attribute {1}='{2}'",
						        ElementName,
						        name,
						        xml.Value);
					}
				}
			}
		}

        protected void Recurse(XmlTextReader reader, Menu root)
        {
            String inner = reader.ReadInnerXml();

              NameTable nt = new NameTable();
              XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
              XmlParserContext ctxt = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
              XmlTextReader reader2 = new XmlTextReader(inner, XmlNodeType.Element, ctxt);

              while (reader2.Read())
              {
            if (reader2.NodeType == XmlNodeType.Element)
            {
              switch (reader2.LocalName)
              {
            case "menu":
              // Menuitem. Find the name, accesskey, command and id strings
              String[] values = new String[3] {"", "", ""};
              String[] names = new String[3] {"label", "accesskey", "command"};
              for (int i = 0; i < names.Length; ++i)
              {
                if (reader2.MoveToAttribute(names[i]) &&
                  reader2.ReadAttributeValue())
                  values[i] = reader2.Value; // XXX need to handle entities
                reader2.MoveToElement();
              }

              // Handle Accesskey
              values[0] = ManticoreMenuItem.GenerateAccessKeyString(values[0], values[1]);

              // Create menu item and attach an event handler
              // BLUESKY - should we support data stored in the XML file as an attribute?
              mCurrentMenuItem = new ManticoreMenuItem(values[0],
                                                       new EventHandler(OnCommandInternal),
                                                       values[2], "");
              if (values[2] != "")
                mItems.Add(values[2], mCurrentMenuItem);
              root.MenuItems.Add(mCurrentMenuItem);
              Recurse(reader2, mCurrentMenuItem);
              break;
            case "menuseparator":
              mCurrentMenuItem = new MenuItem("-");
              root.MenuItems.Add(mCurrentMenuItem);
              break;
            case "menubuilder":
              String id = "";
              if (reader2.MoveToAttribute("id") &&
                  reader2.ReadAttributeValue())
                id = reader2.Value;
              reader2.MoveToElement();
              String datastore = "";
              if (reader2.MoveToAttribute("datastore") &&
                  reader2.ReadAttributeValue())
                datastore = reader2.Value;

              BaseMenuBuilder builder = new BaseMenuBuilder(mMainMenu, root as MenuItem, mCurrentMenuItem, null);
              builder.Root = id;
              builder.DataStore = DataStoreRegistry.GetDataStore(datastore);
              builder.DataStore.AddObserver(builder);
              builder.OnCommand += new EventHandler(OnCommandInternal);
              mBuilders.Add(builder.GetHashCode(), builder);
              break;
              }
            }
              }
        }

 /// <summary>
 /// Fill the list with source
 /// </summary>
 /// <param name="XmlSourceFile"></param>
 public void FillList(string XmlSourceFile)
 {
     XmlTextReader XmlReader=new XmlTextReader(XmlSourceFile);
     while (XmlReader.Read())
     {
         if(XmlReader.HasAttributes & XmlReader.NodeType==System.Xml.XmlNodeType.Element)
         {
             if(XmlReader[0].ToUpper() != "ISO")
             {
                 this._SourceList.Add(XmlReader[1]);
             }
         }
         XmlReader.ReadAttributeValue();
     }
 }

        public void Build(Object sender, EventArgs e)
        {
            XmlTextReader reader;
              reader = new XmlTextReader(mToolbarFile);
              reader.WhitespaceHandling = WhitespaceHandling.None;
              reader.MoveToContent();

              bool shouldBuildNewRow = true;

              while (reader.Read())
              {
            if (reader.NodeType == XmlNodeType.Element)
            {
              switch (reader.LocalName)
              {
            case "toolstrip":
              // The next <toolbar/> we encounter should be created on a new row.
              shouldBuildNewRow = true;
              break;
            case "toolbar":
              String[] tbvalues = new String[4] {"", "", "",  ""};
              String[] tbnames = new String[4] {"id", "label", "description", "visible"};
              for (int i = 0; i < tbnames.Length; ++i)
              {
                if (reader.MoveToAttribute(tbnames[i]) &&
                  reader.ReadAttributeValue())
                  tbvalues[i] = reader.Value; // XXX need to handle entities
                reader.MoveToElement();
              }

              String key = tbvalues[0];
              String label = tbvalues[1];
              bool visible = tbvalues[3] == "true";

              // Create and add a new toolbar.
              mToolBar.Appearance = ToolBarAppearance.Flat;
              mToolBar.ButtonClick += new ToolBarButtonClickEventHandler(this.OnCommand);
              mForm.Controls.Add(mToolBar);

              //mCoolBar.Bands.Add(-1, key, label, new Object(), true, mToolBar, true);

              shouldBuildNewRow = false;
              break;
            case "toolbarseparator":
            {
              if (mToolBar != null)
              {
                ToolBarButton button = new ToolBarButton();
                button.Style = ToolBarButtonStyle.Separator;
                mToolBar.Buttons.Add(button);
              }
              break;
            }
            case "toolbarbutton":
            {
              if (mToolBar != null)
              {
                String[] tbbvalues = new String[3] {"", "", ""};
                String[] tbbnames = new String[3] {"label", "icon", "command"};
                for (int i = 0; i < tbbnames.Length; ++i)
                {
                  if (reader.MoveToAttribute(tbbnames[i]) &&
                    reader.ReadAttributeValue())
                    tbbvalues[i] = reader.Value; // XXX need to handle entities
                  reader.MoveToElement();
                }

                ToolBarButton button = new CommandButtonItem(tbbvalues[1]);
                button.Text = tbbvalues[0];
                mToolBar.Buttons.Add(button);
              }
              break;
            }
              }
            }
              }
        }

        private void CatListRecurse(XmlTextReader aReader, Object aRootNode)
        {
            String inner = aReader.ReadInnerXml();

              NameTable nt = new NameTable();
              XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
              XmlParserContext ctxt = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
              XmlTextReader reader2 = new XmlTextReader(inner, XmlNodeType.Element, ctxt);

              TreeNode node;

              while (reader2.Read()) {
            if (reader2.NodeType == XmlNodeType.Element) {
              switch (reader2.LocalName) {
              case "panel":
            // Tree node with children. Retrieve label and id. Label is
            // used for visual presentation, id is hashed against node
            // and is used as a key when looking for which panel to
            // load.
            String[] values = new String[2] {"", ""};
            String[] names = new String[2] {"label", "id"};
            for (int i = 0; i < names.Length; ++i) {
              if (reader2.MoveToAttribute(names[i]) &&
                reader2.ReadAttributeValue())
                values[i] = reader2.Value;
              reader2.MoveToElement();
            }

            node = new TreeNode(values[0], 0, 0);
            if (aRootNode is TreeView) {
              TreeView rootView = aRootNode as TreeView;
              rootView.Nodes.Add(node);
            }
            else if (aRootNode is TreeNode) {
              TreeNode rootNode = aRootNode as TreeNode;
              rootNode.Nodes.Add(node);
            }

            mNodes.Add(node.GetHashCode(), values[1]);
            CatListRecurse(reader2, node);
            break;
              }
            }
              }
        }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="r"></param>
		/// <param name="t"></param>
		/// <returns></returns>
		public object DeserializeGraph(XmlTextReader r, Type t) 
		{
			object o = t.Assembly.CreateInstance(t.FullName);
			string InstanceName = r.Name;
			int i = 0;

			if(o.GetType().BaseType == typeof(System.Collections.CollectionBase))
			{
				o = DeserializeCollection(r, t);
			}

			PropertyInfo[] properties = o.GetType().GetProperties(BindingFlags.Public|BindingFlags.Instance);
			
			#region Handle XmlRoot attributes
			if(r.HasAttributes) 
			{
				while(r.MoveToNextAttribute() && i < properties.Length) 
				{
					object[] butes = properties[i].GetCustomAttributes(false);
					object bute = null;
					if(butes.Length > 0)
						bute = butes[0];

					PropertyInfo property = null;

					if(r.Name == (bute as XmlAttributeAttribute).AttributeName) 
					{
						property = properties[i];
					}
					else 
					{
						property = t.GetProperty(r.Name);
					}

					if(property.PropertyType.Name == "String") 
					{
						// We have a string
						r.ReadAttributeValue();
						string s = r.Value;
						if(property.CanWrite)
							property.SetValue(o, s, null);
					}
					i++;
				}
			}
			#endregion

			while(r.Read() && i < properties.Length) 
			{
				if((r.Name == InstanceName) && (r.NodeType == XmlNodeType.EndElement)) 
				{
					break;
				}

				object[] attribs = properties[i].GetCustomAttributes(false);
				object attrib = null;

				if(attribs.Length > 0)
					attrib = attribs[0];		
	
				if(r.HasAttributes) 
				{
					r.MoveToFirstAttribute();
					while(r.HasAttributes) 
					{
						PropertyInfo property = null;

						if(r.Name == (attrib as XmlAttributeAttribute).AttributeName) 
						{
							property = properties[i];
						}
						else 
						{
							property = t.GetProperty(r.Name);
						}

						if(property.PropertyType.Name == "String") 
						{
							// We have a string
							r.ReadAttributeValue();
							string s = r.Value;
							if(property.CanWrite)
								property.SetValue(o, s, null);
						}
						i++;
					}
				}
				else if((r.NodeType == XmlNodeType.Element)) 
				{
					
					if(r.IsEmptyElement) 
					{
						i++;
						continue;
//.........这里部分代码省略.........