Thus far, you have seen attributes applied to a specific portion of an XML document. Visual Basic has its own flavor of attributes, as do C# and each of the other .NET languages. These attributes refer to annotations to the source code that specify information, or metadata, that can be used by other applications without the need for the original source code. We will call such attributes Source Code Style attributes.

In the context of the System.Xml.Serialization namespace, Source Code Style attributes can be used to change the names of the elements generated for the data members of a class or to generate XML attributes instead of XML elements for the data members of a class. To demonstrate this, we will use a class called ElokuvaTilaus, which contains data members named name, filmId, and quantity. It just so happens that the default XML generated when serializing this class is not in a form that can be readily consumed by an external application.

For example, assume that a Finnish development team has written this external application — hence, the XML element and attribute names are in Finnish (minus the umlauts), rather than English. To rename the XML generated for a data member, name, a Source Code Style attribute will be used. This Source Code Style attribute specifies that when ElokuvaTilaus is serialized, the name data member is represented as an XML element, <Nimi>. The actual Source Code Style attribute that specifies this is as follows:

<XmlElementAttribute("Nimi")> Public name As String

ElokuvaTilaus, which means MovieOrder in Finnish, also contains other Source Code Style attributes:

ElokuvaTilaus is defined as follows:

Imports System.Xml.Serialization

Public Class ElokuvaTilaus

  ' These are Public because we have yet to implement
  ' properties to provide program access.

  <XmlElementAttribute("Nimi")> Public name As String
  <XmlAttributeAttribute("ElokuvaId")> Public filmId As Integer
  <XmlAttributeAttribute("Maara")> Public quantity As Integer

  Public Sub New()
  End Sub

  Public Sub New(ByVal name As String, _
                 ByVal filmId As Integer, _
                 ByVal quantity As Integer)
      Me.name = name
      Me.filmId = filmId
      Me.quantity = quantity
  End Sub

End Class

ElokuvaTilaus can be serialized as follows:

Dim serialize As XmlSerializer = _
    New XmlSerializer(GetType(ElokuvaTilaus))
Dim MyMovieOrder As ElokuvaTilaus = _
    New ElokuvaTilaus("Grease", 101, 10)

serialize.Serialize(Console.Out, MyMovieOrder)
Console.Readline()

The output generated by this code reflects the Source Code Style attributes associated with the class ElokuvaTilaus:

<?xml version="1.0" encoding="IBM437"?>
<ElokuvaTilaus xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 ElokuvaId="101" Maara="10">
    <Nimi>Grease</Nimi>
</ElokuvaTilaus>

The value of filmId is contained in an XML attribute, ElokuvaId, and the value of quantity is contained in an XML attribute, Maara. The value of name is contained in an XML element, Nimi.

The example only demonstrates the Source Code Style attributes exposed by the XmlAttributeAttribute and XmlElementAttribute classes in the System.Xml.Serialization namespace. A variety of other Source Code Style attributes exist in this namespace that also control the form of XML generated by serialization. The classes associated with such Source Code Style attributes include XmlTypeAttribute, XmlTextAttribute, XmlRootAttribute, XmlIncludeAttribute, XmlIgnoreAttribute, and XmlEnumAttribute.

An XML document can be created programmatically in .NET. One way to perform this task is by writing the individual components of an XML document (schema, attributes, elements, and so on) to an XML stream. Using a unidirectional write-stream means that each element and its attributes must be written in order — the idea is that data is always written at the head of the stream. To accomplish this, you use a writable XML stream class (a class derived from XmlWriter). Such a class ensures that the XML document you generate correctly implements the W3C Extensible Markup Language (XML) 1.0 specification and the Namespaces in XML specification.

Why is this necessary when you have XML serialization? You need to be very careful here to separate interface from implementation. XML serialization works for a specific class, such as the ElokuvaTilaus class. This class is a proprietary implementation and not the format in which data is exchanged. For this one specific case, the XML document generated when ElokuvaTilaus is serialized just so happens to be the XML format used when placing an order for some movies. ElokuvaTilaus was given a little help from Source Code Style attributes so that it would conform to a standard XML representation of a film order summary.

In a different application, if the software used to manage an entire movie distribution business wants to generate movie orders, then it must generate a document of the appropriate form. The movie distribution management software achieves this using the XmlWriter object.

Before reviewing the subtleties of XmlWriter, note that this class exposes over 40 methods and properties. The example in this section provides an overview that touches on a subset of these methods and properties. This subset enables the generation of an XML document that corresponds to a movie order.

This example builds the module that generates the XML document corresponding to a movie order. It uses an instance of XmlWriter, called FilmOrdersWriter, which is actually a file on disk. This means that the XML document generated is streamed to this file. Because the FilmOrdersWriter variable represents a file, you have to take a few actions against the file. For instance, you have to ensure the file is

Before you create the XmlWriter object, you first need to customize how the object operates by using the XmlWriterSettings object. This object, introduced in .NET 2.0, enables you to configure the behavior of the XmlWriter object before you instantiate it:

Dim myXmlSettings As New XmlWriterSettings()
myXmlSettings.Indent = True
myXmlSettings.NewLineOnAttributes = True

You can specify a few settings for the XmlWriterSettings object that define how XML creation will be handled by the XmlWriter object. The following table details the properties of the XmlWriterSettings class:

Once the XmlWriterSettings object has been instantiated and assigned the values you deem necessary, the next steps are to invoke the XmlWriter object and make the association between the XmlWriterSettings object and the XmlWriter object.

The basic infrastructure for managing the file (the XML text stream) and applying the settings class is either

Dim FilmOrdersWriter As XmlWriter = _
   XmlWriter.Create("..FilmOrdersProgrammatic.xml", myXmlSettings)

FilmOrdersWriter.Close()

or the following, if you are utilizing the Using keyword, which is the recommended approach:

Using FilmOrdersWriter As XmlWriter = _
   XmlWriter.Create("..FilmOrdersProgrammatic.xml", myXmlSettings)
End Using

With the preliminaries completed (file created and formatting configured), the process of writing the actual attributes and elements of your XML document can begin. The sequence of steps used to generate your XML document is as follows:

Let's now put all this together in the Module1.vb file shown here:

Imports System.Xml
Imports System.Xml.Serialization
Imports System.IO

Module Module1

    Sub Main()

        Dim myXmlSettings As New XmlWriterSettings
        myXmlSettings.Indent = True
        myXmlSettings.NewLineOnAttributes = True

        Using FilmOrdersWriter As XmlWriter = _
            XmlWriter.Create("..FilmOrdersProgrammatic.xml", myXmlSettings)

            FilmOrdersWriter.WriteComment(" Same as generated " & _
               "by serializing, ElokuvaTilaus ")
            FilmOrdersWriter.WriteStartElement("ElokuvaTilaus")

FilmOrdersWriter.WriteAttributeString("ElokuvaId", "101")
            FilmOrdersWriter.WriteAttributeString("Maara", "10")
            FilmOrdersWriter.WriteElementString("Nimi", "Grease")
            FilmOrdersWriter.WriteEndElement() ' End ElokuvaTilaus

        End Using

    End Sub

End Module

Once this is run, you will find the XML file FilmOrdersProgrammatic.xml created in the same folder as the Module1.vb file or in the bin directory. The content of this file is as follows:

<?xml version="1.0" encoding="utf-8"?>
<!-- Same as generated by serializing, ElokuvaTilaus -->
<ElokuvaTilaus
  ElokuvaId="101"
  Maara="10">
  <Nimi>Grease</Nimi>
</ElokuvaTilaus>

The previous XML document is the same in form as the XML document generated by serializing the ElokuvaTilaus class. Notice that in the previous XML document, the <Nimi> element is indented two characters and that each attribute is on a different line in the document. This was achieved using the XmlWriterSettings class.

The sample application covered only a small portion of the methods and properties exposed by the XML stream-writing class, XmlWriter. Other methods implemented by this class manipulate the underlying file, such as the Flush method; and some methods allow XML text to be written directly to the stream, such as the WriteRaw method.

The XmlWriter class also exposes a variety of methods that write a specific type of XML data to the stream. These methods include WriteBinHex, WriteCData, WriteString, and WriteWhiteSpace.

You can now generate the same XML document in two different ways. You have used two different applications that took two different approaches to generating a document that represents a standardized movie order. However, there are even more ways to generate XML, depending on the circumstances. Using the previous scenario, you could receive a movie order from a store, and this order would have to be transformed from the XML format used by the supplier to your own order format.

In .NET, XML documents can be read from a stream as well. Data is traversed in the stream in order (first XML element, second XML element, and so on). This traversal is very quick because the data is processed in one direction and features such as write and move backward in the traversal are not supported. At any given instance, only data at the current position in the stream can be accessed.

Before exploring how an XML stream can be read, you need to understand why it should be read in the first place. Returning to our movie supplier example, imagine that the application managing the movie orders can generate a variety of XML documents corresponding to current orders, preorders, and returns. All the documents (current orders, preorders, and returns) can be extracted in stream form and processed by a report-generating application. This application prints the orders for a given day, the preorders that are going to be due, and the returns that are coming back to the supplier. The report-generating application processes the data by reading in and parsing a stream of XML.

One class that can be used to read and parse such an XML stream is XmlReader. Other classes in the .NET Framework are derived from XmlReader, such as XmlTextReader, which can read XML from a file (specified by a string corresponding to the file's name), a Stream, or an XmlReader. This example uses an XmlReader to read an XML document contained in a file. Reading XML from a file and writing it to a file is not the norm when it comes to XML processing, but a file is the simplest way to access XML data. This simplified access enables you to focus on XML-specific issues.

In creating a sample, the first step is to make the proper imports into the Module1.vb file:

Imports System.Xml
Imports System.Xml.Serialization
Imports System.IO

From there, the next step in accessing a stream of XML data is to create an instance of the object that will open the stream (the readMovieInfo variable of type XmlReader) and then open the stream itself. Your application performs this as follows (where MovieManage.xml is the name of the file containing the XML document):

Dim myXmlSettings As New XmlReaderSettings()
Using readMovieInfo As XmlReader = XmlReader.Create(fileName, myXmlSettings)

Note that because the XmlWriter has a settings class, the XmlReader also has a settings class. Though you can make assignments to the XmlReaderSettings object, in this case you do not. Later, this chapter covers the XmlReaderSettings object.

The basic mechanism for traversing each stream is to traverse from node to node using the Read method. Node types in XML include Element and Whitespace. Numerous other node types are defined, but this example focuses on traversing XML elements and the white space that is used to make the elements more readable (carriage returns, linefeeds, and indentation spaces). Once the stream is positioned at a node, the MoveToNextAttribute method can be called to read each attribute contained in an element. The MoveToNextAttribute method only traverses attributes for nodes that contain attributes (nodes of type element). An example of an XmlReader traversing each node and then traversing the attributes of each node follows:

While readMovieInfo.Read()
      ' Process node here.
      While readMovieInfo.MoveToNextAttribute()
         ' Process attribute here.
      End While
   End While

This code, which reads the contents of the XML stream, does not utilize any knowledge of the stream's contents. However, a great many applications know exactly how the stream they are going to traverse is structured. Such applications can use XmlReader in a more deliberate manner and not simply traverse the stream without foreknowledge.

Once the example stream has been read, it can be cleaned up using the End Using call:

End Using

This ReadMovieXml subroutine takes the filename containing the XML to read as a parameter. The code for the subroutine is as follows (and is basically the code just outlined):

Private Sub ReadMovieXml(ByVal fileName As String)
   Dim myXmlSettings As New XmlReaderSettings()
   Using readMovieInfo As XmlReader = XmlReader.Create(fileName, _
      myXmlSettings)
      While readMovieInfo.Read()
         ShowXmlNode(readMovieInfo)
         While readMovieInfo.MoveToNextAttribute()
            ShowXmlNode(readMovieInfo)
         End While
      End While
   End Using
   Console.ReadLine()
End Sub

For each node encountered after a call to the Read method, ReadMovieXml calls the ShowXmlNode subroutine. Similarly, for each attribute traversed, the ShowXmlNode subroutine is called. This subroutine breaks down each node into its sub-entities:

The subroutine ShowXmlNode is implemented as follows:

Private Sub ShowXmlNode(ByVal reader As XmlReader)

If reader.Depth > 0 Then
     For depthCount As Integer = 1 To reader.Depth
        Console.Write(" ")
     Next
  End If

  If reader.NodeType = XmlNodeType.Whitespace Then

     Console.Out.WriteLine("Type: {0} ", reader.NodeType)

  ElseIf reader.NodeType = XmlNodeType.Text Then

     Console.Out.WriteLine("Type: {0}, Value: {1} ", _
                          reader.NodeType, _
                          reader.Value)

  Else

     Console.Out.WriteLine("Name: {0}, Type: {1}, " & _
                          "AttributeCount: {2}, Value: {3} ", _
                          reader.Name, _
                          reader.NodeType, _
                          reader.AttributeCount, _
                          reader.Value)
  End If

End Sub

Within the ShowXmlNode subroutine, each level of node depth adds two spaces to the output generated:

If reader.Depth > 0 Then
  For depthCount As Integer = 1 To reader.Depth
    Console.Write(" ")
  Next
End If

You add these spaces in order to create human-readable output (so you can easily determine the depth of each node displayed). For each type of node, ShowXmlNode displays the value of the NodeType property. The ShowXmlNode subroutine makes a distinction between nodes of type Whitespace and other types of nodes. The reason for this is simple: A node of type Whitespace does not contain a name or attribute count. The value of such a node is any combination of white-space characters (space, tab, carriage return, and so on). Therefore, it doesn't make sense to display the properties if the NodeType is XmlNodeType.WhiteSpace. Nodes of type Text have no name associated with them, so for this type, subroutine ShowXmlNode only displays the properties NodeType and Value. For all other node types, the Name, AttributeCount, Value, and NodeType properties are displayed.

To finalize this module, add a Sub Main as follows:

Sub Main(ByVal args() As String)
   ReadMovieXml("..MovieManage.xml")
End Sub

Here is an example construction of the MovieManage.xml file:

<?xml version="1.0" encoding="utf-8" ?>
<MovieOrderDump>

 <FilmOrder_Multiple>
    <multiFilmOrders>
       <FilmOrder>
          <name>Grease</name>
          <filmId>101</filmId>
          <quantity>10</quantity>
       </FilmOrder>
       <FilmOrder>
          <name>Lawrence of Arabia</name>
          <filmId>102</filmId>
          <quantity>10</quantity>
       </FilmOrder>
       <FilmOrder>
          <name>Star Wars</name>
          <filmId>103</filmId>
          <quantity>10</quantity>
       </FilmOrder>
    </multiFilmOrders>
 </FilmOrder_Multiple>

 <PreOrder>
    <FilmOrder>
       <name>Shrek III - Shrek Becomes a Programmer</name>
       <filmId>104</filmId>
       <quantity>10</quantity>
    </FilmOrder>
 </PreOrder>

 <Returns>
    <FilmOrder>
       <name>Star Wars</name>
       <filmId>103</filmId>
       <quantity>2</quantity>
    </FilmOrder>
 </Returns>

</MovieOrderDump>

Running this module produces the following output (a partial display, as it would be rather lengthy):

Name: xml, Type: XmlDeclaration, AttributeCount: 2, Value: version="1.0"
encoding="utf-8"
Name: version, Type: Attribute, AttributeCount: 2, Value: 1.0
Name: encoding, Type: Attribute, AttributeCount: 2, Value: utf-8
Type: Whitespace
Name: MovieOrderDump, Type: Element, AttributeCount: 0, Value:
 Type: Whitespace
 Name: FilmOrder_Multiple, Type: Element, AttributeCount: 0, Value:
  Type: Whitespace

Name: multiFilmOrders, Type: Element, AttributeCount: 0, Value:
   Type: Whitespace
   Name: FilmOrder, Type: Element, AttributeCount: 0, Value:
    Type: Whitespace
    Name: name, Type: Element, AttributeCount: 0, Value:
     Type: Text, Value: Grease

This example managed to use three methods and five properties of XmlReader. The output generated was informative but far from practical. XmlReader exposes over 50 methods and properties, which means that we have only scratched the surface of this highly versatile class. The remainder of this section looks at the XmlReaderSettings class, introduces a more realistic use of XmlReader, and demonstrates how the classes of System.Xml handle errors.

Dim myXmlSettings As New XmlReaderSettings()
myXmlSettings.IgnoreWhitespace = True
myXmlSettings.IgnoreComments = True

Using readMovieInfo As XmlReader = XmlReader.Create(fileName, myXmlSettings)
   ' Use XmlReader object here.
End Using

Read root element: <MovieOrderDump>
    Process each <FilmOrder_Multiple> element
        Read <multiFilmOrders> element
            Process each <FilmOrder>
                Send fax for each movie order here

Dim myXmlSettings As New XmlReaderSettings()

Using readMovieInfo As XmlReader = XmlReader.Create(fileName, myXmlSettings)
      readMovieInfo.Read()
      readMovieInfo.ReadStartElement("MovieOrderDump")

      Do While (True)
         '****************************************************
         '* Process FilmOrder elements here                  *

         '****************************************************
      Loop

      readMovieInfo.ReadEndElement()  '  </MovieOrderDump>

End Using

Dim myXmlSettings As New XmlReaderSettings()

Using readMovieInfo As XmlReader = XmlReader.Create(fileName, myXmlSettings)
      readMovieInfo.Read()
      readMovieInfo.ReadStartElement("MovieOrderDump")

      Do While (True)

readMovieInfo.ReadStartElement("FilmOrder_Multiple")
         readMovieInfo.ReadStartElement("multiFilmOrders")

         Do While (True)
            readMovieInfo.ReadStartElement("FilmOrder")
            movieName = readMovieInfo.ReadElementString()
            movieId = readMovieInfo.ReadElementString()
            quantity = readMovieInfo.ReadElementString()
            readMovieInfo.ReadEndElement() ' clear </FilmOrder>

            FranticallyFaxTheMovieSupplier(movieName, movieId, quantity)

            ' Should read next FilmOrder node
            ' else quits
            readMovieInfo.Read()

            If ("FilmOrder" <> readMovieInfo.Name) Then
               Exit Do
            End If
         Loop

         readMovieInfo.ReadEndElement() ' clear </multiFilmOrders>
         readMovieInfo.ReadEndElement() ' clear </FilmOrder_Multiple>

         ' Should read next FilmOrder_Multiple node
         ' else you quit
         readMovieInfo.Read() ' clear </MovieOrderDump>

         If ("FilmOrder_Multiple" <> readMovieInfo.Name) Then
            Exit Do
         End If
      Loop

      readMovieInfo.ReadEndElement()  '  </MovieOrderDump>

End Using

movieName = readMovieInfo.ReadElementString()
movieId = readMovieInfo.ReadElementString()
quantity = readMovieInfo.ReadElementString()

Dim username As String = _
   myXmlReader.ReadElementContentAs(GetType(String), DBNull.Value)
Dim myDate As DateTime = _
   myXmlReader.ReadElementContentAs(GetType(DateTime), DBNull.Value)

<?xml version="1.0" encoding="IBM437" ?>
<ElokuvaTilaus ElokuvaId="101", Maara="10">
   <Nimi>Grease</Nimi>
<ElokuvaTilaus>

Try
    ReadMovieXml("Malformed.xml")
Catch xmlEx As XmlException
    Console.Error.WriteLine("XML Error: " + xmlEx.ToString())
Catch ex As Exception
    Console.Error.WriteLine("Some other error: " + ex.ToString())
End Try

XML Error: System.Xml.XmlException: The ',' character, hexadecimal value 0x2C,
 cannot begin a name. Line 2, position 49.

XML Error: System.Xml.XmlException: This is an unexpected token. Expected
'EndElement'. Line 5, position 27.

A very useful class that can greatly help you when working with XML is System.IO.MemoryStream. Rather than need a network or disk resource backing the stream (as in System.Net.Sockets.NetworkStream and System.IO.FileStream), MemoryStream backs itself up onto a block of memory. Imagine that you want to generate an XML document and e-mail it. The built-in classes for sending e-mail rely on having a System.String containing a block of text for the message body, but if you want to generate an XML document, then you need a stream.

If the document is reasonably sized, then write the document directly to memory and copy that block of memory to the e-mail. This is good from a performance and reliability perspective because you don't have to open a file, write it, rewind it, and read the data back in again. However, you must consider scalability in this situation because if the file is very large, or if you have a great number of smaller files, then you could run out of memory (in which case you have to go the "file" route).

This section describes how to generate an XML document to a MemoryStream object, reading the document back out again as a System.String value and e-mailing it. What you will do is create a new class called EmailStream that extends MemoryStream. This new class contains an extra method called CloseAndSend that, as its name implies, closes the stream and sends the e-mail message.

First, create a new console application project called "EmailStream." The first task is to create a basic Customer object that contains a few basic members and can be automatically serialized by .NET through use of the SerializableAttribute attribute:

<Serializable()> Public Class Customer

  ' members...
  Public Id As Integer
  Public FirstName As String
  Public LastName As String
  Public Email As String

End Class

The fun part is the EmailStream class itself. This needs access to the System.Net.Mail namespace, so import this namespace into your code for your class. The new class should also extend System.IO.MemoryStream, as shown here:

Imports System.IO
Imports System.Net.Mail

Public Class EmailStream
    Inherits MemoryStream

The first job of CloseAndSend is to start putting together the mail message. This is done by creating a new System.Web.Mail.MailMessage object and configuring the sender, recipient, and subject:

' CloseAndSend - close the stream and send the email...
Public Sub CloseAndSend(ByVal fromAddress As String, _
                        ByVal toAddress As String, _
                        ByVal subject As String)

   ' Create the new message...
   Dim message As New MailMessage()

   message.From = New MailAddress(fromAddress)
   message.To.Add(New MailAddress(toAddress))
   message.Subject = subject

This method will be called after the XML document has been written to the stream, so you can assume at this point that the stream contains a block of data. To read the data back out again, you have to rewind the stream and use a System.IO.StreamReader. Before you do this, however, call Flush. Traditionally, streams have always been buffered — that is, the data is not sent to the final destination (the memory block in this case, but a file in the case of a FileStream, and so on) each time the stream is written. Instead, the data is written in (mostly) a nondeterministic way. Because you need all the data to be written, you call Flush to ensure that all the data has been sent to the destination and that the buffer is empty.

In a way, EmailStream is a great example of buffering. All the data is held in a memory "buffer" until you finally send the data on to its destination in a response to an explicit call to this method:

' Flush and rewind the stream...

Flush()
Seek(0, SeekOrigin.Begin)

Once you have flushed and rewound the stream, you can create a StreamReader and dredge all the data out into the Body property of the MailMessage object:

' Read out the data...

   Dim reader As New StreamReader(Me)
   message.Body = reader.ReadToEnd()

After you have done that, close the stream by calling the base class method:

' Close the stream...

Close()

Finally, send the message:

' Send the message...
   Dim SmtpMail As New SmtpClient()
   SmtpMail.Send(message)

End Sub

End Class

To call this method, you need to add some code to the Main method. First, create a new Customer object and populate it with some test data:

Imports System.Xml.Serialization

Module Module1

  Sub Main()

    ' Create a new customer...
    Dim customer As New Customer
    customer.Id = 27
    customer.FirstName = "Bill"
    customer.LastName = "Gates"
    customer.Email = [email protected]

After you have done that, you can create a new EmailStream object. You then use XmlSerializer to write an XML document representing the newly created Customer instance to the block of memory that EmailStream is backing to:

' Create a new email stream...
Dim stream As New EmailStream

' Serialize...
Dim serializer As New XmlSerializer(customer.GetType())
serializer.Serialize(stream, customer)

At this point, the stream will be filled with data; and after all the data has been flushed, the block of memory that EmailStream backs on to will contain the complete document. Now you can call CloseAndSend to e-mail the document:

' Send the email...
    stream.CloseAndSend("[email protected]", _
       "[email protected]", "XML Customer Document")
  End Sub

End Module

You probably already have the Microsoft SMTP service properly configured — this service is necessary to send e-mail. You also need to ensure that the e-mail addresses used in your code go to your e-mail address! Run the project and check your e-mail; you should see something similar to what is shown in Figure 10-2.

Figure 10.2. Figure 10-2

The classes of the System.Xml namespace that support the Document Object Model (DOM) interact as illustrated in Figure 10-3.

Figure 10.3. Figure 10-3

Within this diagram, an XML document is contained in a class named XmlDocument. Each node within this document is accessible and managed using XmlNode. Nodes can also be accessed and managed using a class specifically designed to process a specific node's type (XmlElement, XmlAttribute, and so on). XML documents are extracted from XmlDocument using a variety of mechanisms exposed through such classes as XmlWriter, TextWriter, Stream, and a file (specified by filename of type String). XML documents are consumed by an XmlDocument using a variety of load mechanisms exposed through the same classes.

A DOM-style parser differs from a stream-style parser with respect to movement. Using the DOM, the nodes can be traversed forward and backward. Nodes can be added to the document, removed from the document, and updated. However, this flexibility comes at a performance cost. It is faster to read or write XML using a stream-style parser.

The DOM-specific classes exposed by System.Xml include the following:

Given the diverse number of methods and properties exposed by XmlDocument, XmlNode, XmlElement, and XmlAttribute (and there are many more than those listed here), it's clear that any XML 1.0 or 1.1-compliant document can be generated and manipulated using these classes. In comparison to their XML stream counterparts, these classes offer more flexible movement within the XML document and through any editing of XML documents.

A similar comparison could be made between DOM and data serialized and deserialized using XML. Using serialization, the type of node (for example, attribute or element) and the node name are specified at compile time. There is no on-the-fly modification of the XML generated by the serialization process.

Other technologies that generate and consume XML are not as flexible as the DOM. This includes ADO.NET and ADO, which generate XML of a particular form. The default install of SQL Server 2000 does expose a certain amount of flexibility when it comes to the generation (FOR XML queries) and consumption (OPENXML) of XML. SQL Server 2005 has more support for XML and even supports an XML data type. SQL Server 2005 also expands upon the FOR XML query with FOR XML TYPE. The choice between using classes within the DOM and a version of SQL Server is a choice between using a language such as Visual Basic to manipulate objects or installing SQL Server and performing most of the XML manipulation in SQL.

Dim xmlDoc As New XmlDocument
Dim ds As New DataSet()

' Set up ADO.NET DataSet() here
xmlDoc.LoadXml(ds.GetXml())

Dim rawData As String = _
    "<multiFilmOrders>" & _
    "  <FilmOrder>" & _
    "    <name>Grease</name>" & _
    "    <filmId>101</filmId>" & _
    "    <quantity>10</quantity>" & _
    "  </FilmOrder>" & _
    "  <FilmOrder>" & _
    "    <name>Lawrence of Arabia</name>" & _
    "    <filmId>102</filmId>" & _
    "    <quantity>10</quantity>" & _
    "  </FilmOrder>" & _
    "</multiFilmOrders>"

Dim rawData As String = _
   <multiFilmOrders>
      <FilmOrder>
         <name>Grease</name>
         <filmId>101</filmId>
         <quantity>10</quantity>
      </FilmOrder>
      <FilmOrder>
         <name>Lawrence of Arabia</name>
         <filmId>102</filmId>
         <quantity>10</quantity>
      </FilmOrder>
   </multiFilmOrders>

Dim xmlDoc As New XmlDocument
Dim movieOrderNodes As XmlNodeList
Dim movieOrderNode As XmlNode

xmlDoc.LoadXml(rawData)

' Traverse each <FilmOrder>
movieOrderNodes = xmlDoc.GetElementsByTagName("FilmOrder")

For Each movieOrderNode In movieOrderNodes
    '**********************************************************
    ' Process <name>, <filmId> and <quantity> here
    '**********************************************************
Next

Dim baseDataNodes As XmlNodeList
Dim bFirstInRow As Boolean

baseDataNodes = movieOrderNode.ChildNodes

bFirstInRow = True

For Each baseDataNode As XmlNode In baseDataNodes
  If (bFirstInRow) Then
    bFirstInRow = False
  Else
    Console.Out.Write(", ")
  End If
  Console.Out.Write(baseDataNode.Name & ": " & baseDataNode.InnerText)
Next
Console.Out.WriteLine()

name: Grease, filmId: 101, quantity: 10
name: Lawrence of Arabia, filmId: 102, quantity: 10

Dim rawData As String = _
   <multiFilmOrders>
      <FilmOrder>
         <name>Grease</name>
         <filmId>101</filmId>
         <quantity>10</quantity>
      </FilmOrder>
      <FilmOrder>
         <name>Lawrence of Arabia</name>
         <filmId>102</filmId>
         <quantity>10</quantity>
      </FilmOrder>
   </multiFilmOrders>

Dim xmlDoc As New XmlDocument
Dim movieOrderNodes As XmlNodeList
Dim movieOrderNode As XmlNode

Dim baseDataNodes As XmlNodeList
Dim bFirstInRow As Boolean

xmlDoc.LoadXml(rawData)

' Traverse each <FilmOrder>
movieOrderNodes = xmlDoc.GetElementsByTagName("FilmOrder")

For Each movieOrderNode In movieOrderNodes
  baseDataNodes = movieOrderNode.ChildNodes
  bFirstInRow = True
  For Each baseDataNode As XmlNode In baseDataNodes
    If (bFirstInRow) Then
      bFirstInRow = False
    Else
      Console.Out.Write(", ")
    End If
    Console.Out.Write(baseDataNode.Name & ": " & baseDataNode.InnerText)
  Next
  Console.Out.WriteLine()
Next

Dim xmlDoc As New XmlDocument

xmlDoc.Load("..MovieSupplierShippingListV2.xml")
'*******************************************
' Business rules process document here
'*******************************************

xmlDoc.Save("..MovieSupplierShippingListV2.xml")

<FilmOrder name="Grease" filmId="101" quantity="10" />

Dim attributes As XmlAttributeCollection
Dim filmId As Integer
Dim quantity As Integer

attributes = node.Attributes()

For Each attribute As XmlAttribute In attributes
  If 0 = String.Compare(attribute.Name, "filmId") Then
    filmId = attribute.InnerXml
  ElseIf 0 = String.Compare(attribute.Name, "quantity") Then
    quantity = attribute.InnerXml
  End If
Next

If filmId = 101 Then
  ' This film comes packaged in batches of six.
  Do Until (quantity / 6) = True
    quantity -= 1
  Loop

  Attributes.ItemOf("quantity").Value = quantity
End If

Sub TraverseAttributes(ByRef node As XmlNode)
    Dim attributes As XmlAttributeCollection
    Dim filmId As Integer
    Dim quantity As Integer

    attributes = node.Attributes()

    For Each attribute As XmlAttribute In attributes
        If 0 = String.Compare(attribute.Name, "filmId") Then
            filmId = attribute.InnerXml
        ElseIf 0 = String.Compare(attribute.Name, "quantity") Then
            quantity = attribute.InnerXml

End If
    Next

    If filmId = 101 Then
       ' This film comes packaged in batches of six
       Do Until (quantity / 6) = True
          quantity -= 1
       Loop

       Attributes.ItemOf("quantity").Value = quantity
    End If
End Sub

Sub WXReadMovieDOM()
    Dim xmlDoc As New XmlDocument
    Dim movieOrderNodes As XmlNodeList
    xmlDoc.Load("..MovieSupplierShippingListV2.xml")

    ' Traverse each <FilmOrder>
    movieOrderNodes = xmlDoc.GetElementsByTagName("FilmOrder")

    For Each movieOrderNode As XmlNode In movieOrderNodes
        TraverseAttributes(movieOrderNode)
    Next

    xmlDoc.Save("..MovieSupplierShippingListV2.xml")
End Sub

The first example used four XSLT elements to transform an XML file into an HTML file. Such an example has merit, but it doesn't demonstrate an important use of XSLT: transforming XML from one standard into another standard. This may involve renaming elements/attributes, excluding elements/attributes, changing data types, altering the node hierarchy, and representing elements as attributes, and vice versa.

Returning to the example, a case of differing XML standards could easily affect your software that automates movie orders coming into a supplier. Imagine that the software, including its XML representation of a movie order, is so successful that you sell 100,000 copies. However, just as you are celebrating, a consortium of the largest movie supplier chains announces that they are no longer accepting faxed orders and that they are introducing their own standard for the exchange of movie orders between movie sellers and buyers.

Rather than panic, you simply ship an upgrade that includes an XSLT file. This upgrade (a bit of extra code plus the XSLT file) transforms your XML representation of a movie order into the XML representation dictated by the consortium of movie suppliers. Using an XSLT file enables you to ship the upgrade immediately. If the consortium of movie suppliers revises their XML representation, then you are not obliged to change your source code. Instead, you can simply ship the upgraded XSLT file that ensures each movie order document is compliant.

The specific source code that executes the transform is as follows:

Dim myXslCompiledTransform As XslCompiledTransform = New XslCompiledTransform

myXslCompiledTransform.Load("..ConvertLegacyToNewStandard.xslt")
myXslCompiledTransform.Transform("..MovieOrdersOriginal.xml", _
   "..MovieOrdersModified.xml")

Those three lines of code accomplish the following:

Recall that the input XML document (MovieOrdersOriginal.xml) does not match the format required by your consortium of movie supplier chains. The content of this source XML file is as follows:

<?xml version="1.0" encoding="utf-8" ?>
<FilmOrder_Multiple>
    <multiFilmOrders>
        <FilmOrder>

<name>Grease</name>
            <filmId>101</filmId>
            <quantity>10</quantity>
        </FilmOrder>
        ...
    </multiFilmOrders>
</FilmOrder_Multiple>

The format exhibited in the preceding XML document does not match the format of the consortium of movie supplier chains. To be accepted by the collective of suppliers, you must transform the document as follows:

Many of the steps performed by the transform could have been achieved using an alternative technology. For example, you could have used Source Code Style attributes with your serialization to generate the correct XML attribute and XML element name. Had you known in advance that a consortium of suppliers was going to develop a standard, you could have written your classes to be serialized based on the standard. The point is that you did not know and now one standard (your legacy standard) has to be converted into a newly adopted standard of the movie suppliers' consortium. The worst thing you could do would be to change your working code and then force all users working with the application to upgrade. It is vastly simpler to add an extra transformation step to address the new standard.

The XSLT file that facilitates the transform is named ConvertLegacyToNewStandard.xslt. A portion of this file is implemented as follows:

<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="FilmOrder">
    <!- rename <FilmOrder> to <DvdOrder> ->
    <xsl:element name="DvdOrder">
      <!- Make element 'quantity' attribute HowMuch
            Notice attribute HowMuch comes before attribute FilmOrderNumber ->
      <xsl:attribute name="HowMuch">
        <xsl:value-of select="quantity"></xsl:value-of>
      </xsl:attribute>
      <!- Make element filmId attribute FilmOrderNumber ->
      <xsl:attribute name="FilmOrderNumber">
        <xsl:value-of select="filmId"></xsl:value-of>
      </xsl:attribute>
    </xsl:element>

<!- end of DvdOrder element ->
  </xsl:template>
</xsl:stylesheet>

In the previous snippet of XSLT, the following XSLT elements are used to facilitate the transformation:

Two new XSLT elements have crept into your vocabulary: element and attribute. Both of these XSLT elements live up to their names. Specifying the XSLT element named element places an element in the destination XML document. Specifying the XSLT element named attribute places an attribute in the destination XML document. The XSLT transform found in ConvertLegacyToNewStandard.xslt is too long to review here. When reading this file in its entirety, remember that this XSLT file contains inline documentation to specify precisely what aspect of the transformation is being performed at which location in the XSLT document. For example, the following XML code comments indicate what the XSLT element attribute is about to do:

<!-- Make element 'quantity' attribute HowMuch
      Notice attribute HowMuch comes before attribute FilmOrderNumber -->
<xsl:attribute name="HowMuch">
     <xsl:value-of select='quantity'></xsl:value-of>
</xsl:attribute>

The preceding example spans several pages but contains just three lines of code. This demonstrates that there is more to XML than learning how to use it in Visual Basic and the .NET Framework. Among other things, you also need a good understanding of XSLT, XPath, and XQuery.

We just took a good look at XSLT and the System.Xml.Xsl namespace, but there is a lot more to it than that. Other classes and interfaces exposed by the System.Xml.Xsl namespace include the following:

Those interested in fully exploring the XML-specific features of SQL Server should take a look at Professional SQL Server 2000 Programming by Robert Vieira (Wrox Press, 2000). However, because the content of that book is not .NET-specific, the next example forms a bridge between Professional SQL Server 2000 Programming and the .NET Framework.

Two of the major XML-related features exposed by SQL Server are as follows:

SQL Server's support for OPENXML is a matter of calling a stored procedure. A developer who can execute a stored procedure call using Visual Basic in conjunction with ADO.NET can take full advantage of SQL Server's support for OPENXML. FOR XML queries have a certain caveat when it comes to ADO.NET. To understand this caveat, consider the following FOR XML query:

SELECT ShipperID, CompanyName, Phone FROM Shippers FOR XML RAW

Using SQL Server's Query Analyzer, this FOR XML RAW query generated the following XML:

<row ShipperID="1" CompanyName="Speedy Express" Phone="(314) 555-9831" />
<row ShipperID="2" CompanyName="United Package" Phone="(314) 555-3199" />
<row ShipperID="3" CompanyName="Federal Shipping" Phone="(314) 555-9931" />

The same FOR XML RAW query can be executed from ADO.NET as follows:

Dim adapter As New _
    SqlDataAdapter("SELECT ShipperID, CompanyName, Phone " & _
                   "FROM Shippers FOR XML RAW", _
                   "SERVER=localhost;UID=sa;PWD=sa;Database=Northwind;")
Dim ds As New DataSet

adapter.Fill(ds)
Console.Out.WriteLine(ds.GetXml())

The caveat with respect to a FOR XML query is that all data (the XML text) must be returned via a result set containing a single row and a single column named XML_F52E2B61-18A1-11d1-B105- 00805F49916B.

The output from the preceding code snippet demonstrates this caveat (where...represents similar data not shown for reasons of brevity):

<NewDataSet>
  <Table>
    <XML_F52E2B61-18A1-11d1-B105-00805F49916B>
      /&lt;row ShipperID="1" CompanyName="Speedy Express"
      Phone="(503) 555-9831"/&gt;
      ...
    </XML_F52E2B61-18A1-11d1-B105-00805F49916B>
  </Table>
</NewDataSet>

The value of the single row and single column returned contains what looks like XML, but it contains /< instead of the less-than character, and /> instead of the greater-than character. The symbols < and > cannot appear inside XML data, so they must be entity-encoded — that is, represented as /> and /<. The data returned in element <XML_F52E2B61-18A1-11d1-B105-00805F49916B> is not XML, but data contained in an XML document.

To fully utilize FOR XML queries, the data must be accessible as XML. The solution to this quandary is the ExecuteXmlReader method of the SQLCommand class. When this method is called, an SQLCommand object assumes that it is executed as a FOR XML query and returns the results of this query as an XmlReader object. An example of this follows:

Dim connection As New _
    SqlConnection("SERVER=localhost;UID=sa;PWD=sa;Database=Northwind;")
Dim command As New _
    SqlCommand("SELECT ShipperID, CompanyName, Phone " & _
                    "FROM Shippers FOR XML RAW")
Dim memStream As MemoryStream = New MemoryStream
Dim xmlReader As New XmlTextReader(memStream)

connection.Open()
command.Connection = connection
xmlReader = command.ExecuteXmlReader()
' Extract results from XMLReader

You will need to import the System.Data.SqlClient namespace for this example to work.

The XmlReader created in this code is of type XmlTextReader, which derives from XmlReader. The XmlTextReader is backed by a MemoryStream; hence, it is an in-memory stream of XML that can be traversed using the methods and properties exposed by XmlTextReader. Streaming XML generation and retrieval was discussed earlier.

Using the ExecuteXmlReader method of the SQLCommand class, it is possible to retrieve the result of FOR XML queries. What makes the FOR XML style of queries so powerful is that it can configure the data retrieved. The three types of FOR XML queries support the following forms of XML customization:

FOR XML queries are flexible. Using FOR XML EXPLICIT and the movie rental database, it would be possible to generate any form of XML movie order standard. The decision that needs to be made is where XML configuration takes place. Using Visual Basic, a developer could use XmlTextReader and XmlTextWriter to create any style of XML document. Using the XSLT language and an XSLT file, the same level of configuration can be achieved. SQL Server and, in particular, FOR XML EXPLICIT, enable the same level of XML customization, but this customization takes place at the SQL level and may even be configured to stored procedure calls.

As a representation for data, XML is ideal in that it is a self-describing data format that enables you to provide your data sets as complex data types. It also provides order to your data. SQL Server 2005 embraces this direction.

More and more developers are turning to XML as a means of data storage. For instance, Microsoft Office enables documents to be saved and stored as XML documents. As an increasing number of products and solutions turn toward XML as a means of storage, this allows for a separation between the underlying data and the presentation aspect of what is being viewed. XML is also being used as a means of communicating data sets across platforms and the enterprise. The entire XML Web Services story is a result of this new capability. Simply said, XML is a powerful alternative to your data storage solutions.

Just remember that the power of using XML isn't only about storing data as XML somewhere (whether that is XML files or not); it is also about the capability to quickly access this XML data and to be able to query the data that is retrieved.

SQL Server 2005 makes a big leap toward XML in adding an XML data type as an option. This enables you to unify the relational aspects of the database and the current desires to work with XML data.

FOR XML has also been expanded from within this latest edition of SQL Server. This includes a new TYPE directive that returns an XML data type instance. In addition, the NET 2.0 Framework introduced a new namespace — System.Data.SqlXml — that enables you to easily work with the XML data that comes from SQL Server 2005. The SqlXml object is an XmlReader-derived type. Another addition is the use of the SqlDataReader object's GetXml method.

SQL Server 2008 continues on this path and introduces some new XML features. First, it supports lax validation using XSD schemas. This wasn't possible prior to this release. Another big change is related to how SQL Server handles the storage of dateTime values. In SQL Server 2005, when you stored dateTime values, the database would first normalize everything to UTC time, regardless of whether or not you wanted to store the information in a specific time zone. In addition, if you excluded the time in your dateTime declaration, SQL Server 2005 would add it back for you so that there was a full dateTime stored within the database. SQL Server 2008, conversely, enables you to store the dateTime value exactly as you declared it. No modifications or alterations are made to your value as it is stored in the database.

Another new feature of SQL Server 2008 is support of union types that contain list types. This means that you can now work with elements such as the following:

<Stocks>INTC MSFT CSCO IBM RTRSY</Stocks>

Union types enable you to define multiple items within a single element with a space between the elements, rather than define each as separate elements, as shown here:

<Stocks>
   <Item>INTC</Item>
   <Item>MSFT</Item>
   <Item>CSCO</Item>
   <Item>IBM</Item>
   <Item>RTRSY</Item>
</Stocks>

ASP.NET 3.5 contains a series of data source controls designed to bridge the gap between your data stores (such as XML) and the data-bound controls at your disposal. These new data controls not only enable you to retrieve data from various data stores, they also enable you to easily manipulate the data (using paging, sorting, editing, and filtering) before the data is bound to an ASP.NET server control.

With XML being as important as it is, a specific data source control is available in ASP.NET just for retrieving and working with XML data: XmlDataSource. This control enables you to connect to your XML data and use this data with any of the ASP.NET data-bound controls. Just like the SqlDataSource and the ObjectDataSource controls (which are two of the other data source controls), the XmlDataSource control enables you to not only retrieve data, but also insert, delete, and update data items. With increasing numbers of users turning to XML data formats, such as Web services, RSS feeds, and more, this control is a valuable resource for your Web applications.

To show the XmlDataSource control in action, first create a simple XML file and include this file in your application. The following code reflects a simple XML file of Russian painters:

<?xml version="1.0" encoding="utf-8" ?>
<Artists>
   <Painter name="Vasily Kandinsky">
      <Painting>
         <Title>Composition No. 218</Title>
         <Year>1919</Year>
      </Painting>
   </Painter>
   <Painter name="Pavel Filonov">
      <Painting>
         <Title>Formula of Spring</Title>
         <Year>1929</Year>
      </Painting>
   </Painter>
   <Painter name="Pyotr Konchalovsky">
      <Painting>
         <Title>Sorrento Garden</Title>
         <Year>1924</Year>
      </Painting>
   </Painter>
</Artists>

Now that the Painters.xml file is in place, the next step is to use an ASP.NET DataList control and connect this DataList control to an <asp:XmlDataSource> control, as shown here:

<%@ Page Language="VB"%>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>XmlDataSource</title>
</head>
<body>
    <form id="form1" runat="server">
        <asp:DataList ID="DataList1" Runat="server"
         DataSourceID="XmlDataSource1">
            <ItemTemplate>
                <p><b><%# XPath("@name") %></b><br />
                <i><%# XPath("Painting/Title") %></i><br />
                <%# XPath("Painting/Year") %></p>
            </ItemTemplate>
        </asp:DataList>

<asp:XmlDataSource ID="XmlDataSource1" Runat="server"
         DataFile="~/Painters.xml" XPath="Artists/Painter">
        </asp:XmlDataSource>
    </form>
</body>
</html>

This is a simple example, but it shows you the power and ease of using the XmlDataSource control. Pay attention to two attributes in this example. The first is the DataFile attribute. This attribute points to the location of the XML file. Because the file resides in the root directory of the application, it is simply ~/Painters.xml. The next attribute included in the XmlDataSource control is the XPath attribute. The XmlDataSource control uses XPath for the filtering of XML data. In this case, the XmlDataSource control is taking everything within the <Painter> set of elements. The value Artists/Painter means that the XmlDataSource control navigates to the <Artists> element and then to the <Painter> element within the specified XML file.

The DataList control next must specify the DataSourceID as the XmlDataSource control. In the <ItemTemplate> section of the DataList control, you can retrieve specific values from the XML file by using XPath commands. The XPath commands filter the data from the XML file. The first value retrieved is an element attribute (name) contained in the <Painter> element. When you retrieve an attribute of an element, you preface the name of the attribute with an @ symbol. In this case, you simply specify @name to get the painter's name. The next two XPath commands go deeper into the XML file, getting the specific painting and the year of the painting. Remember to separate nodes with a /. When run in the browser, this code produces the results shown in Figure 10-5.

Figure 10.5. Figure 10-5

Besides working from static XML files such as the Painters.xml file, the XmlDataSource file can work from dynamic, URL-accessible XML files. One popular XML format pervasive on the Internet today is blogs, or weblogs. Blogs, or personal diaries, can be viewed either in the browser, through an RSS-aggregator, or just as pure XML.

Figure 10-6 shows blog entries directly in the browser (if you are using IE7). Behind this blog is an actual XML document that can be worked with by your code. You can find a lot of blogs to play with for this example at weblogs.asp.net. This screen shot uses the blog found at www.geekswithblogs.net/evjen.

Now that you know the location of the XML from the blog, you can use this XML with the XmlDataSource control and display some of the results in a DataList control. The code for this example is shown here:

<%@ Page Language="VB"%>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">

Figure 10.6. Figure 10-6

<title>XmlDataSource</title>
</head>
<body>
    <form id="form1" runat="server">
        <asp:DataList ID="DataList1" Runat="server"
         DataSourceID="XmlDataSource1">
            <HeaderTemplate>
                <table border="1" cellpadding="3">
            </HeaderTemplate>
            <ItemTemplate>
                <tr><td><b><%# XPath("title") %></b><br />
                <i><%# XPath("pubDate") %></i><br />
                <%# XPath("description") %></td></tr>
            </ItemTemplate>
            <AlternatingItemTemplate>
                <tr bgcolor="LightGrey"><td><b><%# XPath("title") %></b><br />
                <i><%# XPath("pubDate") %></i><br />
                <%# XPath("description") %></td></tr>
            </AlternatingItemTemplate>
            <FooterTemplate>
                </table>
            </FooterTemplate>
        </asp:DataList>

        <asp:XmlDataSource ID="XmlDataSource1" Runat="server"
         DataFile="http://geekswithblogs.net/evjen/Rss.aspx"
         XPath="rss/channel/item">
        </asp:XmlDataSource>
    </form>
</body>
</html>

This example shows that the DataFile points to a URL where the XML is retrieved. The XPath property filters out all the <item> elements from the RSS feed. The DataList control creates an HTML table and pulls out specific data elements from the RSS feed, such as the <title>, <pubDate>, and <description> elements.

Running this page in the browser results in something similar to what is shown in Figure 10-7.

Figure 10.7. Figure 10-7

This approach also works with XML Web Services, even those for which you can pass in parameters using HTTP-GET. You just set up the DataFile value in the following manner:

DataFile="http://www.someserver.com/GetWeather.asmx/ZipWeather?zipcode=63301"

One big issue with using the XmlDataSource control is that when using the XPath capabilities of the control, it is unable to understand namespace-qualified XML. The XmlDataSource control chokes on any XML data that contains namespaces, so it is important to yank out any prefixes and namespaces contained in the XML.

To make this a bit easier, the XmlDataSource control includes the TransformFile attribute. This attribute takes your XSLT transform file, which can be applied to the XML pulled from the XmlDataSource control. That means you can use an XSLT file, which will transform your XML in such a way that the prefixes and namespaces are completely removed from the overall XML document. An example of this XSLT document is illustrated here:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>
   <xsl:template match="*">
      <!-- Remove any prefixes -->
      <xsl:element name="{local-name()}">
          <!-- Work through attributes -->
          <xsl:for-each select="@*">
             <!-- Remove any attribute prefixes -->
             <xsl:attribute name="{local-name()}">
                <xsl:value-of select="."/>
             </xsl:attribute>
          </xsl:for-each>
      <xsl:apply-templates/>
      </xsl:element>
   </xsl:template>
</xsl:stylesheet>

Now, with this XSLT document in place within your application, you can use the XmlDataSource control to pull XML data and strip that data of any prefixes and namespaces:

<asp:XmlDataSource ID="XmlDataSource1" runat="server"
 DataFile="NamespaceFilled.xml" TransformFile="~/RemoveNamespace.xsl"
 XPath="ItemLookupResponse/Items/Item"></asp:XmlDataSource>

Since the very beginning of ASP.NET, there has always been a server control called the Xml server control. This control performs the simple operation of XSLT transformation upon an XML document. The control is easy to use: All you do is point to the XML file you wish to transform using the DocumentSource attribute, and the XSLT transform file using the TransformSource attribute.

To see this in action, use the Painters.xml file shown earlier. Create your XSLT transform file, as shown in the following example:

<?xml version="1.0" encoding="utf-8"?>

<xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:template match="/">
      <html>
      <body>
        <h3>List of Painters &amp; Paintings</h3>
        <table border="1">
          <tr bgcolor="LightGrey">
            <th>Name</th>
            <th>Painting</th>
            <th>Year</th>
          </tr>
          <xsl:apply-templates select="//Painter"/>
        </table>
      </body>
    </html>
  </xsl:template>

<xsl:template match="Painter">
    <tr>
      <td>
        <xsl:value-of select="@name"/>
      </td>
      <td>
        <xsl:value-of select="Painting/Title"/>
      </td>
      <td>
        <xsl:value-of select="Painting/Year"/>
      </td>
    </tr>
  </xsl:template>

</xsl:stylesheet>

With the XML document and the XSLT document in place, the final step is to combine the two using the Xml server control provided by ASP.NET:

<%@ Page Language="VB" %>

<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" runat="server">
    <title>XmlDataSource</title>
</head>
<body>
    <form id="form1" runat="server">
        <asp:Xml ID="Xml1" runat="server" DocumentSource="~/Painters.xml"
         TransformSource="~/PaintersTransform.xsl"></asp:Xml>
    </form>
</body>
</html>

The result is shown in Figure 10-8.

Figure 10.8. Figure 10-8