Another standard associated with XML is XSL
Transformations (XSLT). XSLT allows you to create style sheets that can
extract a portion of a large XML document or transform an XML document
into another type of XML document. An even more popular use of XSLT is
to convert an XML document into an HTML document that can be displayed
in a browser.
NOTE
eXtensible Stylesheet Language (XSL) is a family
of standards for searching, formatting, and transforming XML documents.
XSLT is the specific standard that deals with the transformation step.
XSLT is easy to use from the point of view of the
.NET class library. All you need to understand is how to create an
XslCompiledTransform object (found in the System.Xml.Xsl namespace). You
use its Load() method to specify a style sheet and its Transform()
method to output the result to a file or stream:
' Define the file paths this code uses. The XSLT file and the
' XML source file already exist, but the XML result file
' will be created by this code.
Dim xsltFile As String = Path.Combine(Request.PhysicalApplicationPath, _
"App_Data\SuperProProductList.xsl")
Dim xmlSourceFile As String = Path.Combine(Request.PhysicalApplicationPath, _
"App_Data\SuperProProductList.xml")
Dim xmlResultFile As String = Path.Combine(Request.PhysicalApplicationPath, _
"App_Data\TransformedFile.xml")
' Load the XSLT style sheet.
Dim transformer As New XslCompiledTransform()
transformer.Load(xsltFile)
' Create a transformed XML file.
' SuperProProductList.xml is the starting point.
transformer.Transform(xmlSourceFile, xmlResultFile)
However, this doesn't spare you from needing to learn
the XSLT syntax. Once again, the intricacies of XSLT aren't directly
related to core ASP.NET programming. To get started with XSLT, however, it helps to review a
simple style sheet example. The following example shows an XSLT style
sheet that transforms the no-namespace version of the
SuperProProductList document into a formatted HTML table:
<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0" >
<xsl:template match="SuperProProductList">
<html>
<body>
<table border="1">
<xsl:apply-templates select="Product"/>
</table>
</body>
</html>
</xsl:template>
<xsl:template match="Product">
<tr>
<td><xsl:value-of select="@ID"/></td>
<td><xsl:value-of select="@Name"/></td>
<td><xsl:value-of select="Price"/></td>
</tr>
</xsl:template>
</xsl:stylesheet>
Every XSLT document has a root xsl:stylesheet
element. The style sheet can contain one or more templates (the sample
file SuperProProductList.xslt has two). In this example, the first
template searches for the root SuperProProductList element. When it
finds it, it outputs the tags necessary to start an HTML table and then
uses the xsl:apply-templates command to branch off and perform
processing for any contained Product elements.
<xsl:template match="SuperProProductList">
<html>
<body>
<table border="1">
<xsl:apply-templates select="Product"/>
When that process is complete, the HTML tags for the end of the table will be written:
</table>
</body>
</html>
</xsl:template>
When processing each <Product> element, the
value from the nested ID attribute, Name attribute, and <Price>
element is extracted and written to the output using the xsl:value-of
command. The at sign (@) indicates that the value is being extracted
from an attribute, not a subelement. Every piece of information is
written inside a table row.
<xsl:template match="Product">
<tr>
<td><xsl:value-of select="@ID"/></td>
<td><xsl:value-of select="@Name"/></td>
<td><xsl:value-of select="Price"/></td>
</tr>
</xsl:template>
For more advanced formatting, you could use additional HTML elements to format some text in bold or italics.
The final result of this process is the HTML file shown here:
<html>
<body>
<table border="1">
<tr>
<td>1</td>
<td>Chair</td>
<td>49.33</td>
</tr>
<tr>
<td>2</td>
<td>Car</td>
<td>43398.55</td>
</tr>
<tr>
<td>3</td>
<td>Fresh Fruit Basket</td>
<td>49.99</td>
</tr>
</table>
</body>
</html>
In the next section, you'll look at how this output appears in an Internet browser.
Generally speaking, if you aren't sure you need XSLT,
you probably don't. The .NET Framework provides a rich set of tools for
searching and manipulating XML files using objects and code, which is
the best approach for small-scale XML use.
1. The Xml Web Control
If you use an XLST style sheet such as the one
demonstrated in the previous example, you might wonder what your code
should do with the generated HTML. You could try to write it directly to
the browser or save it to the hard drive, but these approaches are
awkward, especially if you want to display the generated HTML inside a
normal ASP.NET web page that contains other controls. The
XslCompiledTransform object just converts XML files—it doesn't provide
any way to insert the output into your web page.
ASP.NET includes an Xml web control that fills the
gap and can display XML content. You can specify the XML content for
this control in several ways. For example, you can assign a string
containing the XML content to the DocumentContent property, or you can
specify a string that refers to an XML file using the DocumentSource
property.
' Display the information from an XML file in the Xml control.
XmlProducts.DocumentSource = Path.Combine(Request.PhysicalApplicationPath, __
"App_Data\SuperProProductList.xml")
If you assign the SuperProProductList.xml file to the
Xml control, you're likely to be disappointed. The result is just a
string of the inner text (the price for each product), bunched together
without a space (see Figure 1).
