XMLDocument: How to prevent introduction of spaces when reading XSLT from file

Thanks for your answer.

The transform is indeed written to an XmlWriter. I have attached the current code for the function which I use for XML-XSL transformations. The XmlWriterSettings are experimental.

Function TransformXMLWithParameters(ByVal oXML As XmlReader, ByVal oXSL As XslCompiledTransform, ByVal oParams As Hashtable) As String
    Dim element
    Dim sResult As String = ""
    Dim oMS As New MemoryStream
    Dim oWriterSetting As XmlWriterSettings = New XmlWriterSettings
    oWriterSetting.ConformanceLevel = ConformanceLevel.Fragment
    oWriterSetting.Indent = False
    oWriterSetting.NewLineChars = ""
    oWriterSetting.NewLineHandling = NewLineHandling.Replace
    oWriterSetting.NewLineOnAttributes = False
 
    Dim oWriter As XmlWriter = XmlWriter.Create(oMS, oWriterSetting)
    Dim oStream As New StreamReader(oMS)
    Dim oXSLArg As XsltArgumentList = New XsltArgumentList
    For Each element In oParams.Keys
        oXSLArg.AddParam(element, "", oParams(element))
    Next
    oXSL.Transform(oXML, oXSLArg, oWriter)
    oMS.Position = 0
    sResult = oStream.ReadToEnd()
    oStream.Close()
    oMS.Close()
    oXML.Close()
    Return sResult
End Function
 
 
----------------
// relevant XSL
----------------
 
            <xsl:when test="@type='203'">
                <!-- memo -->
                <td valign="top"><xsl:value-of select="caption" /></td>
                <td>
                    <textarea name="{@name}" id="{@name}" cols="50" rows="5"><xsl:if test="@usetinymce = '1'"><xsl:attribute name="class">tinymce</xsl:attribute><xsl:attribute name="rows">10</xsl:attribute></xsl:if><xsl:value-of select="value" /></textarea>
                </td>
            </xsl:when>
 
 
-------------
//relevant XML
-------------
 
      <field field_id="10" name="message_text1" order="04" active="1" type="203" usetinymce="1">
        <caption>Tekst</caption>
        <value />
      </field>
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:

A statement like this in the XSLT:

<td valign="top"><xsl:value-of select="caption" /></td>

will work the same if it were looking like this:

<td valign="top">
   <xsl:value-of select="caption" />
</td>

because XSLT removes all non-relevant spaces, they never become part of the result tree. The only spaces that remain are inside <xsl:text> elements, which must become part of the result tree.

Any spaces introduced are introduced by the serializer of the XSLT processor or the serializer of yourself (which has some pretty interesting settings). Try to do the .Transform() directly to a file and see if that changes the behavior (and inspect that file in the source).

-- Abel --

Thanks for your input so far.

The problem is that  I do not know where exactly the spaces are being introduced. There are quite some possibilities. Here is what I found

* My XML (XmlDocument) is generated on the fly, nodes are added with CreateElement() and AppendChild. When the XML has been created, I can do a XML.Save(Response.OutputStream).
Depending on the value of the PreserveWhitespace property of the XML, the result has white spaces.

.PreserveWhitespace = True
    -> no whitespace introduced

.PreserveWhitespace = False
    -> whitespace is introduced: each node is on a new line and has 2 leading spaces for each nesting level of the node


So apparently here is where the trouble starts: .PreserveWhitespace influences two things:
1. ignore whitespace or not
2. introduce its own whitespace or not

I have attached some simple code which illustrates the second behavior, although the difference is only visible in the View Source of the browser. The first effect (ignoring whitespace) is fine and even useful. The second effect causes my trouble with the XSL.

It is possible that "oXML.Save(Response.OutputStream)" uses implicitly one or more objects with some default settings, but I am not sure which.

Imports System.Xml
 
Partial Class XMLPreserveWhiteSpace
    Inherits System.Web.UI.Page
 
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        Dim oXML As XmlDocument = New XmlDocument
        If Request("preserverwhitespace") = "1" Then
            oXML.PreserveWhitespace = True
        Else
            oXML.PreserveWhitespace = False
        End If
        Dim oRoot = oXML.CreateElement("root")
        oXML.AppendChild(oRoot)
        oRoot.AppendChild(oXML.CreateElement("test"))
        oRoot.AppendChild(oXML.CreateElement("test"))
        Response.ContentType = "text/xml"
        oXML.Save(Response.OutputStream)
        Response.End()
    End Sub
End Class
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

> It is possible that "oXML.Save(Response.OutputStream)" uses implicitly one or more objects with some default settings, but I am not sure which.

yes, that's exactly what it does.

I actually meant you to create an XSLT transform directly to disk. It may seem strange, but the above introduces many places for introduction of white space. Here's a crash course on whitespace and XSLT:

Whitespace in source document is considered text and is preserved by default
Whitespace in XSLT document is ignored everywhere but in the xsl:text elements
Specific whitespace (&#xA; etc) are always preserved, also in XSLT doc
Whitespace is introduced on serialization
Serializing to HTML treats certain objects different when indent=true, to prevent whitespace added to tags like <pre>

To find out where the culprit is do the following:

Create an XSLT document (with any amount of whitespace)
Create a simple input XML document
Transform them the simplest way possible (see below)
Show me the input/output/xslt and code you used

then I can explain you what whitespace was added where and why. Later we'll introduce the rest of the necessary logic again.

-- Abel --

XslCompiledTransform compiledXsl = new XslCompiledTransform();
compiledXsl.Load("yourxsltfile.xslt");
compiledXsl.Transform("Xslt/input.xml", "output.xml");
                                              

1:
2:
3:

> It is possible that "oXML.Save(Response.OutputStream)" uses implicitly one or more objects with some default settings, but I am not sure which.

yes, that's exactly what it does.

I actually meant you to create an XSLT transform directly to disk. It may seem strange, but the above introduces many places for introduction of white space. Here's a crash course on whitespace and XSLT:

1. Whitespace in source document is considered text and is preserved by default 
2. Whitespace in XSLT document is ignored everywhere but in the xsl:text elements 
3. Specific whitespace (&#xA; etc) are always preserved, also in XSLT doc 
4. Whitespace is introduced on serialization 
5. Serializing to HTML treats certain objects different when indent=true, to prevent whitespace added to tags like <pre> 

1. Create an XSLT document (with any amount of whitespace) 
2. Create a simple input XML document 
3. Transform them the simplest way possible (see below) 
4. Show me the input/output/xslt and code you used 

Fine. This simple transformation eliminates most of the whitespace.

Files attached (I had to rename them to .txt, but you'll understand which is which).

Looks Dutch ;-)

There's specific whitespace in the source document, which is transformed into attributes. Whitespace in attributes is always significant (not in XSLT for obvious reasons). This is an XML rule, not an XSLT rule.

Do I understand you correctly that all source whitespace should be collapsed? I.e., that the resulting whitespace should be stripped (all multiple whitespace into a single one)?

Yep, Dutch.

It started with a HTML-textarea which had whitespace coming from nowhere. The ultimate purpose is of course understand what is going on. Which factors influence the whitespace and how.

Where is the whitespace introduced, and how can it be prevented. And then I am talking about the formatting whitespace: each node gets a linefeed + two spaces for each nesting level.

The test from above shows that it is not XslCompiledTransform that does it.

XmlDocument() has a property ".PreserveWhitespace" which seems to do 2 different things: first eliminate whitespace, then introduce its own whitespace (with value "False").

Or is the introduction of that own whitespace a result of something else?