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

previous section described the features of .NET that are aimed at accessing relational data, and how they relate to the way you work with data compared to the traditional techniques used in previous versions of ADO. However, there is another technique for working with data within the .NET Framework.

XML is fast becoming the lingua franca of the Web, and is being adopted within many other application areas as well. We discussed the reasons for this earlier, and now look at how XML is supported within .NET. This relates to the .NET support for relational data, as XML is the standard persistence format for data within the .NET data access classes. However, there are also several other techniques for reading, writing, and manipulating XML data and the associated XML-based data formats.

In this book, we're assuming that the reader is familiar with XML as a data storage mechanism, and how it is used through an XML parser and with the associated technologies such as XSLT. Our aim is to show the way that the .NET Framework and ASP.NET can be used with XML data.

The Fundamental XML Objects

The W3C (at http://www.w3.org/) provides standards that define the structure and interfaces that should be provided by applications used for accessing XML documents. This is referred to as the XML Document Object Model (DOM), and is supported under .NET by the

XmlDocument and

XmlDataDocument objects, as shown in Figure 8-12. They provide full support for the XML DOM Level 2 Core. Within their implementation are the node types and objects that are required for the DOM interfaces, such as the

XmlElement and

XmlAttribute objects:

Figure 8-12:

However, .NET extends the support for XML to provide much more in the way of techniques for manipulating XML documents, XML Schemas, and stylesheets. Figure 8-13 shows the main classes that are used when working with XML documents within .NET applications, and how they are related by showing the kinds of paths that you can follow when working with XML data:

Figure 8-13:

Basically, the classes shown in Figure 8-13 fall into three categories:

Reading, writing, and transforming XML:The

XmlTextReader ,

XmlNodeReader , and

XmlTextWriter – plus the

XslTransform object for creating files in a different format to the original XML document.

Storing and manipulating XML:The function of the

XmlDocument ,

XmlDataDocument , and

XPathDocument objects.

Querying XML:The function of

XPathNavigator object.

There is some overlap between these functions, of course. To validate an XML document while reading it, you can use an

XmlValidatingReader , and there are other objects for creating and editing XML Schemas that aren't covered in this book. You can also use the

XslTransform object to perform querying of a document as well as transforming it into different formats.

In this section, we'll briefly overview the objects and their commonly used methods, and then to show some simple examples. We'll come back to XML again in Chapter 11 and see some more advanced techniques.

The Document Objects

There are three implementations of the document object for storing and working with XML:

The

XmlDocument object is the .NET implementation of the standard DOM Level 2

XMLDocument interface. The properties and methods it exposes include those defined by W3C for manipulating XML documents, plus some extensions to make common operations easier.

The

XmlDataDocument object is an extension of the

XmlDocument object, providing the same set of properties and methods. However, it also acts as a "bridge" between XML and relational data access methods. Once loaded with an XML document, it can expose it as a

DataSet object. This allows you to use relational data programming techniques to work with the data, as well as the same XML DOM techniques that are used with an

XmlDocument object.

The

XPathDocument object is a fast and compact implementation of an XML storage object that is designed for access via an

XPathNavigator object, using only XPath queries or navigation element-by-element using the "pull" technique.

The Commonly Used XML Document Methods

The

XPathDocument object has no really useful public methods other than

CreateNavigator , as it is designed solely to work with an

XPathNavigator object. However, the other two document objects expose the full set of properties and methods specified in the W3C XML DOM Level 2 Core. The extensions to these properties and methods include several very useful methods regularly used to work with XML documents.

The following table shows the extensions for creating specific types of node, and accessing existing nodes in the

XmlDocument and

XmlDataDocument objects:

The following table shows the series of useful methods that are available for loading and saving XML to and from the

XmlDocument and

XmlDataDocument objects:

To use an

XPathNavigator with any of the three types of XML document object, create it using the

CreateNavigator method as shown in the following table:

The

XmlDataDocument adds a single property to those exposed by the

XmlDocument class, as shown in the following table:

The

XmlDataDocument also adds methods that provide extra access to the contents of the document, treating it more like a rowset or data table, as shown in the following table:

The XPathNavigator Class

In order to make working with XML documents easier, the

System.Xml namespace classes include the

XPathNavigator , which can be used to navigate within an XML document or to query the content of the document using an XPath expression. Note that an

XPathNavigator can be used with any of the XML document objects – not just an

XPathDocument . You can create an

XPathNavigator based on an

XmlDocument or an

XmlDataDocument as well.

The

XPathNavigator provides methods and properties that allow cursor-style navigation through the XML document; for example, by stepping through the nodes (elements and attributes) in order, or by skipping to the next node of a specific type.

The

XPathNavigator provides methods that accept an XPath expression, the name of a node or a node type, and return one or more matching nodes. You can then iterate through these nodes.

An

XPathNavigator can only be created from an existing document object. This is done using the

CreateNavigator method:

Dim objNav1 As XPathNavigator = objXMLDoc.CreateNavigator() 
Dim objNav2 As XPathNavigator = objXMLDataDoc.CreateNavigator() 
Dim objNav3 As XPathNavigator = objXPathDoc.CreateNavigator() 

The Commonly Used XPathNavigator Methods

The

XPathNavigator is designed to act as a pull model interface for an XML document. It allows you to navigate across a document, and select and access nodes within that document. You can also create two (or more) navigator objects against the same document, and compare their positions.

To edit the XML document(s), you can use the reference to the current node exposed by the navigator, or an

XPathNodeIterator that contains a collection of nodes, and call the methods of that node or collection. At the same time, the

XPathNavigator exposes details about the current node directly, so there are two ways to get information about each node.

The table that follows shows methods used to move around within the document, making different nodes current in the navigator, and to create a new navigator:

The following table shows the methods used to access and select parts of the content of the document:

The XmlTextWriter Class

When using an

XmlDocument to create a new XML document, you must create document fragments and insert them into the document in a specific way – a technique that can be error-prone and complex. The

XmlTextWriter can be used to create an XML document node by node in serial fashion by simply writing the tags and content to the output stream using the comprehensive range of methods that it provides.

The

XmlTextWriter takes as its source either a

TextWriter that refers to a disk file, the path and name of a disk file, or a

Stream that will contain the new XML document. It exposes a series of properties and methods that can be used to create XML nodes and other content, and output them to the disk file or stream directly.

The

XmlTextWriter can also be specified as the output device for methods in several other objects, where it automatically streams the content to a disk file, a

TextWriter , or a

Stream .

The Commonly Used XmlTextWriter Methods

The most commonly used methods of the

XmlTextWriter are listed in the following table:

The XmlReader Classes

You need to be able to read documents from other sources, rather than creating them from scratch. The

XmlReader class is a base class from which two public classes,

XmlTextReader and

XmlNodeReader , inherit.

The

XmlTextReader takes as its source either a

TextReader that refers to an XML disk file, the path and name of an XML disk file, or a

Stream containing an XML document. The contents of the document can be read one node at a time, and the object provides information about each node and its value as it is read.

The

XmlNodeReader takes a reference to an

XmlNode instance (usually from within an

XmlDocument ) as its source, allowing you to read specific portions of an XML document rather than having to read all of it, if you only want to access a specific node and its children.

The

XmlTextReader and

XmlNodeReader can be used standalone to provide simple and efficient access to XML documents or as the source for another object whereby they automatically read the document and pass it to the parent object.

Like the

XPathNavigator , the

XmlTextReader provides a pull model for accessing XML documents node-by-node, rather than parsing them into a tree in memory as is done in an XML parser. This allows larger documents to be accessed without impacting on memory usage, and can also make coding easier, depending on the task you need to accomplish.

Furthermore, if you are just searching for a specific value, you won't always have to read the whole document. Taking a broad average, you will reach the specific node you want after reading only half the document. This is considerably faster and more efficient than reading and parsing the whole document every time.

The Commonly Used XmlReader Methods

The

XmlTextReader and the

XmlNodeReader objects have almost identical sets of properties and methods. The most commonly used methods are shown in the following table:

The XmlValidatingReader Class

There is another object based on the

XmlReader base class – the

XmlValidatingReader . You can think of this as an

XmlTextReader that does document validation against a schema or DTD. You can create an

XmlValidatingReader from an existing

XmlReader (an

XmlTextReader or

XmlNodeReader ), from a

Stream , or from a

String that contains the XML to be validated.

Once the

XmlValidatingReader is created, it can be used just like any other

XmlReader . However, it raises an event when a schema validation error occurs, allowing you to ensure that the XML document is valid against one or more specific schemas.

The XslTransform Class

One common requirement when working with XML is the need to transform a document using XML Stylesheet Language (XSL or XSLT). The .NET Framework classes provide the

XslTransform object, which is specially designed to perform either XSL or XSLT transformations.

The Commonly Used XslTransform Methods

The

XslTransform class has two methods that are used for working with XML documents and XSL/XSLT stylesheets, as shown in the following table:

Let's look at some of the common tasks that need to be carried out using XML documents.