We Keep Coding

InnerXML Replace not working with XMLDOCUMENT

I have an XML file with :
<IMG0></IMG0>
<IMG1></IMG1>
<IMG2></IMG2>
It represents up to 10 images.
I try to delete the number for having :
<IMG></IMG>
<IMG></IMG>
<IMG></IMG>
I make :
for (int l = 0; l <= 10; l++)
{
doc.InnerXml.Replace("IMG" + l, "IMG");
}
"doc" is an XMLDocument.
But the node doesn't change.
What can I do ?

By using XSLT and Identity Transform pattern.
The 2nd template will find any XML element that starts with 'IMG' and transform it to just 'IMG' while keeping everyhing else as-is intact.
XML
<?xml version="1.0" encoding="UTF-8"?>
<root>
<Betalningsmottagares_x0020_postnr>401 01</Betalningsmottagares_x0020_postnr>
<Betalningsmottagares_x0020_postort>Göteborg</Betalningsmottagares_x0020_postort>
<IMG0>10</IMG0>
<IMG1>20</IMG1>
<IMG2>30</IMG2>
</root>
XSLT
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" encoding="utf-8" indent="yes" omit-xml-declaration="no"/>
<xsl:strip-space elements="*"/>
<xsl:template match="node() | #*">
<xsl:copy>
<xsl:apply-templates select="node() | #*"/>
</xsl:copy>
</xsl:template>
<xsl:template match="*[starts-with(local-name(), 'IMG')]">
<IMG>
<xsl:value-of select="."/>
</IMG>
<xsl:apply-templates/>
</xsl:template>
</xsl:stylesheet>
Output
<?xml version='1.0' encoding='utf-8' ?>
<root>
<Betalningsmottagares_x0020_postnr>401 01</Betalningsmottagares_x0020_postnr>
<Betalningsmottagares_x0020_postort>Göteborg</Betalningsmottagares_x0020_postort>
<IMG>10</IMG>10
<IMG>20</IMG>20
<IMG>30</IMG>30
</root>

Merge two xml file nodes with same node value

I want to merge nodes of two xml files in C# or XSLT. If the Path value of Method nodes of two different xml files are same. The two Method nodes should be merged as one in the output.
Example:
File1:
<Methods>
<Method>
<ID>1234</ID>
<Name>manager</Name>
<Path>path1</Path>
</Method>
</Methods>
File2:
<Methods>
<Method>
<Path>path1</Path>
<Description>text</Description>
</Method>
</Methods>
Output:
<Methods>
<Method>
<ID>1234</ID>
<Name>manager</Name>
<Description>text</Description>
</Method>
</Methods>

Try it this way?
XSLT 1.0
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>
<xsl:strip-space elements="*"/>
<xsl:variable name="file2" select="document('file2.xml')" />
<xsl:key name="method-by-path" match="Method" use="Path" />
<!-- identity transform -->
<xsl:template match="#*|node()">
<xsl:copy>
<xsl:apply-templates select="#*|node()"/>
</xsl:copy>
</xsl:template>
<xsl:template match="Method">
<xsl:copy>
<xsl:apply-templates select="#*|node()"/>
<xsl:variable name="path" select="Path"/>
<!-- switch context to the other file -->
<xsl:for-each select="$file2">
<xsl:copy-of select="key('method-by-path', $path)/*[not(self::Path)]" />
</xsl:for-each>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
Note: this does not check for duplicate nodes.

LINQ to XML is quite effective. Try
var xml1 = XDocument.Load("File1.xml");
var xml2 = XDocument.Load("File2.xml");
foreach (XElement metNode in xml1.Descendants("ID"))
{
metNode.AddAfterSelf(xml2.Descendants("Path").Where(ele => ele.Value.Equals(metNode.Parent.Element("Path").Value)).FirstOrDefault().Parent.Element("Description"));
}

XslCompiledTransform ignores ordering of XPathNodeIterator

I have an XSLT stylesheet that consumes a document and outputs a SOAP message, where the body is in a specific format defined by a WCF data contract (not specified here). The issue is that WCF has a peculiar notion of what constitutes 'alphabetical' ordering and considers the following order to be correct:
AC
Ab
This is because it uses ordinal string comparison internally. The details are not interesting, suffice to say that XSLT <sort> doesn't natively support this ordering but in order to transform an input document whose format may vary, into an acceptable SOAP message, the stylesheet must be able to order the output elements according to this peculiar ordering. I've therefore decided to implement node sorting in a script block. This is part of a C# solution and uses XslCompiledTransform and therefore msxsl:script is available.
Given a stylesheet:
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:fn="urn:functions"
xmlns:msxsl="urn:schemas-microsoft-com:xslt"
exclude-result-prefixes="msxsl exsl"
xmlns:exsl="http://exslt.org/common"
>
<msxsl:script implements-prefix="fn" language="C#">
<![CDATA[
public class OrdinalComparer : IComparer
{
public int Compare(object x, object y)
{
return string.CompareOrdinal((string)x, (string)y);
}
}
public XPathNodeIterator OrdinalSort(XPathNavigator source)
{
var query = source.Compile("/*");
query.AddSort(source.Compile("local-name()"), new OrdinalComparer());
return source.Select(query);
}
]]>
</msxsl:script>
<xsl:template match="Stuff">
<xsl:element name="Body">
<xsl:element name="Request">
<xsl:variable name="sort">
<xsl:apply-templates select="*"/>
</xsl:variable>
<xsl:for-each select="fn:OrdinalSort($sort)">
<xsl:copy-of select="."/>
</xsl:for-each>
</xsl:element>
</xsl:element>
</xsl:template>
<xsl:output method="xml" indent="yes"/>
<xsl:template match="#* | node()">
<xsl:copy>
<xsl:apply-templates select="#* | node()"/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>
And an input document:
<?xml version='1.0' encoding='utf-8'?>
<Root>
<Stuff>
<Age></Age>
<AIS></AIS>
<Something></Something>
<BMI></BMI>
</Stuff>
</Root>
I would expect the output to order the innermost elements as follows:
AIS
Age
BMI
Something
This does not happen. Instead the elements are emitted in the order they went in. Debugging into the stylesheet as it executes I can see the OrdinalSort function is called, and the iterator it returns does enumerate the elements in the desired order, but the XSLT processor somehow ignores this and emits the elements in the order they were encountered.
I have verified additionally that parsing the document in a console application and running the same iterator query emits elements in the right order.
Why, and what can I do about it? The only hunch I have at the moment is that the XSLT engine is interpreting the parent Navigator of the iterator (which hasn't changed from what was passed into the sort function) as the element to reproduce, and ignoring the contents of the iterator.

I am not sure how to solve that with XPathNodeIterator or XPathNavigator, I went as far as creating an XPathNavigator[] from the XPathNodeIterator, to avoid any lazy evaluation effects, but somehow I always ended up with the same result as you.
So as an alternative I have written some code using the DOM implementation in the .NET framework to create some new nodes in the right sort order:
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:mf="urn:functions"
xmlns:msxsl="urn:schemas-microsoft-com:xslt"
exclude-result-prefixes="msxsl exsl mf"
xmlns:exsl="http://exslt.org/common"
>
<msxsl:script implements-prefix="mf" language="C#">
<![CDATA[
public class OrdinalComparer : IComparer
{
public int Compare(object x, object y)
{
return string.CompareOrdinal((string)x, (string)y);
}
}
public XPathNavigator OrdinalSort(XPathNavigator source)
{
var query = source.Compile("/root/*");
query.AddSort("local-name()", new OrdinalComparer());
XPathNodeIterator result = source.Select(query);
XmlDocument resultDoc = new XmlDocument();
XmlDocumentFragment frag = resultDoc.CreateDocumentFragment();
foreach (XPathNavigator item in result)
{
frag.AppendChild(resultDoc.ReadNode(item.ReadSubtree()));
}
return frag.CreateNavigator();
}
]]>
</msxsl:script>
<xsl:output method="xml" indent="yes"/>
<xsl:template match="#* | node()">
<xsl:copy>
<xsl:apply-templates select="#* | node()"/>
</xsl:copy>
</xsl:template>
<xsl:template match="Stuff">
<Body>
<Request>
<xsl:variable name="sort-rtf">
<root>
<xsl:copy-of select="*"/>
</root>
</xsl:variable>
<xsl:variable name="sort" select="exsl:node-set($sort-rtf)"/>
<xsl:variable name="sorted" select="mf:OrdinalSort($sort)"/>
<xsl:copy-of select="$sorted"/>
</Request>
</Body>
</xsl:template>
</xsl:stylesheet>
Using that approach then the result is
<Root>
<Body><Request><AIS /><Age /><BMI /><Something /></Request></Body>
</Root>
I have slightly streamlined the code to
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:mf="urn:functions"
xmlns:msxsl="urn:schemas-microsoft-com:xslt"
exclude-result-prefixes="msxsl exsl mf"
xmlns:exsl="http://exslt.org/common"
>
<msxsl:script implements-prefix="mf" language="C#">
<![CDATA[
public class OrdinalComparer : IComparer
{
public int Compare(object x, object y)
{
return string.CompareOrdinal((string)x, (string)y);
}
}
public XPathNavigator OrdinalSort(XPathNavigator source)
{
var query = source.Compile("*");
query.AddSort("local-name()", new OrdinalComparer());
XPathNodeIterator result = source.Select(query);
XmlDocument resultDoc = new XmlDocument();
XmlDocumentFragment frag = resultDoc.CreateDocumentFragment();
foreach (XPathNavigator item in result)
{
frag.AppendChild(resultDoc.ReadNode(item.ReadSubtree()));
}
return frag.CreateNavigator();
}
]]>
</msxsl:script>
<xsl:output method="xml" indent="yes"/>
<xsl:template match="#* | node()">
<xsl:copy>
<xsl:apply-templates select="#* | node()"/>
</xsl:copy>
</xsl:template>
<xsl:template match="Stuff">
<Body>
<Request>
<xsl:variable name="sorted" select="mf:OrdinalSort(.)"/>
<xsl:copy-of select="$sorted"/>
</Request>
</Body>
</xsl:template>
</xsl:stylesheet>
Having to construct XmlNodes in the extension function C# "script" seems like an overhead but I am not sure how to solve it otherwise.

I have devised a hideous workaround to the original problem - which was to make XSLT support character ordinal sorting. I consider this an answer, but definitely not a good one. The following snippet illustrates this solution:
<xsl:template match="Stuff">
<xsl:element name="Body">
<xsl:element name="Request">
<xsl:variable name="source">
<xsl:apply-templates select="*"/>
</xsl:variable>
<xsl:for-each select="exsl:node-set($source)/*">
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 1, 1))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 2, 2))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 3, 3))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 4, 4))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 5, 5))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 6, 6))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 7, 7))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 8, 8))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 9, 9))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 10, 10))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 11, 11))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 12, 12))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 13, 13))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 14, 14))"/>
<xsl:sort data-type="number" select="fn:GetOrdinal(substring(local-name(.), 15, 15))"/>
<xsl:copy-of select="."/>
</xsl:for-each>
</xsl:element>
</xsl:element>
</xsl:template>
Where the extension function GetOrdinal is as follows:
public int GetOrdinal(string s)
{
return s.Length == 1 ? (char)s[0] : 0;
}
This is quite frankly shameful, and I would not advocate ever doing anything as shoddy as this. But it works.

"Execution of the 'document()' function was prohibited." where EnableDocumentFunction set to true?

I am getting an intermittent System.Xml.Xsl.XslTransformException exception in our production environment when attempting an xslt transform, unfortunately I cannot replicate this in the development environment.
The exception spits out further details:
Execution of the 'document()' function was prohibited. Use the
XsltSettings.EnableDocumentFunction property to enable it. An error
occurred at C:\path\to\file\CDS.xsl(16,3).
However the EnableDocumentFunction property is set to true in the processing code:
private void Transform()
{
var keepTrying = true;
var tryCount = 0;
const int maxRetrys = 3;
while (keepTrying)
{
try
{
var xmlResolver = new XmlUrlResolver();
using (var xmlFile = new XmlNodeReader(_xDoc))
{
var settings = new XmlReaderSettings
{
XmlResolver = xmlResolver,
ProhibitDtd = false,
DtdProcessing = DtdProcessing.Ignore
};
using (var xsl = XmlReader.Create(_xslPath, settings))
{
var xslt = new XslCompiledTransform(true);
xslt.Load(xsl, new XsltSettings { EnableDocumentFunction = true }, xmlResolver);
var sb = new StringBuilder();
using (var writer = XmlWriter.Create(sb, xslt.OutputSettings))
{
xslt.Transform(xmlFile, null, writer, xmlResolver); // errors out here.
}
var xhtml = sb.ToString();
_transformedXml = xhtml;
_isTransformed = true;
xsl.Close();
}
}
keepTrying = false;
}
catch (System.Xml.Xsl.XsltException ex)
{
ExceptionPolicy.HandleException(ex, "ExceptionLogging");
tryCount++;
if (tryCount > maxRetrys)
{
keepTrying = false;
throw;
}
}
}
}
The xslt file is provided by a third party and automatically updated, so rewriting it is not an option. Here is the top of it, slightly modified for privacy reasons:
<?xml version="1.0"?>
<!--
Interaction_550.xsl : 20110916
-->
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:example="http://www.example.com" version="1.0">
<xsl:param name="D2DSeverityFilter"></xsl:param>
<xsl:param name="D2HSeverityFilter"></xsl:param>
<xsl:param name="DocumentationFilter"></xsl:param>
<xsl:output method="html"/>
<xsl:key name="d2d_sev_level-lookup" match="example:d2d_sev_level" use="#name"/>
<xsl:key name="d2h_sev_level-lookup" match="example:d2h_sev_level" use="#name"/>
<xsl:key name="d2l_sev_level-lookup" match="example:d2l_sev_level" use="#name"/>
<xsl:key name="preg_cat-lookup" match="example:preg_cat" use="#cat"/>
<xsl:key name="doc_level-lookup" match="example:doc_level" use="#name"/>
<xsl:variable name="d2d_sev_level-top" select="document('')/*/example:d2d_sev_levels"/>
<xsl:variable name="d2h_sev_level-top" select="document('')/*/example:d2h_sev_levels"/>
<xsl:variable name="d2l_sev_level-top" select="document('')/*/example:d2l_sev_levels"/>
<xsl:variable name="doc_level-top" select="document('')/*/example:doc_levels"/>
<xsl:variable name="preg_cat-top" select="document('')/*/example:preg_cats"/>
<xsl:template match="/">
<head>
<style type="text/css">
body {
font-family : arial,sans serif,helvetica;
}
...
How can I:
fix this so that it does not happen at all?
failing that, how could I go about replicating this in dev?

Alternatively with MS XslCompiledTransform class you can use a XsltSettings class to avoid this error as it described by the error itself. from MSDN

Here is a general way to get rid of the document('')/*/someName expressions:
The original transformation is processed with a special transformation that generates an equivalent transformation that doesn't contain the document('') function call.
Then you just need to use the generated transformation.
Example:
This transformation (lets name it tA), containing document(''):
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:my="my:my" >
<xsl:output omit-xml-declaration="yes" indent="yes"/>
<xsl:strip-space elements="*"/>
<my:paramDoc1>
<x>123</x>
<y>37</y>
</my:paramDoc1>
<my:paramDoc2>
<x>456</x>
<y>79</y>
</my:paramDoc2>
<xsl:variable name="vpDoc1" select="document('')/*/my:paramDoc1"/>
<xsl:variable name="vpDoc2" select="document('')/*/my:paramDoc2"/>
<xsl:template match="/*">
<xsl:value-of select="$vpDoc1/x"/>
<xsl:text>|</xsl:text>
<xsl:value-of select="$vpDoc2/y"/>
</xsl:template>
</xsl:stylesheet>
when applied on any document, produces:
123|79
Now we process the above transformation with this one (tGen):
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:x="a:a" exclude-result-prefixes="x">
<xsl:output omit-xml-declaration="yes" indent="yes"/>
<xsl:strip-space elements="*"/>
<xsl:namespace-alias stylesheet-prefix="x"
result-prefix="xsl"/>
<xsl:variable name="vApos">'</xsl:variable>
<xsl:variable name="vSelectPrefix" select=
"concat('document(', $vApos,$vApos, ')/*/')"/>
<xsl:template match="node()|#*" name="identity">
<xsl:copy>
<xsl:apply-templates select="node()|#*"/>
</xsl:copy>
</xsl:template>
<xsl:template match="xsl:stylesheet">
<x:stylesheet xmlns:ext="http://exslt.org/common">
<xsl:copy-of select="#*"/>
<xsl:apply-templates/>
</x:stylesheet>
</xsl:template>
<xsl:template match="xsl:variable">
<xsl:variable name="vSelattr" select="#select"/>
<xsl:choose>
<xsl:when test="not(starts-with(#select, $vSelectPrefix))">
<xsl:call-template name="identity"/>
</xsl:when>
<xsl:otherwise>
<x:variable name="vrtf{#name}">
<xsl:copy-of select=
"/*/*[name()
= substring-after($vSelattr, $vSelectPrefix)
]"/>
</x:variable>
<x:variable name="{#name}" select=
"ext:node-set($vrtf{#name})/*"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>
The result is a new transformation (tRes), which doesn't contain expressions like document(''):
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:ext="http://exslt.org/common">
<xsl:output omit-xml-declaration="yes"
indent="yes" xmlns:my="my:my" />
<xsl:strip-space elements="*" xmlns:my="my:my" />
<my:paramDoc1 xmlns:my="my:my">
<x>123</x>
<y>37</y>
</my:paramDoc1>
<my:paramDoc2 xmlns:my="my:my">
<x>456</x>
<y>79</y>
</my:paramDoc2>
<xsl:variable name="vrtfvpDoc1">
<my:paramDoc1 xmlns:my="my:my">
<x>123</x>
<y>37</y>
</my:paramDoc1>
</xsl:variable>
<xsl:variable name="vpDoc1" select="ext:node-set($vrtfvpDoc1)/*" />
<xsl:variable name="vrtfvpDoc2">
<my:paramDoc2 xmlns:my="my:my">
<x>456</x>
<y>79</y>
</my:paramDoc2>
</xsl:variable>
<xsl:variable name="vpDoc2" select="ext:node-set($vrtfvpDoc2)/*" />
<xsl:template match="/*" xmlns:my="my:my">
<xsl:value-of select="$vpDoc1/x" />
<xsl:text>|</xsl:text>
<xsl:value-of select="$vpDoc2/y" />
</xsl:template>
</xsl:stylesheet>
If we now apply this dynamically generated transformation (tRes) to any XML document, the result is exactly the same as when applying the original transformation (tA) to this document:
123|79
Therefore, we can use tGen to convert a transformation containing document('') expressions to an equivalent transformation that doesn't contain such expressions.

Use Muenchian grouping with a variable node-set?

I have a xsl variable who contains :
<Products>
<product>
<productId >1</productId>
<textdate>11/11/2011</textdate>
<price>200</price>
</product>
<product>
<productId >6</productId>
<textdate>11/11/2011</textdate>
<price>100</price>
</product>
<product>
<productId >1</productId>
<textdate>16/11/2011</textdate>
<price>290</price>
</product>
</Products>
I want to regroup product like this :
{ product 1 :
11/11/2011 - 200
16/11/2011 - 290 }
{ product 6
11/11/2011 - 100 }
with a simple Muenchian algorithme it's possible but I cant have a xsl:key with a match on a variable.
edit
Maybe I'm not clear,
I've this xml document mydocument.xml I try to transform :
<?xml version="1.0" encoding="utf-8" ?>
<root>
<test>somestuff</test>
</root>
My xsl must look like that :
<?xml version="1.0" encoding="utf-8" ?>
<xsl:stylesheet version="2.0" xmlns:ms="urn:schemas-microsoft-com:xslt" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:output omit-xml-declaration="yes" method="xml" encoding="utf-8" />
<xsl:variable name="MyProductList" select="document('myresultlist.xml')" />
<xsl:key name="kProdById" match="$MyProductList/product" use="productId"/>
<xsl:template match=
"product[generate-id()
=
generate-id(key('kProdById',productId)[1])
]">
<xsl:value-of select="concat('
{product ', productId, ' :')"/>
<xsl:apply-templates mode="display"
select="key('kProdById',productId)"/>
}<xsl:text/>
</xsl:template>
<xsl:template match="product" mode="display">
<xsl:value-of select=
"concat('
', textdate, ' - ', price)"/>
</xsl:template>
<xsl:template match="text()"/>
</xsl:stylesheet>
When I put my variable $MyProductList in a match Visual Studio give an error, and when I'm trying to force the run my web app crash.
So I cannnot do what dimitre explain me.
Thanks for helping me

This transformation uses the Muenchian grouping method in its classic form:
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="text"/>
<xsl:key name="kProdById" match="product" use="productId"/>
<xsl:template match=
"product[generate-id()
=
generate-id(key('kProdById',productId)[1])
]">
<xsl:value-of select="concat('
{product ', productId, ' :')"/>
<xsl:apply-templates mode="display"
select="key('kProdById',productId)"/>
}<xsl:text/>
</xsl:template>
<xsl:template match="product" mode="display">
<xsl:value-of select=
"concat('
', textdate, ' - ', price)"/>
</xsl:template>
<xsl:template match="text()"/>
</xsl:stylesheet>
when applied on the provided XML document, the wanted, correct result is produced:
{product 1 :
11/11/2011 - 200
16/11/2011 - 290
}
{product 6 :
11/11/2011 - 100
}
UPDATE: The OP has shown more information and explained that the problem (in his code) is in these two lines:
<xsl:variable name="MyProductList" select="document('myresultlist.xml')" />
<xsl:key name="kProdById" match="$MyProductList/product" use="productId"/>
Solution: Just use:
<xsl:key name="kProdById" match="product" use="productId"/>
Whenever you want to reference the kProdById key in a key() function, make sure the wanted document is made current. In the more complicated cases this is done in XSLT 1.0 in the following way:
<!-- Temporarily switch to the document to be indexed -->
<xsl:for-each select="document('myresultlist.xml')">
<!-- Use here the key() function -->
</xsl:for-each>
<!-- Resume working with the main document here -->
Here is the same solution now applied to a document (its top-element) contained in a variable:
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:my="my:my"
>
<xsl:output method="text"/>
<my:doc>
<Products>
<product>
<productId >1</productId>
<textdate>11/11/2011</textdate>
<price>200</price>
</product>
<product>
<productId >6</productId>
<textdate>11/11/2011</textdate>
<price>100</price>
</product>
<product>
<productId >1</productId>
<textdate>16/11/2011</textdate>
<price>290</price>
</product>
</Products>
</my:doc>
<xsl:variable name="vDoc" select="document('')/*/my:doc/*"/>
<xsl:key name="kProdById" match="product" use="productId"/>
<xsl:template match="/">
<xsl:apply-templates select="$vDoc"/>
</xsl:template>
<xsl:template match=
"product[generate-id()
=
generate-id(key('kProdById',productId)[1])
]">
<xsl:value-of select="concat('
{product ', productId, ' :')"/>
<xsl:apply-templates mode="display"
select="key('kProdById',productId)"/> }
<xsl:text/>
</xsl:template>
<xsl:template match="product" mode="display">
<xsl:value-of select=
"concat('
', textdate, ' - ', price)"/>
</xsl:template>
<xsl:template match="text()"/>
</xsl:stylesheet>
when this transformation is applied on any document (not used), again the wanted result is produced:
{product 1 :
11/11/2011 - 200
16/11/2011 - 290 }
{product 6 :
11/11/2011 - 100 }