Professional ASP.NET 1.1 [Electronic resources] نسخه متنی

Creating and Editing XML Documents

We've discussed how to read and write XML documents, access them in a range of ways, and validate the content against a schema or DTD. Let's now look at Creating and Editing the Content of XML Documents (edit-xml.aspx).

The example page loads an XML document named bookdetails.xml and demonstrates four different techniques you can use for editing and creating documents:

• 
  

  Selecting a node, extracting the content, and deleting that node from the document.



• 
  

  Creating a new empty document and adding a declaration and comment to it.



• 
  

  Importing (that is, copying) a node from the original document into the new document.



• 
  

  Selecting, editing, and inserting new nodes and content into the original document.

Figure 11-20 shows the page when you run it. You can see the four stages of the process, though the second and third are combined into one section of the output in the page:

Figure 11-20:

The Code for This Example Page

The page contains the customary <div> elements to display the results and messages, and details of any errors encountered. It also creates the paths to the existing and new documents, and displays a hyperlink to the existing document. This is identical to the previous example, and so we aren't repeating the code here. Instead, here's the part that loads the existing document into a new XmlDocument object:

Dim objXMLDoc As New XmlDocument()
Try
objXMLDoc.Load(strXMLPath)
Catch objError As Exception
outError.innerHTML = "Error while accessing document.<br />" _
& objError.Message & "<br />" & objError.Source
Exit Sub ' and stop execution
End Try

Selecting, Displaying, and Deleting a Node

To select a specific node in the document, you can use an XPath expression. In our example, the expression is descendant::Book[ISBN="0764544020"], which – when the current node is the root element of the document – selects the <Book> node with the specified value for its <ISBN> child node. This expression is used in the SelectSingleNode method, and it returns a reference to the node you want. To display this node and its content, you just have to reference its OuterXml property.

To delete the node from the document, you can call the RemoveChild method of the parent node (the root of the document, which is returned by the DocumentElement property of the document object), and pass it a reference to the node to be deleted.

'specify XPath expression to select a book element
Dim strXPath As String = "descendant::Book[ISBN=" & Chr(34) _
& "0764544020" & Chr(34) & "]"
 
'get a reference to the matching <Book> node
Dim objNode As XmlNode
objNode = objXMLDoc.SelectSingleNode(strXPath)
 
'display node and content using the OuterXml property
outResult1.InnerHtml = "XPath expression '<b>" & strXPath _
& "</b>' returned:<br />" _
& Server.HtmlEncode(objNode.OuterXml) & "<br />"
 
'delete this node using RemoveChild method from document element
objXMLDoc.DocumentElement.RemoveChild(objNode)
outResult1.InnerHtml &= "Removed node from document.<br />"

Creating a New Document and Adding Nodes

We create a new empty XML document, simply by instantiating an XmlDocument (or XmlDataDocument) object. Nodes can then be created and inserted into this document. In the code that follows, we're creating a new XML declaration (the <?xml version="1.0"?> element) and inserting it into the new document with the InsertBefore method:

'create new empty XmlDocument object
Dim objNewDoc As New XmlDocument()
 
'create a new XmlDeclaration object
Dim objDeclare As XmlDeclaration
objDeclare = objNewDoc.CreateXmlDeclaration("1.0", Nothing, Nothing)
 
'and add it as the first node in the new document
objDeclare = objNewDoc.InsertBefore(objDeclare, objNewDoc.DocumentElement)

When the new node is created, a reference to this new node is returned from the CreateXmlDeclaration method. This reference is used as the first parameter to the InsertBefore method. The second parameter is a reference to the node that we want to insert before, and in this case we specify the root of the document.

Notice that DocumentElement is not the root element of the document, as it doesn't yet have one. This sounds confusing, but you can think of it as a reference to the placeholder where the root element will reside.

Next we create a new Comment element, and insert this into the new document after the XML declaration element:

'create a new XmlComment object
Dim objComment As XmlComment
objComment = objNewDoc.CreateComment("New document created " & Now())
 
'and add it as the second node in the new document
objComment = objNewDoc.InsertAfter(objComment, objDeclare)

Importing Nodes into the New Document

To get some content into the newly created document, our example page imports a node from the existing document loaded from disk at the start of the page. We again use an XPath expression with the SelectSingleNode method to get a reference to the <Book> element that is to be imported.

We then create a new XmlNode object in the target document to hold the imported node, and call the Import method of this new node to copy the node from the original document. The second parameter to the Import method specifies whether we want a deep copy – in other words, if we want to import all the content of the node as well as the value.

Once you've got the new node into the document, you have to insert it into the tree – it is only an unattached fragment at the moment. As before, you can use the InsertAfter method, using the reference you've already got to the new node, and the reference created earlier to the Comment node so that the imported node becomes the root element of the new document.

We finish this section by displaying the contents of the new document. We've got a reference to the XmlDocument object that contains it, so we just query the OuterXml property to get the complete content. You can see the new document displayed in the example page.

strXPath = "descendant::Book[ISBN=" & Chr(34) & "0764543709" & Chr(34) & "]"
objNode = objXMLDoc.SelectSingleNode(strXPath)
 
'create a variable to hold the imported node object
Dim objImportedNode As XmlNode
 
'import node and all children into new document as unattached fragment
objImportedNode = objNewDoc.ImportNode(objNode, True)
 
'insert new unattached node into document after the comment node
objNewDoc.InsertAfter(objImportedNode, objComment)
 
'display the contents of the new document
outResult2.InnerHtml = "Created new XML document and inserted " _
& "into it the node selected by<br />" _
& "the XPath expression '" & strXPath & "'" _
& "Content of new document is:<br />" _
& Server.HtmlEncode(objNewDoc.OuterXml)

Inserting and Updating Nodes in a Document

The final part of the example page edits some values in the original document. This time, an XPath expression that will match more than one node is necessary, and so we use the SelectNodes method of the document to return an XmlNodeList object containing references to all the matching nodes (in our example, all the <ISBN> nodes). We can then display the number of matches found.

The plan is to add an attribute to all of the <ISBN> elements, and replace the text content (value) of these elements with two new elements that contain the information in a different form. After declaring some variables that are needed, we can iterate through the collection of <ISBN> nodes using a For Each construct.

strXPath = "descendant::ISBN"
 
'get a reference to the matching nodes as a collection
Dim colNodeList As XmlNodeList
colNodeList = objXMLDoc.SelectNodes(strXPath)
 
'display the number of matches found
outResult3.InnerHtml = "Found " & colNodeList.Count _
& " nodes matching the" _
& "XPath expression '" & strXPath & "'<br />" _
& "Editing and inserting new content<br />"
 
'create variables to hold an XmlAttribute and other values
Dim objAttr As XmlAttribute
Dim strNodeValue, strNewValue, strShortCode As String
 
'iterate through all the nodes found
For Each objNode In colNodeList
...

Within the loop, we first create a new attribute named formatting and set the value to hyphens (all the <ISBN> nodes will have the same value for this attribute). You can add this attribute to the <ISBN> element node by calling the SetAttribute method. However, there is a minor hitch – the members of an XmlNodeList are XmlNode objects, which don't have a SetAttribute method. In Visual Basic, you can get around this by casting the object to an XmlElement object using the CType (convert type) function.

To change the content of the <ISBN> elements, you only have to set the InnerXml property. This is much easier than using the InsertBefore and InsertAfter methods demonstrated earlier, and provides a valid alternative when the content you want to insert is available as a string (recall that you had references to the element node and its new content node when you used InsertBefore).

Our code extracts the existing ISBN value, creates the new short code from it, formats the existing ISBN with hyphens, and then creates a string containing the new content for the element. The final step is to insert these values into the <ISBN> node by setting its InnerXml property, before going round to do the next one. You can then end the page by writing the complete edited XML document to a disk file and displaying a hyperlink to it so that it can be viewed.

...
'create an XmlAttribute named 'formatting'
objAttr = objXMLDoc.CreateAttribute("formatting")
 
'set the value of the XmlAttribute to 'hyphens'
objAttr.Value = "hyphens"
 
'and add it to this ISBN element – have to cast the object
'to an XmlElement as XmlNode doesn't have this method
CType(objNode, XmlElement).SetAttributeNode(objAttr)
 
'get text value of this ISBN element
strNodeValue = objNode.InnerText
 
'create short and long strings to replace content
strShortCode = Right(strNodeValue, 4)
strNewValue = Left(strNodeValue, 1) & "-" _
& Mid(strNodeValue, 2, 6) & "-" _
& Mid(strNodeValue, 8, 2) & "-" _
& Right(strNodeValue, 1)
 
'insert into element by setting the InnerXml property
objNode.InnerXml = "<LongCode>" & strNewValue _
& "</LongCode><ShortCode>" _
& strShortCode & "</ShortCode>"
Next
'write the updated document to a disk file
objXMLDoc.Save(strNewPath)
'display a link to view the updated document
outResult3.InnerHTML &= "Saved updated document: <a href="" _
& strNewPath & "">" & strNewPath & "</a>"

Viewing the Results

If you open both documents – the original and the edited version (Figures 11-21, 11-22) – you can see the effects of our editing process. The first contains the <Book> node with the <ISBN> value 0764544020, which is not present in the second. You can also see the updated <ISBN> elements in the second document:

Figure 11-21:

Figure 11-22:

In this example, we've demonstrated several techniques for working with an XML document using the System.Xml classes provided in .NET. Some of the techniques use the XML DOM methods as defined by W3C, and some are specific extensions available with the XmlDocument (and other) objects. In general, these extensions make common tasks a lot easier – for example, the ability to access the InnerText, InnerXml, and OuterXml of a node makes it remarkably easy to edit or insert content and markup.

We haven't covered all the possibilities for accessing XML documents, as you'll see if you examine the list of properties, methods, and events for each of the relevant objects in the SDK. However, by now, you should have a flavor for what is possible, and how easy it is to achieve.