Joshi_09973C04.

fm Page 100 Monday, June 9, 2008 9:13 AM

100 CH APT ER 4 ■ AC CE SSI NG XM L DO C UMENT S BY USI NG TH E XPAT H DA TA MO D EL

Selecting Nodes
This chapter began with a brief overview of XPath and its vocabulary, including terms such as
axis, node test, predicate, and function. You might be wondering where they come into the pic-
ture. It’s time now to see those features in action.
To test various XPath expressions, we will create a simple application that looks like the
one shown in Figure 4-3.

Figure 4-3. Executing XPath expressions

The application consists of a text box positioned at the top to enter XPath expressions.
After you click the Execute button, the given expression is executed and its results are displayed
in another text box at the bottom. The label at the bottom displays the total number of rows
returned by the expression. Listing 4-3 shows the Click event handler of the Execute button.

Listing 4-3. Using the Select() Method

private void button1_Click(object sender, EventArgs e)

{
XPathDocument doc =
new XPathDocument(Application.StartupPath + @"\employees.xml");
XPathNavigator navigator = doc.CreateNavigator();
XPathNodeIterator iterator = navigator.Select(textBox1.Text);
try
{
label3.Text = "The expressions returned " + iterator.Count + " nodes";
if (iterator.Count > 0)
{
while (iterator.MoveNext())
Joshi_09973C04.fm Page 101 Monday, June 9, 2008 9:13 AM

CHAPTER 4 ■ AC CES SING XML DOCUM ENTS BY USING THE XPATH DA TA MODEL 101

{
textBox2.Text = iterator.Current.OuterXml;
}
}
else
{
textBox2.Text = "No results";
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}

The code creates an instance of XPathDocument by passing the path of the Employees.xml file.
Then an XPathNavigator is obtained by using the CreateNavigator() method of XPathDocument.
The code then calls the Select() method of XPathNavigator, which accepts an XPath expression
and returns an instance of XPathNodeIterator.
The XPathNodeIterator class allows you to iterate through the returned nodes and has a
number of properties and methods to assist you. To start with, the Count property tells you how
many nodes were selected by the Select() method. After you are satisfied that there were some
results, you can iterate through the selected nodes by using the MoveNext() method. On each
node, you then use the Current property to give you a reference to the XPathNavigator that
is positioned at the current node. You can then call any of the methods and properties of
XPathNavigator.
In our example, we simply display the OuterXml property of the underlying XPathNavigator in
a text box. Though not used in our example, the CurrentPosition property of XPathNodeIterator
returns the current index of the node being accessed.
Now let’s try some XPath expressions by using our application. Some XPath expressions
relevant to our XML document (Employees.xml) are given in Table 4-6.

Table 4-6. Examples of XPath Expressions Try to execute these XPath Expressions.

Purpose Expression
To select an employee whose employee employees/employee[@employeeid=1]
ID is 1
To select the employee whose first name employees/employee[firstname/text()='Andrew']
is Andrew
To select the last employee from the employees/employee[last()]
document
To select the employee whose index is 2 employees/employee[position()=2]
To select an employee whose name employees/employee[contains(firstname,'Nancy')]
contains Nancy
To select the name of the first employee employees/employee/firstname[text()]
Joshi_09973C04.fm Page 110 Monday, June 9, 2008 9:13 AM

110 CH APT ER 4 ■ AC CE SSI NG XM L DO C UMENT S BY USI NG TH E XPAT H DA TA MO D EL

Getting an XmlWriter from XPathNavigator

Just as you can create an XmlReader from XPathNavigator, you can also create an XmlWriter
from it. This is useful in situations where you want to write selected nodes from XPathNavigator
to a file or stream. XPathNavigator provides a method called WriteSubtree() that accepts an
XmlWriter and writes the current node to it.
To illustrate the use of this technique, you need to develop an application like the one
shown in Figure 4-9.

Figure 4-9. Obtaining an XmlWriter from XPathNavigator

The application consists of two text boxes: one to accept the employee ID to be extracted,
and the other to specify a file path where the extracted employee details are stored.
Listing 4-10 shows the Click event handler of the Write button.

Listing 4-10. Calling the WriteSubtree() Method

private void button1_Click(object sender, EventArgs e)

{
XPathDocument doc =
new XPathDocument(Application.StartupPath + @"\employees.xml");
XPathNavigator navigator = doc.CreateNavigator();
navigator.MoveToRoot();
navigator.MoveToFirstChild();

while (navigator.MoveToNext())
{
navigator.MoveToFirstChild();

do
{
string id = navigator.GetAttribute("employeeid", "");
if (id == textBox1.Text)
Joshi_09973C04.fm Page 111 Monday, June 9, 2008 9:13 AM

CHAPTER 4 ■ AC CES SING XML DOCUM ENTS BY USING THE XPATH DA TA MODEL 111

{
XmlTextWriter writer = new XmlTextWriter(textBox2.Text, null);
navigator.WriteSubtree(writer);
writer.Close();
if (MessageBox.Show("Do you want to see the file?",
"Question",
MessageBoxButtons.YesNo) == DialogResult.Yes)
{
System.Diagnostics.Process.Start(textBox2.Text);
}
}
}
while (navigator.MoveToNext());
}
}

The code creates an instance of XPathDocument and XPathNavigator as before. It then

starts navigating the document and finds the matching <employee> node. After the matching
employee is found, the code creates an instance of XmlTextWriter (recollect that XmlTextWriter
inherits from the XmlWriter abstract class), supplying the file path entered in the text box to the
constructor. Though our example writes the data to a disk file, any writable stream can be used.
To write the matching employee to XmlTextWriter, the code calls the WriteSubtree()
method of XPathNavigator. The WriteSubtree() method accepts any class derived from the
XmlWriter base class and writes the contents of the current node to it. In our example, it will be
the <employee> node and its child nodes. After the writing is over, the XmlTextWriter is closed
by calling its Close() method. The code then asks the user whether to open the resultant file, as
shown in Figure 4-10.

Figure 4-10. Prompting the user to open the resultant file

If the user clicks Yes, the resultant XML file is opened in the browser. Note the use of the
Process class from the System.Diagnostics namespace. The Start() method of this class
accepts a filename and opens it in its associated application. Figure 4-11 shows a sample out-
put document with the <employee> subtree extracted.
Joshi_09973C04.fm Page 112 Monday, June 9, 2008 9:13 AM

112 CH APT ER 4 ■ AC CE SSI NG XM L DO C UMENT S BY USI NG TH E XPAT H DA TA MO D EL

Figure 4-11. Resultant XML document

Editing XML Documents with the XPathNavigator Class

Up until now, we have used XPathNavigator to navigate and read values from the underlying
XML document. However, it is possible to modify the underlying document also, though the
XPathNavigator must be obtained from the XmlDocument class to do so. XPathNavigator
instances obtained from XPathDocument are read-only and hence cannot be used for editing.
You can check whether an instance of XPathNavigator is editable by using its CanEdit property,
which returns true if the instance is editable, and false otherwise.
To see how an XML document can be modified with the help of XPathNavigator, you need
to develop an application like the one shown in Figure 4-12.

Figure 4-12. Modifying an XML document by using XPathNavigator

The application consists of text boxes to supply values for employee ID, first name, last
name, home phone, and notes. There are four buttons for adding a new employee, modifying
an existing employee, deleting an existing employee, and saving the changed document,
Joshi_09973C04.fm Page 113 Monday, June 9, 2008 9:13 AM

CHAPTER 4 ■ AC CES SING XML DOCUM ENTS BY USING THE XPATH DA TA MODEL 113

respectively. When you enter an employee ID and click the Show button, the details of that
employee are displayed in the remaining text boxes. You can change the details as per your
requirements and click the Add, Update, or Delete buttons to add, update, or delete an
employee, respectively. To save the modified document, you need to click the Save button.
In the source code of the application, you will find two form variables declared as shown
Listing 4-11.

Listing 4-11. Declaring XmlDocument and XPathNavigator

XmlDocument doc = new XmlDocument();

XPathNavigator navigator = null;

The Employees.xml file is loaded into this XmlDocument, and an XPathNavigator is obtained
from it. This code goes in the Load event of the form and is shown in Listing 4-12.

Listing 4-12. Creating XPathNavigator

private void Form1_Load(object sender, EventArgs e)

{
doc.Load(Application.StartupPath + @"\employees.xml");
navigator = doc.CreateNavigator();
}

When the user enters an employee ID and clicks the Show button, the details of that
employee need to be displayed in the remaining text boxes. The Click event handler of the
Show button does this job, as shown in Listing 4-13.

Listing 4-13. Retrieving Details of an Employee

private void button1_Click(object sender, EventArgs e)

{
navigator.MoveToRoot();
navigator.MoveToFirstChild();

while (navigator.MoveToNext())
{
navigator.MoveToFirstChild();

do
{
string id = navigator.GetAttribute("employeeid", "");
if (id == textBox1.Text)
{
navigator.MoveToFirstChild();
Joshi_09973C04.fm Page 114 Monday, June 9, 2008 9:13 AM

114 CH APT ER 4 ■ AC CE SSI NG XM L DO C UMENT S BY USI NG TH E XPAT H DA TA MO D EL

do
{
switch (navigator.Name)
{
case "firstname":
textBox2.Text = navigator.Value;
break;
case "lastname":
textBox3.Text = navigator.Value;
break;
case "homephone":
textBox4.Text = navigator.Value;
break;
case "notes":
textBox5.Text = navigator.Value;
break;
}
}
while (navigator.MoveToNext());

navigator.MoveToParent();
}
}
while (navigator.MoveToNext());
}
}

The code should be familiar to you, because we used something similar in previous exam-
ples. The code loops through all the <employee> nodes and finds the one that matches the
supplied employee ID. The values of various child nodes such as <firstname>, <lastname>,
<homephone>, and <notes> are displayed in the respective text boxes by using the Value property
of XPathNavigator.

Adding Nodes
To add new nodes to the document, the XPathNavigator class provides a method called
AppendChild(). The AppendChild() method returns an instance of XmlWriter, and by using
this XmlWriter you can write additional nodes to the document. The newly written nodes are
added as child nodes of the current node. Listing 4-14 shows how this is accomplished.
Joshi_09973C04.fm Page 115 Monday, June 9, 2008 9:13 AM

CHAPTER 4 ■ AC CES SING XML DOCUM ENTS BY USING THE XPATH DA TA MODEL 115

Listing 4-14. Appending New Nodes

private void button2_Click(object sender, EventArgs e)

{
navigator.MoveToRoot();
navigator.MoveToFirstChild();

while (navigator.MoveToNext())
{
XmlWriter writer = navigator.AppendChild();
writer.WriteStartElement("employee");
writer.WriteAttributeString("employeeid", textBox1.Text);
writer.WriteElementString("firstname", textBox2.Text);
writer.WriteElementString("lastname", textBox3.Text);
writer.WriteElementString("homephone", textBox4.Text);
writer.WriteElementString("notes", textBox5.Text);
writer.WriteEndElement();
writer.Close();
}
}

The code first navigates to the <employees> node. This is where we want to add a new
<employee> child node. Then it calls the AppendChild() method of the XPathNavigator. The
returned XmlWriter is used to add a new <employee> node with an employeeid attribute.
The child nodes of the <employee> node (<firstname>, <lastname>, <homephone>, and <notes>)
are also added. The methods such as WriteStartElement()and WriteEndElement() should
already be familiar to you from Chapter 3.

■Note There are a few other overloads of the AppendChild() method. For example, one overloaded
method accepts the complete XML markup fragment for the new node and appends it to the current node.
However, the one that we used is more flexible.

Modifying Nodes
To modify contents of any of the nodes, the XPathNavigator class provides a method called
SetValue(), which accepts the new value and assigns it to the current node. Listing 4-15 shows
how this method can be used.
Joshi_09973C04.fm Page 116 Monday, June 9, 2008 9:13 AM

116 CH APT ER 4 ■ AC CE SSI NG XM L DO C UMENT S BY USI NG TH E XPAT H DA TA MO D EL

Listing 4-15. Modifying Content

private void button3_Click(object sender, EventArgs e)

{
navigator.MoveToRoot();
navigator.MoveToFirstChild();

while (navigator.MoveToNext())
{
navigator.MoveToFirstChild();

do
{
string id = navigator.GetAttribute("employeeid", "");
if (id == textBox1.Text)
{
navigator.MoveToFirstChild();

do
{
switch (navigator.Name)
{
case "firstname":
navigator.SetValue(textBox2.Text);
break;
case "lastname":
navigator.SetValue(textBox3.Text);
break;
case "homephone":
navigator.SetValue(textBox4.Text);
break;
case "notes":
navigator.SetValue(textBox5.Text);
break;
}
}
while (navigator.MoveToNext());

navigator.MoveToParent();
}
}
while (navigator.MoveToNext());
}
}
Joshi_09973C04.fm Page 117 Monday, June 9, 2008 9:13 AM

CHAPTER 4 ■ AC CES SING XML DOCUM ENTS BY USING THE XPATH DA TA MODEL 117

As before, the code finds out the <employee> node that is to be updated. The switch state-
ment checks the Name property of XPathNavigator for the required node names (firstname,
lastname, homephone, and notes). Inside each case, the SetValue() method is called on the nav-
igator by passing the new value from the appropriate text box.

Deleting Nodes
Deleting a node is fairly simple. The DeleteSelf() method of XPathNavigator deletes the cur-
rent node. After the node is successfully deleted, the cursor is moved to the parent node of the
deleted node. Listing 4-16 shows the usage of DeleteSelf().

Listing 4-16. Deleting a Node

private void button4_Click(object sender, EventArgs e)

{
navigator.MoveToRoot();
navigator.MoveToFirstChild();

while (navigator.MoveToNext())
{
navigator.MoveToFirstChild();

do
{
string id = navigator.GetAttribute("employeeid", "");
if (id == textBox1.Text)
{
navigator.DeleteSelf();
}
}
while (navigator.MoveToNext());
}
}

As in the previous case, the code looks for a specific <employee> node. After it finds the
node, it calls the DeleteSelf() method on the navigator.

Saving Changes
It is important to remember that while making any modifications via XPathNavigator, the
changes are not saved automatically to disk. The changes affect only the DOM tree loaded in
memory, so you need to save the underlying document by calling the Save() method of the
XmlDocument class. This is illustrated in Listing 4-17.
Joshi_09973C04.fm Page 118 Monday, June 9, 2008 9:13 AM

118 CH APT ER 4 ■ AC CE SSI NG XM L DO C UMENT S BY USI NG TH E XPAT H DA TA MO D EL

Listing 4-17. Saving the Document

private void button5_Click(object sender, EventArgs e)

{
doc.Save(Application.StartupPath + @"\employees.xml");
}

Summary
In this chapter, you learned what XPath is and how to use XPath expressions in the .NET
Framework. We covered in detail the XPathNavigator class, which represents the XPath data
model of the .NET Framework. The XPathNavigator class can be constructed from either of the
XPathDocument or XmlDocument classes. The XPathNavigator returned from XPathDocument is
read-only, whereas that returned from XmlDocument is editable. You also learned how to select
nodes from the XML document by using XPath expressions in string form as well as in com-
piled form.
Joshi_09973C06.fm Page 172 Wednesday, June 4, 2008 8:28 AM

172 CH APT ER 6 ■ T RANS FO RMI NG XM L WI T H XS LT

• A stream (for example, MemoryStream or FileStream)

• A class inheriting from the TextWriter abstract class (for example, StringWriter or
StreamWriter)

Performing Transformations by Using XslCompiledTransform

In this section, you will learn to use the XslCompiledTransform class. You will develop an appli-
cation like the one shown in Figure 6-5.

Figure 6-5. Application to apply XSLT transformations

As shown in Figure 6-5, the application consists of three text boxes to accept the source
XML filename, the XSLT style sheet filename, and the destination filename, respectively. Clicking
the Transform button performs the transformation, and the output of the transformation is
stored in a file specified by the Destination File text box. You can also open the destination file
after a successful transformation by selecting the check box. Listing 6-9 shows the Click event
handler of the Transform button.

Listing 6-9. Using the XslCompiledTransform Class

private void button1_Click(object sender, EventArgs e)

{
if(Path.GetExtension(textBox3.Text)!=".htm" &&
Path.GetExtension(textBox3.Text)!=".html")
{
MessageBox.Show("File extension must be .htm or .html");
return;
}
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(textBox2.Text);
xslt.Transform(textBox1.Text, textBox3.Text);
if (checkBox1.Checked)
{
System.Diagnostics.Process.Start(textBox3.Text);
}
}
Joshi_09973C06.fm Page 173 Wednesday, June 4, 2008 8:28 AM

C HA PTER 6 ■ TRAN SFORM IN G XML WITH XSLT 173

Make sure to import the System.Xml.Xsl namespace because the XslCompiledTransform

class resides in it. Notice the code marked in bold. To start with, the code creates an instance of
the XslCompiledTransform class. The Load() method of XslCompiledTransform accepts the path
of the XSLT style sheet to be applied and loads it for transformation. However, it is the Transform()
method that actually performs the transformation by applying the style sheet loaded by using
the Load() method. There are several overloads of the Transform() method; the one that we
have used accepts two string parameters. The first parameter is the path of the source XML
document, and the second parameter is the path of the destination document. After the trans-
formation, the resultant output is saved in the file specified by the second parameter of the
Transform() method. Finally, the file is opened with the associated application by using the
Start() method of the Process class.
To test the application, you can use the Employees.xml and Employees.xslt files (see
Listing 6-2) that we used earlier in this chapter. Note that Employees.xml no longer needs to
have the xml-stylesheet processing instruction. When you supply all the filenames and click
the Transform button, you should see the Employees.html file generated in the specified folder.
The Employees.html file will have HTML markup as shown in Listing 6-10.

Listing 6-10. Output After Applying the Style Sheet

<html>
<body>
<h1>Employee Listing</h1>
<table border="1">
<tr>
<th>Employee ID</th>
<th>First Name</th>
<th>Last Name</th>
<th>Home Phone</th>
<th>Notes</th>
</tr>
<tr>
<td>1</td>
<td>Nancy</td>
<td>Davolio</td>
<td>(206) 555-9857</td>
<td>
includes a BA in psychology from Colorado State University in 1970.
She also completed "The Art of the Cold Call." Nancy is a member
of Toastmasters International.
</td>
</tr>
<tr>
<td>2</td>
<td>Andrew</td>
<td>Fuller</td>
<td>(206) 555-9482</td>
Joshi_09973C06.fm Page 174 Wednesday, June 4, 2008 8:28 AM

174 CH APT ER 6 ■ T RANS FO RMI NG XM L WI T H XS LT

<td>
Andrew received his BTS commercial in 1974 and a Ph.D. in international
marketing from the University of Dallas in 1981. He is fluent in French
and Italian and reads German. He joined the company as a sales
representative, was promoted to sales manager in January 1992 and to vice
president of sales in March 1993. Andrew is a member of the Sales
Management Roundtable, the Seattle Chamber of Commerce, and the Pacific
Rim Importers Association.
</td>
</tr>
<tr>
<td>3</td>
<td>Janet</td>
<td>Leverling</td>
<td>(206) 555-3412</td>
<td>
Janet has a BS degree in chemistry from Boston College (1984).
She has also completed a certificate program in food retailing management.
Janet was hired as a sales associate in 1991 and promoted to sales
representative in February 1992.
</td>
</tr>
</table>
</body>
</html>

As you can see, the source XML markup is transformed into HTML markup as specified in
the style sheet.

■Note In our example, we converted XML markup into HTML markup. However, you can easily use the
XslCompiledTransform class to transform source XML into another XML representation.

Passing Arguments to a Transformation

In Listing 6-5, you created a style sheet that transforms details of a single employee, Nancy, by
using the <xsl:if> element. The problem with our XSLT is that we hard-coded the name Nancy
in the style sheet. In real-world cases, this name will probably come from a user interface element.
Thus it becomes necessary that the employee’s first name be accepted as a parameter in the
XSLT rather than a fixed value.
Fortunately, XSLT allows you to declare parameters in your style sheet. These parameters
can then be supplied at run time from your application. A collection of these parameters is
represented by the XsltArgumentList class, and you can add individual parameters to this
collection. To illustrate the use of XsltArgumentList, we will develop an application like the one
shown in Figure 6-6.
Joshi_09973C06.fm Page 175 Wednesday, June 4, 2008 8:28 AM

C HA PTER 6 ■ TRAN SFORM IN G XML WITH XSLT 175

Figure 6-6. Application for passing parameters to the XSLT style sheet

The application consists of a single text box for accepting the first name of the employee.
Clicking the Transform button applies the style sheet and stores the resultant output in an
HTML file. Our XML file remains the same (Employees.xml). However, you need to modify the
style sheet from Listing 6-5 as shown in Listing 6-11.

Listing 6-11. XSLT Style Sheet with Parameter

<?xml version="1.0" encoding="UTF-8" ?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:param name="firstname"/>
<xsl:template match="/">
<html>
<body>
<h1>Employee Listing</h1>
<table border="1">
<tr>
<th>Employee ID</th>
<th>First Name</th>
<th>Last Name</th>
<th>Home Phone</th>
<th>Notes</th>
</tr>
<xsl:for-each select="employees/employee">
<xsl:if test="firstname[text()=$firstname]">
<tr>
<td>
<xsl:value-of select="@employeeid"/>
</td>
<td>
<xsl:value-of select="firstname"/>
</td>
<td>
<xsl:value-of select="lastname"/>
</td>
<td>
<xsl:value-of select="homephone"/>
</td>
Joshi_09973C06.fm Page 176 Wednesday, June 4, 2008 8:28 AM

176 CH APT ER 6 ■ T RANS FO RMI NG XM L WI T H XS LT

<td>
<xsl:value-of select="notes"/>
</td>
</tr>
</xsl:if>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

Notice the style sheet markup displayed in bold. At the top of the style sheet, we have declared
a parameter by using the <xsl:param> element. The name attribute of the <xsl:param> element
indicates the name of the parameter (firstname in our example). To use this parameter further
in the XSLT, you prefix it with the dollar symbol ($). Notice the firstname parameter of the <xsl:if>
element. Listing 6-12 shows the code that passes this parameter value at the time of actual
transformation.

Listing 6-12. Using the XsltArgumentList Class to Pass XSLT Parameters

private void button1_Click(object sender, EventArgs e)

{
string sourcefile=Application.StartupPath + @"\employees.xml";
string xsltfile=Application.StartupPath + @"\employees.xslt";
string destinationfile=Application.StartupPath + @"\employees.html";

FileStream stream = new FileStream(destinationfile, FileMode.Create);

XslCompiledTransform xslt = new XslCompiledTransform();

xslt.Load(xsltfile);
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("firstname", "", textBox1.Text);
xslt.Transform(sourcefile, arguments, stream);
stream.Close();
if (checkBox1.Checked)
{
System.Diagnostics.Process.Start(destinationfile);
}
}

The code declares three string variables to store the paths of the source XML file, the XSLT
style sheet file, and the destination HTML file, respectively. Then the code creates a FileStream
object for writing to the destination HTML file. This FileStream object will be passed to the
Transform() method later.
A new instance of the XslCompiledTransform class is then created, and the Load() method
loads the XSLT style sheet. Then comes the important part. The code creates an instance of the
XsltArgumentList class and adds a parameter to it by using its AddParam() method, which takes
Joshi_09973C06.fm Page 177 Wednesday, June 4, 2008 8:28 AM

C HA PTER 6 ■ TRAN SFORM IN G XML WITH XSLT 177

three parameters: the name of the parameter, the namespace if any, and the parameter value.
Then, the Transform() method of XslCompiledTransform is called by passing the XsltArgumentList
object that we just created. This time, we pass the source filename, the parameter list, and a
stream to which the resultant output will be written. In our case, this stream points to the
Employees.html file. After the transformation is over, the stream is closed, and the newly gener-
ated HTML file is shown to the user.
If you run the application and supply Nancy as the parameter value, the resultant HTML
file will look like Listing 6-13.

Listing 6-13. Output After Passing the Parameter

<html>
<body>
<h1>Employee Listing</h1>
<table border="1">
<tr>
<th>Employee ID</th>
<th>First Name</th>
<th>Last Name</th>
<th>Home Phone</th>
<th>Notes</th>
</tr>
<tr>
<td>1</td>
<td>Nancy</td>
<td>Davolio</td>
<td>(206) 555-9857</td>
<td>
includes a BA in psychology from Colorado State University in 1970.
She also completed "The Art of the Cold Call." Nancy is a member of
Toastmasters International.
</td>
</tr>
</table>
</body>
</html>

As you can see, only one record is transformed, indicating that the output was indeed
filtered based on the parameter value.

Using Script Blocks in an XSLT Style Sheet

Though XSLT offers a few programming constructions and built-in functions, it is not a fully
fledged programming language in itself. Sometimes, you may need to perform an operation
that is beyond the capabilities of XSLT. For example, you may want to connect with a SQL
Server database and fetch some data that is used further by the style sheet, or you may need to
perform disk IO. To cater to such needs, XslCompiledTransform allows you to embed scripts
within your XSLT style sheets. After the style sheet is loaded, the embedded code is compiled
into Microsoft Intermediate Language (MSIL) and executed at run time.