.NET provides a rich set of
classes for XML manipulation in several namespaces that start with
System.Xml. One of the most confusing aspects of using XML with .NET is
deciding which combination of classes you should use. Many of them
provide similar functionality in a slightly different way, optimized for
specific scenarios or for compatibility with specific standards.
The majority of the examples you'll explore use the
types in the core System.Xml namespace. The classes here allow you to
read and write XML files, manipulate XML data in memory, and even
validate XML documents.
In this article, you'll look at the following options for dealing with XML data:
Reading and writing XML directly, just like
you read and write text files using XmlTextWriter and XmlTextReader. For
sheer speed and efficiency, this is the best approach.
Dealing
with XML as a collection of in-memory objects using the XDocument
class. If you need more flexibility than the XmlTextWriter and
XmlTextReader provide or you just want a simpler, more straightforward
model (and you don't need to squeeze out every last drop of
performance), this is a good choice.
Using
the Xml control to transform XML content to displayable HTML. In the
right situation—when all you want to do is display XML content using a
prebuilt XSLT style sheet—this approach offers a useful shortcut.
NOTE
When it comes to XML, Microsoft is a bit
schizophrenic. The .NET Framework includes at least a dozen ways to read
and manipulate XML. In the following sections, you'll spend most
of your time exploring the two most practical ways to work with XML.
First, you'll learn to use the basic XmlTextWriter and XmlTextReader
classes, which guarantee good performance. Second, you'll explore the
XDocument class, which can simplify intricate XML processing.
1. The XML TextWriter
One of the simplest ways to create or read any XML
document is to use the basic XmlTextWriter and XmlTextReader classes.
These classes work like their StreamWriter and StreamReader relatives,
except that they write and read XML documents instead of ordinary text
files. First, you create or open the file. Then, you
write to it or read from it, moving from top to bottom. Finally, you
close it and get to work using the retrieved data in whatever way you'd
like.
Before beginning this example, you'll need to import the namespaces for file handling and XML processing:
Imports System.IO
Imports System.Xml
Here's an example that creates a simple version of the SuperProProductList document:
' Place the file in the App_Data subfolder of the current website.
' The System.IO.Path class makes it easy to build the full file name.
Dim file As String = Path.Combine(Request.PhysicalApplicationPath, _
"App_Data\SuperProProductList.xml")
Dim fs As New FileStream(file, FileMode.Create)
Dim w As New XmlTextWriter(fs, Nothing)
w.WriteStartDocument()
w.WriteStartElement("SuperProProductList")
w.WriteComment("This file generated by the XmlTextWriter class.")
' Write the first product.
w.WriteStartElement("Product")
w.WriteAttributeString("ID", "", "1")
w.WriteAttributeString("Name", "", "Chair")
w.WriteStartElement("Price")
w.WriteString("49.33")
w.WriteEndElement()
w.WriteEndElement()
' Write the second product.
w.WriteStartElement("Product")
w.WriteAttributeString("ID", "2")
w.WriteAttributeString("Name", "Car")
w.WriteStartElement("Price")
w.WriteString("43399.55")
w.WriteEndElement()
w.WriteEndElement()
' Write the third product.
w.WriteStartElement("Product")
w.WriteAttributeString("ID", "3")
w.WriteAttributeString("Name", "Fresh Fruit Basket")
w.WriteStartElement("Price")
w.WriteString("49.99")
w.WriteEndElement()
w.WriteEndElement()
' Close the root element.
w.WriteEndElement()
w.WriteEndDocument()
w.Close()
1.1. Dissecting the Code . . .
You create the entire XML document by calling
the methods of the XmlTextWriter, in the right order. To start a
document, you always begin by calling WriteStartDocument(). To end it,
you call WriteEndDocument().
The
next step is writing the elements you need. You write elements in three
steps. First, you write the start tag (like <Product>) by calling
WriteStartElement(). Then you write attributes, elements, and text
content inside. Finally, you write the end tag (like </Product>)
by calling WriteEndElement().
The methods
you use always work with the current element. So if you call
WriteStartElement() and follow it up with a call to
WriteAttributeString(), you are adding an attribute to that
element. Similarly, if you use WriteString(), you insert text content
inside the current element, and if you use WriteStartElement() again,
you write another element, nested inside the current element.
In some ways, this code is similar to the code you
used to write a basic text file. It does have a few advantages, however.
You can close elements quickly and accurately, the angle brackets (<
>) are included for you automatically, and some errors (such as
closing the root element too soon) are caught automatically, thereby
ensuring a well-formed XML document as the final result.
To check that your code worked, open the file in
Internet Explorer, which automatically provides a collapsible view for
XML documents (see Figure 1).
By default, the XmlTextWriter will create an XML file
that has all its elements lumped together in a single line without any
helpful carriage returns or indentation. You don't see this limitation
in Figure 18-1,
because Internet Explorer uses a style sheet to give the XML a more
readable (and more colorful) appearance. However, if you open the XML
document in Notepad, you'll see the difference.
Although additional formatting isn't required (and
doesn't change how the data will be processed), it can make a
significant difference if you want to read your XML files in Visual
Studio, Notepad, or another text editor. Fortunately, the XmlTextWriter
supports formatting; you just need to enable it, as follows:
' Set it to indent output.
w.Formatting = Formatting.Indented
' Set the number of indent spaces.
w.Indentation = 5
