CodeProject: XSL Transformations in .NET 2.0. Free source code and programming help

Report Article

Discuss

Send to a friend

39 votes for this Article.

Popularity: 5.70 Rating: 3.58 out of 5

Download demo project - 6.82 Kb

Introduction

The core XSLT related classes are contained in the System.Xml.Xsl namespace, and are as follows:

XslCompiledTransform - Core class that acts as the XSLT processor in .NET Framework 2.0. Used to transform XML data into other structures such as HTML, text, or another XML.
XsltArgumentList - Allows you to pass a variable number of parameters and extension objects to an XSL style sheet.
XsltCompileException - This exception is thrown by the Load() method when an error occurs in the XSL style sheet.
XsltException - This exception is thrown if an exception occurs during the processing of an XSL style sheet.

Note that the XslTransform class used for XSL transformations in .NET Framework 1.x is now obsolete, and replaced by the new XslCompiledTransform class. In addition to better performance, the XslCompiledTransform also provides better support for the XSLT 1.0 specification. Starting from .NET Framework 2.0, the recommended approach to performing XSL transformations is through the XslCompiledTransform class. Because of the similarity in design to the XslTransform class, you can easily migrate your existing code to utilize the XslCompiledTransform class.

Before looking at the code sample, let us have a brief look at the important methods of the XslCompiledTransform class that will be required.

Load - This method has several overloads, and it provides for loading of an XSL stylesheet into an XslCompiledTransform object from any one of the following resources: a string that specifies the URL, from an XmlReader object, or from an XPathNavigator object, and so on.
Transform - Allows you to transform the XML data into a specified format using the stylesheet that is already loaded (using the Load method).

Implementation

Now that you have had an overview of the XSLT classes and the methods, let us start by looking at a simple XSL transformation example. For the purposes of this article, you will retrieve the data from AdventureWorks database in the form of XML data, and transform it using XSLT to render the data as HTML in the browser.

Simple XSL Transformation

In this example, you will create a simple ASP.NET page that retrieves categories data from the DB as an XML stream and transforms that into HTML so that it can be displayed in the browser. Before looking at the ASP.NET page, let us look at the XSL file named Category.xsl.

<?xml version="1.0" ?>
<xsl:stylesheet version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="html" />
  <xsl:template match="/">
  <HTML>
    <HEAD>
      <TITLE>Simple XSLT Transformation</TITLE>
    </HEAD>
    <BODY>
      <H2>Simple XSLT Transformation</H2>
      <table border="1" cellSpacing="1" cellPadding="1">
        <center>
          <xsl:for-each select="//Categories">
          <!-- Each record on a seperate row -->
            <xsl:element name="tr">
              <xsl:element name="td">
                <xsl:value-of select="ProductSubcategoryID" />
              </xsl:element>
              <xsl:element name="td">
                <xsl:value-of select="Name" />
              </xsl:element>
              <xsl:element name="td">
                <xsl:attribute name="align">center</xsl:attribute>
                <xsl:value-of select="ModifiedDate" />
              </xsl:element>
            </xsl:element>
          </xsl:for-each>
        </center>
      </table>
    </BODY>
  </HTML>
  </xsl:template>
</xsl:stylesheet>

The XSL file basically contains the logic to loop through all the elements contained in the Categories element. The code for the ASP.NET page is as follows:

<%@ Page Language="C#" %>
<%@ Import Namespace="System.Data.SqlClient" %>
<%@ Import Namespace="System.Xml" %>
<%@ Import Namespace="System.Xml.Xsl" %>
<%@ Import Namespace="System.Xml.XPath" %>
<%@ Import Namespace="System.Web.Configuration" %>

<script runat="server">
void Page_Load(object sender, System.EventArgs e)
{
  string connString = WebConfigurationManager.ConnectionStrings
    ["adventureWorks"].ConnectionString;
  using (SqlConnection connection = new SqlConnection(connString))
  {
    connection.Open();
    SqlCommand command = new SqlCommand
      ("Select * from Production.ProductSubcategory as Categories " +
      " for xml auto,elements", connection);
    XmlReader reader = command.ExecuteXmlReader();
    XPathDocument xpathDoc = new XPathDocument(reader);
    string xslPath = Server.MapPath("App_Data/Category.xsl");
    XslCompiledTransform transform = new XslCompiledTransform();
    transform.Load(xslPath);
    transform.Transform(xpathDoc, null, Response.Output);
  }
}
</script>

In the Page_Load event of the Web form, you retrieve the data (in the form of XML) from the ProductSubcategory table, and then apply an external XSLT stylesheet (named Category.xsl) on the XML data, to emit HTML. You then write this HTML directly onto the client browser. This is accomplished by passing in the Response.Output object to the Transform() method. Note that in the above example, the XPathDocument class is used for loading the XML document, because this class is optimized to provide high-performance XML document processing. If you navigate to the page using the browser, you will see the output below.

Passing Parameters to an XSLT Stylesheet

Similar to the way you pass parameters to a method or a function, you can also pass parameters to an XSLT stylesheet. Passing a parameter to a stylesheet gives you the ability to initialize a globally scoped variable, which is defined as any <xsl:param> that is a child of the <xsl:stylesheet> element. The code shown in bold shows the lines of code where the parameter is declared and then used:

<?xml version="1.0" ?>
<xsl:stylesheet version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="html" />
  <xsl:param name="BackGroundColor" select="Blue" />
  <xsl:template match="/">
  <HTML>
    <HEAD>
      <TITLE>Passing Parameters to an XSLT Style Sheet</TITLE>
    </HEAD>
    <BODY>
      <H2> Passing Parameters to an XSLT Style Sheet</H2>
      <table border="1" cellSpacing="1" cellPadding="1">
        <center>
          <xsl:for-each select="//Categories">
          <!-- Each record on a seperate row -->
            <xsl:element name="tr">
              <xsl:attribute name="bgcolor">
                <xsl:value-of select="$BackGroundColor" />
              </xsl:attribute>
              <xsl:element name="td">
                <xsl:value-of select="ProductSubcategoryID" />
              </xsl:element>
              <xsl:element name="td">
                <xsl:value-of select="Name" />
              </xsl:element>
              <xsl:element name="td">
                <xsl:attribute name="align">center</xsl:attribute>
                <xsl:value-of select="ModifiedDate" />
              </xsl:element>
            </xsl:element>
          </xsl:for-each>
        </center>
      </table>
    </BODY>
  </HTML>
  </xsl:template>
</xsl:stylesheet>

After the declaration of the BackGroundColor parameter, the code then uses the BackGroundColor parameter to specify the background color for the <tr> element in the table.

<xsl:value-of select="$BackGroundColor" />

Although the value of BackGroundColor was hard-coded in the declaration using the < xsl:param> element, ideally it should be passed from the calling ASP.NET page. To accomplish this, you leverage the XsltArgumentList class. Specifically, the AddParam() method of the XsltArgumentList provides this functionality. The XsltArgumentList class is a key class that enables you to create XSLT reusable and maintainable style sheets by providing a mechanism to pass parameters to an XSLT stylesheet.

To the AddParam() method, you supply a qualified name, the namespace URI, and a value. If the parameter value is not a String, Boolean, Number, NodeFragment, or NodeSet, it will be forced to a double or string. The ASP.NET calling page that passes parameters to the stylesheet is shown below:

<%@ Page Language="C#" %>
<%@ Import Namespace="System.Data.SqlClient" %>
<%@ Import Namespace="System.Xml" %>
<%@ Import Namespace="System.Xml.Xsl" %>
<%@ Import Namespace="System.Xml.XPath" %>
<%@ Import Namespace="System.Web.Configuration" %>

<script runat="server">
void Page_Load(object sender, System.EventArgs e)
{
  string connString = WebConfigurationManager.ConnectionStrings
    ["adventureWorks"].ConnectionString;
  using (SqlConnection connection = new SqlConnection(connString))
  {
    connection.Open();
    SqlCommand command = new SqlCommand
      ("Select * from Production.ProductSubCategory as Categories " +
      " for xml auto,elements", connection);
    XmlReader reader = command.ExecuteXmlReader();
    XPathDocument xpathDoc = new XPathDocument(reader);
    string xslPath = Server.MapPath("App_Data/Category.xsl");
    XslCompiledTransform transform = new XslCompiledTransform();
    transform.Load(xslPath);
    XsltArgumentList argsList = new XsltArgumentList();
    string backGroundColor = "Tan";
    //Add the required parameters to the XsltArgumentList object

    argsList.AddParam("BackGroundColor", "", backGroundColor);
    transform.Transform(xpathDoc, argsList, Response.Output);
  }
}
</script>

The above code is very similar to the first example except for the difference that this example uses the XsltArgumentList object. Specifically, you create an instance of the XsltArgumentList object, invoke its AddParam() method to add the BackGroundColor parameter, and finally pass the XsltArgumentList as an argument to the Transform() method of the XslCompiledTransform. With all these enhancements in place, pointing the browser to the URL of the Web page results in the following output wherein all the categories records are displayed with the Tan background color:

Invoking Extension Objects from an XSLT Stylesheet

In addition to allowing you to pass parameters, the XsltArgumentList class also provides you with the ability to associate a class with the namespace URI, using which you can call the methods of a class directly from a stylesheet. The object whose methods are invoked from the stylesheet is called an extension object. For the purposes of this example, let us create an extension object named DateTimeConverter to format the ModifiedDate value to the appropriate format. To this end, let us create the DateTimeConverter class with only one method named ToDateTimeFormat() that formats the input date value based on the supplied format string.

using System;

public class DateTimeConverter
{
  public DateTimeConverter()
  {}

  public string ToDateTimeFormat(string data, string format)
  {
    DateTime date = DateTime.Parse(data);
    return date.ToString(format);
  }
}

Place the DateTimeConverter class in the App_Code folder so that it can then be easily referred to from the ASP.NET page. To be able to invoke the extension object from the XSLT stylesheet, you need to do the following:

Declare an alias for the extension object namespace at the top of the XSLT file
Invoke the method of the extension object using the alias

<?xml version="1.0" ?>
<xsl:stylesheet version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:DateTimeConverter="urn:DateTimeConverter">
  <xsl:output method="html" />
  <xsl:param name="BackGroundColor" select="Blue" />
  <xsl:template match="/">
  <HTML>
    <HEAD>
      <TITLE>Invoking extension objects from an XSLT Style Sheet</TITLE>
    </HEAD>
    <BODY>
      <H2>Invoking extension objects from an XSLT Style Sheet</H2>
      <table border="1" cellSpacing="1" cellPadding="1">
        <center>
          <xsl:for-each select="//Categories">
          <!-- Each record on a seperate row -->
            <xsl:element name="tr">
              <xsl:attribute name="bgcolor">
                <xsl:value-of select="$BackGroundColor" />
              </xsl:attribute>
              <xsl:element name="td">
                <xsl:value-of select="ProductSubcategoryID" />
              </xsl:element>
              <xsl:element name="td">
                <xsl:value-of select="Name" />
              </xsl:element>
              <xsl:element name="td">
                <xsl:attribute name="align">center</xsl:attribute>
                <xsl:value-of select="DateTimeConverter:ToDateTimeFormat
                  (ModifiedDate, 'F')" />
              </xsl:element>
            </xsl:element>
          </xsl:for-each>
        </center>
      </table>
    </BODY>
  </HTML>
  </xsl:template>
</xsl:stylesheet>

As you can see, the adjustments made to the stylesheet are minimal. To the xsl:stylesheet element, you add the attribute xmlns:DateTimeConverter="urn:DateTimeConverter". This is done to associate a namespace URI for our extension object. The following line of code creates the association.

<xsl:stylesheet version="1.0" 
     xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
     xmlns:DateTimeConverter="urn:DateTimeConverter">

Once you have the association between the object and the namespace URI in place, you can then easily invoke the methods of the extension object from the stylesheet as if it is part of the stylesheet.

The following line of code demonstrates this.

<xsl:value-of select="DateTimeConverter:ToDateTimeFormat(ModifiedDate, 'F')" />

In the above line, you invoke the ToDateTimeFormat() method of the DateTimeConverter class, passing to it the ModifiedDate and the desired date format string.

Now that you have had a look at the changes to the style sheet, let us turn our focus to the code required to pass the extension object to the stylesheet so that it can invoke the methods of the extension object.

<%@ Page Language="C#" %>
<%@ Import Namespace="System.Data.SqlClient" %>
<%@ Import Namespace="System.Xml" %>
<%@ Import Namespace="System.Xml.Xsl" %>
<%@ Import Namespace="System.Xml.XPath" %>
<%@ Import Namespace="System.Web.Configuration" %>

<script runat="server">
void Page_Load(object sender, System.EventArgs e)
{
  string connString = WebConfigurationManager.ConnectionStrings
    ["adventureWorks"].ConnectionString;
  using (SqlConnection connection = new SqlConnection(connString))
  {
    connection.Open();
    SqlCommand command = new SqlCommand
      ("Select * from Production.ProductSubCategory as Categories " +
      " for xml auto,elements", connection);
    XmlReader reader = command.ExecuteXmlReader();
    XPathDocument xpathDoc = new XPathDocument(reader);
    string xslPath = Server.MapPath("App_Data/Category.xsl");
    XslCompiledTransform transform = new XslCompiledTransform();
    transform.Load(xslPath);
    XsltArgumentList argsList = new XsltArgumentList();
    string backGroundColor = "Tan";
    //Add the required parameters to the XsltArgumentList object

    argsList.AddParam("BackGroundColor", "", backGroundColor);
    //Create and add the extension object to the XsltArgumentList

    DateTimeConverter converter = new DateTimeConverter();
    argsList.AddExtensionObject("urn:DateTimeConverter", converter);
    transform.Transform(xpathDoc, argsList, Response.Output);
  }
}
</script>

Let us walk through the important lines of the code.

In this line, you create an instance of the BGColor class.

DateTimeConverter converter = new DateTimeConverter();

After you create an instance of the object, the next step would be to add the instantiated object to the XsltArgumentList object.

argsList.AddExtensionObject("urn:DateTimeConverter",converter);

Finally, you pass the instantiated object, along with the rest of the parameters, to the stylesheet, using the following line of code:

transform.Transform(xpathDoc,argsList,Response.Output);

Executing the above code results in the following output:

As you can see from the above output, the ModifiedDate value is appropriately formatted.

Conclusion

In this article, you have seen the following:

How to transform an XML document using an XSLT stylesheet.
How to supply parameters to an XSLT stylesheet using the XsltArgumentList class.
How to invoke methods of an extension object from an XSLT stylesheet.
How to filter a set of nodes using an XPath expression.

Although the application we created was simple in functionality, it should provide a solid foundation for understanding how to create applications using XSLT related classes in the .NET Framework 2.0.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

Karthik R N

Location:

India

Other popular XML articles:

C# and XML Source Code Documentation
Demonstrates how to use C#.NET's XML source documentation to produce professional, indexed and searchable source documentation.
Sending Files in Chunks with MTOM Web Services and .NET 2.0
How to send large files across web services in small chunks using MTOM (WSE 3)
Microsoft Office XML formats ? Defective by design
Case studies why Microsoft Office XML formats are broken
XmlSerializer and 'not expected' Inherited Types
A solution to XmlSerializing inherited types not known until runtime.
Load and save objects to XML using serialization
A C# program to demonstrate loading and saving an object to an XML file using XML serialization encapsulated in a wrapper class.

Article Top

You must Sign In to use this message board.

Msgs 1 to 13 of 13 (Total in Forum: 13) (Refresh)

FirstPrevNext

Subject

Author

Date

worst article

Moh.Shafe3i

2:41 8 Sep '07

please put the name of Original Author Moh. A. Shafei Think deeply be4 write 1 line of code
Sign In·View Thread·PermaLink

Voted 1 for plagarism

cykophysh39

2:14 12 Feb '07

voted your article a 1 Because of the blatant plagarism!! At least you could place in your introduction some credit to the original author! Kind Regards, Gary My Website \|\| My Blog \|\| My Articles
Sign In·View Thread·PermaLink

Who is the real author ?

Rene Langevin

4:08 4 Jul '06

See the same text in www.15seconds.com/issue/060608.htm by Thiru Thangarathinam RLangevin
Sign In·View Thread·PermaLink	5.00/5 (3 votes)

Re: Who is the real author ?

Abishek Bellamkonda

14:49 4 Jul '06

Rene Langevin wrote: See the same text in www.15seconds.com/issue/060608.htm by Thiru Thangarathinam You are true. Heee... heeeee... Abi ( Abishek Bellamkonda ) My Blog: http://abibaby.blogspot.com =(:*
Sign In·View Thread·PermaLink

Re: Who is the real author ?

ph0sph0ruz

5:28 5 Jul '06

Ouch! That's gotta hurt!
Sign In·View Thread·PermaLink

Re: Who is the real author ? [modified]

RahulGeek

14:46 20 Jul '06

Wow. These two articles match verbatim. I don't want to jump to conclusion on who plagiarized who. But it would be great if the author clarifies this matter. Thanks. Rahul -- modified at 19:46 Thursday 20th July, 2006
Sign In·View Thread·PermaLink

Re: Who is the real author ?

Ashley van Gerven

22:53 5 Aug '06

Well since the 15seconds article was posted on 8 June, well before this one, it seems likely this is the copy. "Nothing ever changes by staying the same." - David Brent (BBC's The Office) ~ ScrollingGrid: A cross-browser freeze-header control for the ASP.NET DataGrid
Sign In·View Thread·PermaLink

Re: Who is the real author ?

muttok

4:05 7 Nov '07

True.. Also, if you take a look at the pictures you will se the following: http://www.codeproject.com/soap/XSL_Transformations/060608_03.gif http://www.15seconds.com/graphics/issue/060608_03.gif Both images have the 8 June 2006 timestamp, so this codeproject version have to be a copy.
Sign In·View Thread·PermaLink

Great article

Profox Jase

22:21 3 Jul '06

Hello

Thanks very much for this great article. I have been avoiding XSL for some time now, but knowing that one day I should learn at least a little bit.

Your clear article has helped inspire me - I must learn more of this today, so I can make my code generation tool much better.

Many thanks

Profox Jase
Co-Author, "Cross-Platform .NET Development: Using Mono, Portable.NET, and Microsoft .NET"
(Apress, 2004, ISBN: 1-59059-330-8)
The Book

bad

kimdubakur

23:26 28 Jun '06

this is not working.
Sign In·View Thread·PermaLink	1.00/5 (2 votes)

Re: bad [modified]

DisruptedSinner

22:04 10 Jul '06

In fact, everything in this article works perfectly. If you don't have the adventure works database installed and do not have the connection string set up the same as in the article, it will not work. If you have a proper development machine/environment set up for all of this then everything will work as outlined.

Just by process of elimination, I suspect it's your database and/or development machine that's not set up properly.

~Brad / Disrupted

2.00/5 (1 vote)

C# Classes in XSLT

Mike DiRenzo

9:56 28 Jun '06

Karthik:

Fantastic article. I have a smilar article for incorporating intrinsic .NET classes. I really like the ablity to pass in objects to the XSLT. I have in the past passed in only string data. This technique opens the door to many more possiblities. Thanks.

Here are two more articles fro your review:

http://www.codeproject.com/soap/DynNodeTreeFragConvertXSL.asp[^]

http://www.topxml.com/code/default.asp?p=3&id=v20031014144731[^]

-Mike DiRenzo Cool

"In quiet and silence, the truth is made clear."

Cool leppie 6:01 28 Jun '06

Thanks xacc.ide-0.2.0 preview - Now in 100% C# goodness
Sign In·View Thread·PermaLink	2.00/5 (1 vote)

Last Visit: Friday, July 4, 2008 6:46 PM Last Update:Friday, July 4, 2008 6:46 PM

General News Question Answer Joke Rant Admin