{"id":3923,"date":"2008-10-06T18:25:00","date_gmt":"2008-10-06T18:25:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2008\/10\/06\/vb-xml-cookbook-recipe-6-writing-an-xslt-transform-in-vb-doug-rothaus\/"},"modified":"2024-07-05T14:07:22","modified_gmt":"2024-07-05T21:07:22","slug":"vb-xml-cookbook-recipe-6-writing-an-xslt-transform-in-vb-doug-rothaus","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/vb-xml-cookbook-recipe-6-writing-an-xslt-transform-in-vb-doug-rothaus\/","title":{"rendered":"VB XML Cookbook, Recipe 6: Writing an XSLT Transform in VB (Doug Rothaus)"},"content":{"rendered":"

Most XSLT programmers are familiar with this XSLT transform to copy an XML file. <\/font><\/p>\n

<?<\/span>xml<\/span> <\/span>version<\/span>=<\/span>“1.0<\/span>“ <\/span>encoding<\/span>=<\/span>“utf-8<\/span>“?><\/p>\n

<\/span><\/span><\/p>\n

<<\/span>xsl:stylesheet<\/span> <\/span>version<\/span>=<\/span>“1.0<\/span>“ <\/span>xmlns:xsl<\/span>=<\/span>“http:\/\/www.w3.org\/1999\/XSL\/Transform<\/span>“><\/p>\n

<\/span><\/span><\/p>\n

    <\/span><<\/span>xsl:output<\/span> <\/span>method<\/span>=<\/span>“xml<\/span>“ <\/span>indent<\/span>=<\/span>“yes<\/span>“\/><\/p>\n

<\/span><\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span><<\/span>xsl:template<\/span> <\/span>match<\/span>=<\/span>“@* | node()<\/span>“><\/p>\n

<\/span><\/span><\/p>\n

        <\/span><<\/span>xsl:copy<\/span>><\/p>\n

<\/span><\/p>\n

            <\/span><<\/span>xsl:apply-templates<\/span> <\/span>select<\/span>=<\/span>“@* | node()<\/span>“\/><\/p>\n

<\/span><\/span><\/p>\n

        <\/span><\/<\/span>xsl:copy<\/span>><\/p>\n

<\/span><\/p>\n

    <\/span><\/<\/span>xsl:template<\/span>><\/p>\n

<\/span><\/p>\n

<\/<\/span>xsl:stylesheet<\/span>><\/p>\n

<\/span><\/p>\n

This XSLT is commonly used for identity transforms as it allows you to copy an entire XML document and “touch” each XML node and attribute. If you add a matching template, then you can transform just that attribute or node that has a match in place. Unmatched nodes and attributes are simply copied.<\/font><\/p>\n

We can also do this in Visual Basic with XML Literals (including LINQ to XML and XML Axis Properties). Our VB code will allow us to “touch” each node or element by recursively navigating through an XML document based on the following pseudo-code:<\/font><\/p>\n

Starting with the root element, perform the following whenever you encounter a node <\/p>\n

<\/font><\/font><\/i><\/p>\n

If the\n node is an element<\/p>\n

<\/font><\/font><\/i><\/p>\n

If the element has attributes, transform or copy each attribute<\/p>\n

<\/font><\/font><\/i><\/p>\n

If the element has child nodes, transform or copy each node<\/p>\n

<\/font><\/font><\/i><\/p>\n

If the node is text, transform or copy the text<\/p>\n

<\/font><\/font><\/i><\/p>\n

If the node is CData, transform or copy the CData<\/p>\n

<\/font><\/font><\/i><\/p>\n

If the node is a comment, transform or copy the comment<\/p>\n

<\/font><\/font><\/i><\/p>\n

If the node is a processing instruction, transform or copy the processing instruction<\/p>\n

<\/font><\/font><\/i><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

For this cookbook entry, we’ll create an abstract (MustInherit<\/b>) base class that performs this pseudo-coded recursive navigation of an XML document. We can then create a class that inherits from that base class to perform specific transforms. First, we’ll create the abstract class and the “starting point,” a function called <\/font>Transform<\/span> that takes the XML document (XDocument<\/b>) to be transformed as input and returns the transformed document.<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

Public<\/span> MustInherit<\/span> Class<\/span> VBXmlTransform<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

  <\/span>Public<\/span> Overridable<\/span> Function<\/span> Transform(ByVal<\/span> xmlDoc As<\/span> XDocument) As<\/span> XDocument<\/p>\n

<\/span><\/p>\n

    <\/span>Return<\/span> <?<\/span>xml<\/span> version<\/span>=<\/span>“<\/span>1.0<\/span>“<\/span> encoding<\/span>=<\/span>“<\/span>utf-8<\/span>“<\/span>?><\/p>\n

<\/span><\/span><\/p>\n

           <\/span><%=<\/span> ProcessElement(xmlDoc.Root) %><\/p>\n

<\/span><\/span><\/p>\n

  <\/span>End<\/span> Function<\/p>\n

<\/span><\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

End Class<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Next, we add the logic that is called for each XML node (XNode<\/b>) encountered. This includes elements, text, CData, and so on. Our code needs to determine the type of XML node and call the related function to transform or copy the node type and return the result, which is either a copied or transformed node. This method is called <\/font>ProcessNode<\/span> and is shown here.<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

  <\/span>Public<\/span> Overridable<\/span> Function<\/span> ProcessNode(ByVal<\/span> xmlNode As<\/span> XNode) As<\/span> XNode<\/p>\n

<\/span><\/p>\n

    <\/span>‘ This method ignores DTD (XDocumentType) content.<\/p>\n

<\/span><\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>Dim<\/span> nodeType = xmlNode.GetType()<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>‘ Because XCData inherits from XText, check for the XCData type before checking <\/p>\n

<\/span><\/span><\/p>\n

    <\/span>‘ for XText.<\/p>\n

<\/span><\/p>\n

    <\/span>If<\/span> nodeType Is<\/span> GetType<\/span>(XCData) Then<\/span> Return<\/span> ProcessCData(xmlNode)<\/p>\n

<\/span><\/p>\n

    <\/span>If<\/span> nodeType Is<\/span> GetType<\/span>(XText) Then<\/span> Return<\/span> ProcessText(xmlNode)<\/p>\n

<\/span><\/p>\n

    <\/span>If<\/span> nodeType Is<\/span> GetType<\/span>(XElement) Then<\/span> Return<\/span> ProcessElement(xmlNode)<\/p>\n

<\/span><\/p>\n

    <\/span>If<\/span> nodeType Is<\/span> GetType<\/span>(XComment) Then<\/span> Return<\/span> ProcessComment(xmlNode)<\/p>\n

<\/span><\/p>\n

    <\/span>If<\/span> nodeType Is<\/span> GetType<\/span>(XProcessingInstruction) Then<\/span> Return<\/span> _<\/p>\n

<\/span><\/p>\n

      <\/span>ProcessProcessingInstruction(xmlNode)<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>Return<\/span> xmlNode<\/p>\n

<\/span><\/p>\n

  <\/span>End<\/span> Function<\/p>\n

<\/span><\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

Next, we can add the strongly-typed functions that process each of the node types as well as attributes. The function to process an element is unique, so we’ll leave that out for now and cover that next. The functions to process the other node types and attributes are rather simple. Because the default behavior of the base class is to simply copy a document, each function just returns the input value. The reason that we have created this code is to provide strongly-typed functions that we can override in our inheriting class with specific behavior. Here are the strongly-typed functions (without the <\/font>ProcessElement<\/span> function).<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

  <\/span>Public<\/span> Overridable<\/span> Function<\/span> ProcessAttribute(ByVal<\/span> xmlAttribute As<\/span> XAttribute) As<\/span> XAttribute<\/p>\n

<\/span><\/p>\n

    <\/span>Return<\/span> xmlAttribute<\/p>\n

<\/span><\/p>\n

  <\/span>End<\/span> Function<\/p>\n

<\/span><\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

  <\/span>Public<\/span> Overridable<\/span> Function<\/span> ProcessCData(ByVal<\/span> xmlCData As<\/span> XCData) As<\/span> XCData<\/p>\n

<\/span><\/p>\n

    <\/span>Return<\/span> xmlCData<\/p>\n

<\/span><\/p>\n

  <\/span>End<\/span> Function<\/p>\n

<\/span><\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

  <\/span>Public<\/span> Overridable<\/span> Function<\/span> ProcessText(ByVal<\/span> xmlText As<\/span> XText) As<\/span> XText<\/p>\n

<\/span><\/p>\n

    <\/span>Return<\/span> xmlText<\/p>\n

<\/span><\/p>\n

  <\/span>End<\/span> Function<\/p>\n

<\/span><\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

  <\/span>Protected<\/span> Overridable<\/span> Function<\/span> ProcessComment(ByVal<\/span> xmlComment As<\/span> XComment) As<\/span> XComment<\/p>\n

<\/span><\/p>\n

    <\/span>Return<\/span> xmlComment<\/p>\n

<\/span><\/p>\n

  <\/span>End<\/span> Function<\/p>\n

<\/span><\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

  <\/span>Public<\/span> Overridable<\/span> Function<\/span> ProcessProcessingInstruction( _<\/p>\n

<\/span><\/p>\n

    <\/span>ByVal<\/span> pi As<\/span> XProcessingInstruction) As<\/span> XProcessingInstruction<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

    <\/span>Return<\/span> pi<\/p>\n

<\/span><\/p>\n

  <\/span>End<\/span> Function<\/p>\n

<\/span><\/span><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

Now let’s look at the <\/font>ProcessElement<\/span> function. Processing elements is unique because elements can have both attributes as well as child nodes. Those attributes and child nodes need to be transformed or copied as well, so we must provide code that calls the <\/font>ProcessAttribute<\/span> function for each attribute, and calls the <\/font>ProcessNode<\/span> function for each child node. We’ll encapsulate this code in a function called <\/font>CopyElement<\/span>. The <\/font>ProcessElement<\/span> function will look like the other strongly-typed functions, except that it will return a call to the <\/font>CopyElement<\/span> function instead of just the input element. The <\/font>CopyElement<\/span> function uses XML Literals, embedded expressions, and LINQ to XML to create the copy of the XML element as shown here.<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

  <\/span>Public<\/span> Overridable<\/span> Function<\/span> ProcessElement(ByVal<\/span> xmlElement As<\/span> XElement) As<\/span> XElement<\/p>\n

<\/span><\/p>\n

    <\/span>Return<\/span> CopyElement(xmlElement)<\/p>\n

<\/span><\/p>\n

  <\/span>End<\/span> Function<\/p>\n

<\/span><\/span><\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

Most XSLT programmers are familiar with this XSLT transform to copy an XML file. <?xml version=“1.0“ encoding=“utf-8“?> <xsl:stylesheet version=“1.0“ xmlns:xsl=“http:\/\/www.w3.org\/1999\/XSL\/Transform“>     <xsl:output method=“xml“ indent=“yes“\/>       <xsl:template match=“@* | node()“>         <xsl:copy>             <xsl:apply-templates select=“@* | node()“\/>         <\/xsl:copy>     <\/xsl:template> <\/xsl:stylesheet> This XSLT is commonly used for identity transforms as it allows you to […]<\/p>\n","protected":false},"author":260,"featured_media":8818,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[192,195],"tags":[59,117,163,166],"class_list":["post-3923","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-featured","category-visual-basic","tag-doug-rothaus","tag-orcas","tag-vb-xml-cookbook","tag-vb2008"],"acf":[],"blog_post_summary":"

Most XSLT programmers are familiar with this XSLT transform to copy an XML file. <?xml version=“1.0“ encoding=“utf-8“?> <xsl:stylesheet version=“1.0“ xmlns:xsl=“http:\/\/www.w3.org\/1999\/XSL\/Transform“>     <xsl:output method=“xml“ indent=“yes“\/>       <xsl:template match=“@* | node()“>         <xsl:copy>             <xsl:apply-templates select=“@* | node()“\/>         <\/xsl:copy>     <\/xsl:template> <\/xsl:stylesheet> This XSLT is commonly used for identity transforms as it allows you to […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/3923","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/users\/260"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/comments?post=3923"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/3923\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media\/8818"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media?parent=3923"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/categories?post=3923"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/tags?post=3923"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}