In some applications, you will want the user to provide you with the
necessary value(s) to create an element. Fortunately, the XmlDocument, the XmlNode,
and the
XmlElement classes provide all the necessary properties and methods to perform
the routine operations of an XML file, an element, or a node. The operations
include locating a node, adding a new element, or deleting a node.

Before performing an operation, you will usually need to
decide in what section of the file you want the action to be applied. As it
happens, you have on the root node, on a particular node inside the document, on
the parent of a
node, on a sibling of a node, etc. To get to a node, you will usually first get a
reference to its XmlElement object. To do this, you can declare an
XmlElement variable and initialize it with that reference.

Appending an Element

To assist with in programmatically creating a new element, the XmlDocument
class provides the CreateElement() method that is overloaded with three
versions. One of the versions uses the following syntax:

Public Function CreateElement(name As String) As XmlElement

Using this method, to create a new element, call it and pass it the name of the element.
For example, imagine you want to add a new Title element to the above file. You
would start with code as follows:

In order to add the new element to the file, you must specify its position in the
tree: whether it would be the first or the last node, whether you want to
position it before or after a node of your choice. For example, if you want to
add a new Title element to the above file, it would be considered a child of the
root, that is, a child of the XmlDocument.DocumentElement property. In
the previous lesson, we learned how to get a reference to the root node.

To support the positions of
existing nodes, the XmlNode class, which is the ancestor of all XML
nodes of the .NET Framework, provides various appropriate methods. One of these methods is
AppendChild(), which is
used to add an element as the last child of its parent. The syntax of the XmlNode.AppendChild()
method is:

Public Overridable Function AppendChild(newChild As XmlNode) As XmlNode

When calling this method, pass the XmlNode object you
had previous created. After adding the node, if you want the file to keep it,
you should save it. Here is an example:

Imagine that you want to add a video element. You have a
choice of adding one, more than one, or all child elements of the video node. To perform
this operation, one solution you can use is to "build" all child
elements of the video element, then add the node as a whole.

In the previous lesson, we saw that the XmlNode.InnerXml property comprises a
node, its markup, its children and their markup. This means that you can create
the child node(s) with its (their) markup(s) as a string and assign that string to an XmlNode.InnerXml
string. To do this, you would need the set version of the InnerXml
property. It is declared as follows:

Public Overridable Property InnerXml As String

Here is an example that adds a complete new video node to
the above XML file:

If you want the element to
have a value, the XmlDocument class provides the CreateTextNode()
method. This method returns an XmlText value. The syntax of this method
is:

Public Overridable Function CreateTextNode(text As String) As XmlText

This method takes as argument the string that would
constitute the value of the element. Before calling it, you should have used the
XmlNode.AppendChild() method to create a node. Calling this method on the
LastChild node of the one that called the AppendChild() would
specify the value of the new node. Here is an example:

Notice that the root, videos, has a repetitive child named video. This
video child has its own child named Title. Imagine that you want to
add a new video node that has a child. To do this, first create an empty video node as a child of the root. We learned earlier how to do that:

After creating the new child of the root, initialize the
grand child with the desired name (the name does not have to be one of the
existing names) and a value (which is optional if you do not want the new node to
have a value). Once the new node is ready, add it as the last child of the
root. If this new node has a value, add its XmlText object as the LastChild
of the LastChild of the root. Here is an example of how you would do this:

The root, videos, has a child named video. The video node
has many child nodes. By now, we know how to add a child to the root. We also
saw how to add a grand child with value to the root. To had many (grand)
children to a node, first build the node, add it to the root, then continuously
add the necessary nodes, one at a time, including its name and its optional
value. This would be done as follows: