If you played with the XML Document Object Model classes to create XML documents from scratch, it will be easy for you to migrate to a brand new set of classes which allows you to create XML elements in a much more natural and easier way. These classes are located inside the Sytem.Linq.Xml namespace. The classic way of loading an XML document is by using the XmlDocument class from the System.Xml namespace.
XmlDocument doc = XmlDocument.Load("myXmlFile.xml");
There is no difference if you are going to use the newer XDocument class.
XDocument doc = XDocument.Load("myXmlFile.xml");
So what makes this new classes have besides from having shorter names compared to their older versions? The answer is functional construction. With functional construction, you don’t need to declare the XML DOM elements one by one. You can simply use the overloaded constructors of each X class to suit your needs. This can be seen clearer by looking at an example.
By using the old System.Xml‘s XML DOM classes, the following code is used to create a simple XML file.
//A new XML Document XmlDocument doc = new XmlDocument(); //Xml Declaration XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0", "utf-8", "yes"); //Attach declaration to the document doc.AppendChild(declaration); //Create a comment XmlComment comment = doc.CreateComment("This is a comment"); //Attach comment to the document doc.AppendChild(comment); //Create root element XmlElement root = doc.CreateElement("Persons"); //Attach the root node to the document doc.AppendChild(root); //Create a Person child element XmlElement person1 = doc.CreateElement("Person"); //Add an attribute name with value John Smith person1.SetAttribute("name", "John Smith"); //Crate Age element XmlElement person1Age = doc.CreateElement("Age"); person1Age.InnerText = "30"; //Create Gender element XmlElement person1Gender = doc.CreateElement("Gender"); person1Gender.InnerText = "Male"; //Attach Age and Gender element to the Person element person1.AppendChild(person1Age); person1.AppendChild(person1Gender); //Attach Person child element to the root Persons element doc.DocumentElement.AppendChild(person1); //Create another Person child element XmlElement person2 = doc.CreateElement("Person"); //Add attribute name with value Mike Folley person2.SetAttribute("name", "Mike Folley"); //Crate Age element XmlElement person2Age = doc.CreateElement("Age"); person2Age.InnerText = "25"; //Create Gender element XmlElement person2Gender = doc.CreateElement("Gender"); person2Gender.InnerText = "Male"; //Attach Age and Gender element to the Person element person2.AppendChild(person2Age); person2.AppendChild(person2Gender); //Attach second Person child element to the root Persons element doc.DocumentElement.AppendChild(person2); //Save the constructed XML into an XML file doc.Save(@"C:\sample1.xml");
Example 1 – Using XML DOM classes to create a file
The above code will produce the followingXML:
<?xml version="1.0" encoding="utf-8" standalone="yes"?> <!--This is a comment--> <Persons> <Person name="John Smith"> <Age>30</Age> <Gender>Male</Gender> </Person> <Person name="Mike Folley"> <Age>25</Age> <Gender>Male</Gender> </Person> </Persons>
Now let’s take a look at using the new LINQ to XML classes to create the very same XML markup.
XDocument doc = new XDocument( new XDeclaration("1.0", "utf-8", "yes"), new XComment("This is a comment"), new XElement("Persons", new XElement("Person", new XAttribute("name", "John Smith"), new XElement("Age", new XText("30")), new XElement("Gender", new XText("Male"))), new XElement("Person", new XAttribute("name", "Mike Folley"), new XElement("Age", new XText("25")), new XElement("Gender", new XText("Male"))))); doc.Save(@"C:\sample2.xml");
Example 2 – Using LINQ to XML classes to create an XML document
As you can see, using the XML DOM classes to construct an XML document requires you to declare each component and attach each element to their proper parents one by one. Using the LINQ to XML classes, you can see the every part of the XML document you will create is instantiated inside the constructor of every class. These method of creating XML markup is called functional construction. Each LINQ to XML class’ constructor accepts arguments that may serve as child elements or values of the element it represents. For example, the XElement has the following overload of its constructor:
XElement(XName name, params object content)
The first parameter accepts the name of the element. You can simply pass a string as the name and it will automatically be converted to an XName instance. The second parameter is special because it allows you to pass any number of different kinds of objects such as an XText, XAttribute, or an XElement that will be a child element of that current XElement. Other LINQ to XML class only accepts one argument such as XComment and XText which both accept a string argument that represents the text they will render.
The following table shows some of the LINQ to XML classes you can use together what part of an XML document they represent.
|XDocument||Represents an XML Document|
|XDeclaration||Represents an XML Declaration|
|XElement||Represents an XML Element|
|XAttribute||Represents an attribute of an XML Element|
|XComment||Represents an comment|
|XText||Represents the inner text of an XML element.|
Figure 1 – LINQ to XML Classes
For example, if you want to create an element named Person with a name attribute of value John Smith, here’s the code to do that.
var personElement = new XElement("Person", new XAttribute("name", "John Smith"));
If you want to add a child element for that person, simply add another argument to the constructor of XElement.
var personElement = new XElement("Person", new XAttribute("name", "John Smith"), new XElement("Age", new XText("30")));
The child argument has a name of Age and the next argument to its constructor is its inner text represented by the XText class. You can also see in Example 2 how every XElement argument was indented. This is to make it look more like the way we indent XML elements. You can already see how the XML output will look like simply by looking at the code.
At the end of Example 2 is a call to the XDocument.Save method. This method allows you to save the constructed XML which is currently in memory, into an external XML file. The method accepts a string argument which represents the file path of the file. If the file does not exist, then it will be created. If the file is already there, it will be overwritten. There are other overloads of this method, but for now, this version is sufficient to save the constructed XML to a file.