Home/ Questions/Q 6873167
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-27T04:01:37+00:00

I am getting an intermittent System.Xml.Xsl.XslTransformException exception in our production environment when attempting an

  • 0

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?
Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    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.

    • 0