Creating an XML Document in .NET

You can create any kind of XML document you want in order to describe any kind of data you want to work with. However, XML works best with hierarchical types of data structures that can be organized in an outline form. The first step of defining an XML language is to look at the data you are working with and try to organize it into an outline form. For the quiz program, I realized that a quiz is made up of several problems. (I avoided the use of the term question to describe the major element of a quiz because I wanted to use question to describe the question being asked.)

Each problem consists of a question, four possible answers, and the correct answer. To simplify the example, I decided to work only with multiple−choice questions with four answers. When I had decided what kinds of tags I would have, I started to build a sample document. You can use any text editor you want to build an XML document, but Visual Studio comes with a very nice XML document editor that makes the task simple. To use the XML editor, open up a project in the editor, and choose Add New Item from the Project menu. Select XML Document from the resulting dialog to open the XML editor. If you already have an XML document that you’d like to open in the editor, choose Open File from the File menu, and select the XML file from the drive system. (Alternatively, you can choose Add Existing Item from the Project menu. Opening a file doesn’t necessarily add the file to your project, but adding an existing item does.) Figure 10.5 shows an XML file being written in the Visual Studio XML editor.

Figure 10.5: The Visual Studio XML editor automatically indents your code and creates a closing tag for each opening tag.

The XML editor included with Visual Studio makes writing XML easy because it automatically indents your XML code and, each time you create a tag, it creates an ending tag. The editor also color−codes the XML much like normal C# code, which helps you to separate the XML code from the actual data. Visual Studio also includes a very handy editor for writing your own XML schema, but you will not need it for this brief introduction to XML. After you create the basic framework of your data structure, you can click the data tag at the bottom of the XML code window to switch to a table view (see Figure 10.6).

283

Figure 10.6: After you define your data set, you can enter it in, just like a database.

Visual Studio can automatically convert your XML structure into a table for easy data entry. It allows you to enter your data quickly and accurately without having to repeat all the XML tags. This gives you the flexibility of XML with the easy data access of a more formal database. In Chapter 11, “Databases and ADO.NET: The Spymaster Database,” you will learn more about the relationship between XML and databases in .NET.

Creating an XML Schema for Your Language

If you’re going to reuse your language or you expect other people to use it, you should have a formal definition of the rules of your language. There has been some debate among the XML community about how this should be done, but .NET provides a solution that is extremely simple and elegant. When you load or create XML code in the IDE XML editor, a new XML menu appears on the menu bar. After you define your first set of data, you can choose Schema from the XML menu visible in the XML editor. This creates a new XML document that describes how your data works. The following XML code illustrates the schema automatically generated for the quiz document:

<?xml version="1.0" ?> <xs:schema id="test"

targetNamespace="http://tempuri.org/sampleTest.xsd"

xmlns:mstns="http://tempuri.org/sampleTest.xsd"

xmlns="http://tempuri.org/sampleTest.xsd"

xmlns:xs="http://www.w3.org/2001/XMLSchema"

xmlns:msdata="urn:schemas−microsoft−com:xml−msdata"

attributeFormDefault="qualified"

elementFormDefault="qualified"> <xs:element name="test"

msdata:IsDataSet="true"

msdata:EnforceConstraints="False">

<xs:complexType>

<xs:choice maxOccurs="unbounded"> <xs:element name="problem">

<xs:complexType>

284

<xs:sequence>

<xs:element name="question" type="xs:string" minOccurs="0" /> <xs:element name="answerA" type="xs:string" minOccurs="0" /> <xs:element name="answerB" type="xs:string" minOccurs="0" /> <xs:element name="answerC" type="xs:string" minOccurs="0" /> <xs:element name="answerD" type="xs:string" minOccurs="0" /> <xs:element name="correct" type="xs:string" minOccurs="0" />

</xs:sequence>

</xs:complexType>

</xs:element>

</xs:choice>

</xs:complexType>

</xs:element>

</xs:schema>

The meaning of this code is beyond the scope of an introduction to XML, but the code is automatically generated, so you can use it even if you don’t know exactly what it’s doing.

You can also choose Validate from the XML menu to ensure that your data follows the guidelines generated by the schema. For a beginner, creating a schema and validating your documents are not necessary because your first attempts at XML code will probably be simple and nobody but you will use your particular XML dialect. If you write an XML language that others will use, you will want to explore data validation because it can prevent many kinds of data errors. In this chapter most of the XML will be generated automatically by the programs, so there is no need to validate it.

Investigating the .NET View of XML

The .NET framework defines a set of classes that map to an XML document and its constituent parts. An XML document is essentially seen as a tree. The document itself is the base of the tree. The document contains a series of nodes. .NET has a class to define the Node element. Each pair of tags (such as <question> and </question>) is considered an element. The information between the tags is the data (usually text). The .NET environment provides three classes that are critical for using XML:

∙The XmlNode class defines the basic characteristics of any node in an XML document.

∙The XmlElement class extends XmlNode and adds a few methods for dealing with attributes.

∙The XmlDocument class also extends XmlNode, but it adds several methods, mainly for storing and loading documents and creating new nodes.

Essentially, you work with an XML document in .NET by defining an XmlDocument, which is mapped to a specific document on the drive system. All the tags in the document are instances of the XmlElement class. Because both XmlDocument and XmlElement are derived from XmlNode, they also share the characteristics of the XmlNode class.

Exploring the XmlNode Class

The XmlNode class describes each node in a document. A node can be an entire XML document, an element (a pair of tags), or data (the text inside a pair of tags). The XmlNode class has properties and methods that enable you to figure out what type of node you are working with. It also features the capability to extract and modify the data in a node. Table 10.1 presents important properties and methods of the XmlNode class.

Table 10.1: Selected Members of the XmlNode Class

285

Element	Type of	Description	Example
	Element
ChildNodes	Property	A collection of all the	MessageBox.Show
		children of the node	(theNode. ChildNodes[2].InnerText);
			//shows the text of child
			node 3 of the current node
FirstChild	Property	The first child of a	MessageBox.Show
		node	(theNode.
			FirstChild.InnerText); //shows the text of
			the first child of the current node
InnerText	Property	Gets or sets the text of	MessageBox.Show
		this node and all its	(theNode.InnerText);
		children	//shows the text value of the current
			node
Name	Property	Returns or sets the	MessageBox.Show
		name of the node	(theNode. Name);
			//displays the name of the current node
NextSibling	Property	Returns the next node	theNode =
		at the current level of	theNode. NextSibling;
		the hierarchy (or null)	//moves the node to its next sibling or
			sets the node to null
ParentNode	Property	Returns the parent of	theNode =
		the current node	theNode.ParentNode;
			//sets the node to its parent
AppendChild(node)	Method	Adds a child node to	theNode.AppendNode(newNode);
		the end of this node’s	//adds newNode to theNode's children
		children
Clone()	Method	Creates a copy of this	theNode.ParentNode.
		node	AppendNode(theNode.Clone());
			//adds a copy of this node at the same
			level as the node
RemoveChild(node)	Method	Removes a child node	theNode.Remove
		from the current node	(theNode. FirstChild);
			//removes the first child from the node

The XmlNode class is rarely used directly, but it has two descendants that form the foundation of all XML documents. The XmlDocument class describes an entire document, and the XmlElement class describes an element, which is the part of an XML document surrounded by a pair of tags. Much of the functionality of the XmlDocument and XmlElement classes is inherited from the XmlNode class, but the XmlDocument class has a few important properties and methods of its own, which are particular to a document.

Exploring the XmlDocument Class

The XmlDocument class describes an XML document. It features important properties and methods for working with the entire document. It has save and load methods, which allow you to save and load a document directly, without needing to use streams. The XmlDocument has methods for creating various elements inside the document, including the CreateElement() and CreateAttribute() methods. It has methods for adding a node to a document: Append(), InsertBefore(), and InsertAfter().

286