- Community Pick
- Experts Exchange Approved
XML Literals are a great way to handle XML files and the community doesn’t use it as much as it should. An XML Literal is like a String Literal, only instead of starting and ending with with a quote character ("), it begins with (<) and ends with (>). You can use regular XML tags right there in the code!
Introduction
XML Literals allow you to use XML syntax in your code. It’s easy to work with XML files and XML fragments this way, since you have the tags in the code, but it’s also quicker to access information rather than the traditional methods using XmlDocument and XmlElement.
It’s available in the namespace System.Xml.Linq, since the .NET Framework 3.5/Visual Studio 2008 (for Visual Basic Only) it supports most of the Extensible Markup Language (XML) 1.0 specification, and together with Lambda Expressions and/or LINQ, gives you a better experience with XML files. It’s also recognized by the intellisense system, making it very convenient to use. It even does the indenting automatically.
Topics in this article:
- XML Literals
- Read Information
- List Information
- Embedded Expressions
- Modify Nodes
- Inserting Nodes
- Deleting Nodes
- Finally Example (web)
XML Literals
NOTE: Most of the examples use Option Infer On but you can declare the correct variables data type.
The basic concept looks like this:
This will show you a MessageBox, preserving the spaces, tabs and page breaks. Notice that it doesn’t need the line continuation character “_” (which, incidentally, will not even be necessary in Visual Studio 2010 for most of the code).
You can create your XML file in runtime mode. Here’s an example how to achieve that:
The variable bookList is now an XDocument that you can work as an XML file. To save the file on the disk, you just need to use the Save() method:
Read Information
The previous example generates an easy XML file and saves it to disk. To load the file and handle it, you can use the Load() method. This will load the file and show the magazine name, using the Descendants property.
Descendants property allow you to access to the descendant nodes by name, using a triple-dot (...), from a XElement or XDocument object:
This will show in the Immediate Window “MSDN Magazine” because it’s the first name that it found. We can also get the second magazine (in this case), using Lambda Expressions:
This is for “regular” node elements but if you need to show attributes, then you should use the following syntax:
And for the Lambda Expression to filter for a specific value (this will search on the book name and show the author name):
List Information
You have several ways to show information, looping on the values, using LINQ to XML or Lambda Expressions. You can list all the magazines this way:
Next You can also use the Descendants property (...) and simplify the code significantly:
To show the book names you can use the same method, but since you now deal with attributes, you use the “@” to define that you want the attribute, plus the attribute name.
But you can also filter the information before showing it. This example uses LINQ to XML to check all of the books that have a name containing the keyword “Song”.
Embedded Expressions
Embedded expressions are expressions that you can use in the XML code, using the tags
<%= expression %>
much the same wasy as it's done in ASP.NET. You can use them to build or modify the XML file and that makes it really easy to create a file from a DataTable, List(Of T), Dictionary, etc.
Here’s a very straightforward example, using a Func() delegate (Lambda Expression) that adds two values:
The result will be:
<value>250</value>
</test>
If you have another datasource, like a List(Of T), you can list all the values, using embedded expressions, to a XML file:
This will be the result:
<library>
<books>
<book>The Hunger Games</book>
<book>Breaking Dawn</book>
<book>The Last Song</book>
</books>
</library>
Another example of using embedded expressions is using a DataTable. In this case it will create an XML file with the attributes “name” and “author”:
This will be the result:
<library>
<books>
<book name=" The Hunger Games" author="Suzanne Collins" />
<book name=" Breaking Dawn" author="Stephanie Meyer" />
<book name=" The Last Song" author="Nicholas Sparks" />
</books>
</library>
Modify Nodes
To modify any information in a XML file, using XML Literals, you just need to read the file, change the value and then save it to disk.
Here’s an example:
But using this approach, only the first value that is found will be changed. If you need to change a specific value, like you normally do, you need to filter the information first to indicate what value to change:
This will change the name of the author for the book “The Last Song”, from “Nicholas Sparks” to “Jorge Paulino” (that was nice!). But once again, using the Descendants property saves you some code:
Inserting Nodes
To insert a new node into the XML file, you first need to build the new element (XElement) and then add it to the right position. We can do that in two ways:
Or, the easy way:
In this example we can change the values of the attributes dynamically, using embedded expressions like we saw before.
Deleting Nodes
Deleting a node is very similar to the modification method. You can remove all the nodes:
Or remove a specific node:
Finally Example (web)
You can use XML Literals also to read information from the web, like RSS. This example reads my personal blog RSS and filters by the “VB.NET” category (that is defined by the tags). This shows how powerful and easy is to work with XML Literals.
And here's the resulting console output:
Conclusion
XML literals provide several methods to work with XML files. Today you have XML files for everything (reports, configurations, data storage, RSS, etc) and it’s so important to handle it right, quickly and without complications.
This is an English version of some articles I posted a while ago in my blog and I hope this article helps you to become better with XML Literals, and use them more!
by: DanRollins on 2010-04-19 at 16:46:32ID: 13487
Great Article! Got a big Yes vote from me!