Recently in XML Category

Proceedings of Extreme Markup Languages 2006 · XML

{Visual Studio install drive}:\Program Files\Microsoft Visual Studio 9.0\Xml\Schemas
<b>This is a <span style="color: #888">very long</span> text.</b>
<b>This is a <span style="color: #888">very ...</span></b>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:param name="max-len" select="15"/>

  <xsl:template match="/">
    <xsl:call-template name="trim"/>
  </xsl:template>

  <xsl:template name="trim">
    <xsl:param name="rlen" select="0"/>
    <xsl:param name="nodes" select="*"/>

    <xsl:choose>
      <xsl:when test="$rlen + string-length($nodes[1]) <= $max-len">
        <xsl:copy-of select="$nodes[1]"/>
        <xsl:if test="$nodes[2]">
          <xsl:call-template name="trim">
            <xsl:with-param name="rlen" select="$rlen + string-length($nodes[1]) "/>
            <xsl:with-param name="nodes" select="$nodes[position() != 1]|$nodes[1]/*"/>
          </xsl:call-template>
        </xsl:if>
      </xsl:when>
      <xsl:when test="$nodes[1]/self::text()">
        <xsl:value-of select="substring($nodes[1], 1, $max-len - $rlen)"/>
        <xsl:text>...</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:if test="$nodes[1]/node()">
          <xsl:element name="{name($nodes[1])}" 
                       namespace="{namespace-uri($nodes[1])}">
            <xsl:copy-of select="$nodes[1]/@*"/>
            <xsl:call-template name="trim">
              <xsl:with-param name="rlen" select="$rlen"/>
              <xsl:with-param name="nodes" select="$nodes[1]/node()"/>
            </xsl:call-template>
          </xsl:element>
        </xsl:if>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
</xsl:stylesheet>
<!DOCTYPE p [
<!ENTITY _0_ 'string'>  
<!ENTITY _0-0_ 'sub&_0_;'>
]>
<p x:version="1.0" xmlns:x="http://www.w3.org/1999/XSL/Transform">
  <x:variable name="_" select="document('')"/>
  <x:variable name="_-_" select="number(not(_-_=_-_=_-_=_-_))"/>
  <x:value-of select="concat(
    &_0-0_;(namespace-uri($_/*/*[$_-_]), $_-_, $_-_), 
    &_0-0_;(name($_/*/*[$_-_]), &_0_;-length(*>*)*2, $_-_),
    &_0-0_;(@_>_-, &_0_;-length(******* div @_), $_-_),
    translate(name(($_//@*)[5]), translate(name(($_//@*)[5]), 'l', ''), ''),
    &_0-0_;($_//namespace::*, &_0_;-length($_-_ div 0)+7, $_-_), '&#032;',
    &_0-0_;-after(&_0-0_;-before($_//namespace::*, 3), '.'),
    &_0-0_;($_//namespace::*, 15, 2),
    &_0-0_;(_/_/_=//_//_, 3, $_-_),
    &_0-0_;($_/*/*/@*[contains(.,'(')], $_-_, $_-_), '&#x21;')"/>
</p>
<?xml version="1.0" encoding="UTF-8" ?>
<stylesheet version="1.0" xmlns="http://www.w3.org/1999/XSL/Transform">
</stylesheet>
<?xml version="1.0" encoding="utf-8"?>

<xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:exsl="http://exslt.org/common" 
    exclude-result-prefixes="exsl">

<xsl:template match="/">
    <html>
    <body>
    <!--
        This is an XSLT template file. Fill in this area with the
        XSL elements which will transform your XML to XHTML.
    -->
    </body>
    </html>
</xsl:template>

</xsl:stylesheet>
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"
>
    <xsl:output method="xml" indent="yes"/>

    <xsl:template match="@* | node()">
        <xsl:copy>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>
</xsl:stylesheet>
document()
xsl:include
xsl:import
true
doc.setProperty("AllowXsltScript", true);
doc.setProperty("AllowXsltScript", false);
false
AllowXsltScript
true
document
true
document
doc.setProperty("AllowDocumentFunction", true);
document
doc.setProperty("AllowDocumentFunction", false);
document
document
document
document
xsl:include
xsl:import
true
resolveExternals
false
doc.resolveExternals = true;
doc.resolveExternals = false;
xsl:import
xsl:include
document()
document()
nxsltc mytransform.xsl /out:mytransform.dll
nxslt3 document.xml -c mytransform -af mytransform.dll
nxslt3 document.xml -c mytransform
nxslt3 document.xml -c -af mytransform.dll
nxsltc mytransform.xsl /keyfile:d:\keys\test.snk
nxslt3 document.xml -c -an "mytransform, Version=1.0.0.0, PublicKeyToken=b79508ebff528747"
nxslt3 document.xml -c -an mytransform
XslCompiledTransform
nxsltc.exe catalog2html.xslt /version:2.3.4.5 /keyfile:d:\keys\test.snk

D:\>nxsltc.exe /?
XSLT Compiler version 1.0beta2 for .NET 3.5
(c) 2007 Oleg Tkachenko, http://www.xmllab.net

Usage: nxsltc  [options]
where possible options include:
  /out:         Specifies the output file name
  /debug[+|-]   Emit debugging information
  /nowarn       Disable all warnings
  /namespace:   Specifies namespace for compiled stylesheets
  /version:     Specifies assembly version
  /keyfile:     Specifies strong name key file
  /help         Display this usage message (Short form: /?)
  /nologo       Do not display compiler copyright banner
XslCompiledTransform
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:exsl="http://exslt.org/common" exclude-result-prefixes="exsl">
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="xml" indent="yes" 
    doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
    doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN"/>
  <xsl:template match="/">
    <html xmlns="http://www.w3.org/1999/xhtml">
      <head>
        <title/>
      </head>
      <body>
        <p>Para element must have end tag even if empty:</p>
        <p/>
        <p>These elements must not have end tags:</p>
	<p>
          <br></br>
          <hr></hr>
          <img src="foo.jpg" alt="bar"></img>
        </p>
      </body>
    </html>
  </xsl:template>
</xsl:stylesheet>

using System;
using System.Xml.XPath;
using System.IO;
using Mvp.Xml.Common.Xsl;

class Program
{
  static void Main(string[] args)
  {
    XPathDocument doc = new XPathDocument(
      new StringReader(""));
    MvpXslTransform xslt = new MvpXslTransform();
    xslt.Load("../../XSLTFile1.xslt");
    xslt.EnforceXHTMLOutput = true;
    xslt.Transform(new XmlInput(doc), null, 
      new XmlOutput(Console.Out));
  }
}

<?xml version="1.0" encoding="DOS-862"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <title></title>
  </head>
  <body>
    <p>Para element must have end tag even if empty:</p>
    <p></p>
    <p>These elements must not have end tags:</p>
    <p>
      <br />
      <hr />
      <img src="foo.jpg" alt="bar" />
    </p>
  </body>
</html>

using System;
using System.Xml.XPath;
using System.Xml.Xsl;
using System.Xml;
using System.IO;
using Mvp.Xml.Common;

class Program
{
  static void Main(string[] args)
  {
    XPathDocument doc = new XPathDocument(
      new StringReader(""));
    XslCompiledTransform xslt = new XslCompiledTransform();
    xslt.Load("../../XSLTFile1.xslt");            
    xslt.Transform(doc, null, 
      new XhtmlWriter(
        XmlWriter.Create(Console.Out, xslt.OutputSettings)));
  }
}

using System;
using Saxon.Api;
using Mvp.Xml.XInclude;

class Program
{
  static void Main(string[] args)
  {
    Processor proc = new Processor();
    XdmNode doc = proc.NewDocumentBuilder().Build(
      new XIncludingReader("d:/test/document.xml"));
    XsltExecutable xslt = proc.NewXsltCompiler().Compile(
      new Uri("d:/test/foo.xsl"));
    XsltTransformer trans = xslt.Load();
    trans.InitialContextNode = doc;
    Serializer ser = new Serializer();
    ser.SetOutputStream(Console.OpenStandardOutput());
    trans.Run(ser);            
  }
}
<xsl:stylesheet
  version="1.0" 
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:exslt="http://exslt.org/common"
  xmlns:msxsl="urn:schemas-microsoft-com:xslt"
  exclude-result-prefixes="exslt msxsl">

<msxsl:script language="JScript" implements-prefix="exslt">
 this['node-set'] =  function (x) {
  return x;
  }
</msxsl:script>
...

using System;
using System.Xml.Xsl;
using System.Xml.XPath;
using System.Xml;
using Mvp.Xml.Common.Xsl;

class Program
{
    public static void Main()
    {
        MvpXslTransform xslt1 = new MvpXslTransform();        
        xslt1.Load("../../XSLTFile1.xslt");
        MvpXslTransform xslt2 = new MvpXslTransform();
        xslt2.Load("../../XSLTFile2.xslt");
        XPathDocument doc = new XPathDocument("../../source.xml");
        XmlReader stage1Output = xslt1.Transform(new XmlInput(doc), null);
        xslt2.Transform(new XmlInput(stage1Output), null, 
            new XmlOutput(Console.Out));        
    }
}
SgmlReader r = new SgmlReader();
r.Href = "http://www.microsoft.com";                        
XmlDocument doc = new XmlDocument();
doc.Load(r);                
//pick the first <li> element in navigation section
XmlNode firstNavItemNode = 
  doc.SelectSingleNode("//div[@id='Nav']//li");
//validate the first list item in the Nav element says "Windows"        
Debug.Assert(firstNavItemNode.InnerText == "Windows"); 
<nxslt in="books.xml" style="books.xsl" out="out/params1.html">
  <parameters>
    <parameter name="param2" namespaceuri="foo ns" value="param2 value"/>
    <parameter name="param1" namespaceuri="" value="param1 value"/>
  </parameters>
</nxslt>
<ItemGroup>
  <MyXslFile Include="foo.xsl">
    <param>value</param>
  </MyXslFile>
</ItemGroup>

<Target Name="report" >
  <Xslt Inputs="@(XmlFiles)"
    Xsl="@(MyXslFile)" 
    Output="$(testDir)\Report.html" />
</Target>
<PropertyGroup>
  <XsltParameters>
    <Parameter Name="param1" Value="value111"/>
    <Parameter Name="param2" NamespaceUri="foo ns" Value="value222"/>
  </XsltParameters>
</PropertyGroup>

<Target Name="transform">
  <Nxslt In="books.xml" Style="books.xsl" Out="Out/params1.html" 
    Parameters="$(XsltParameters)"/>
</Target>

<p:pipeline name="fig2"
            xmlns:p="http://example.org/PipelineNamespace">
  <p:input port="doc" sequence="no"/>
  <p:output port="out" step="xform" source="result"/>

  <p:choose name="vcheck" step="fig2" source="doc">
    <p:when test="/*[@version &lt; 2.0]">
      <p:output name="valid" step="val1" source="result"/>
      <p:step type="p:validate" name="val1">
        <p:input port="document" step="fig2" source="doc"/>
        <p:input port="schema" href="v1schema.xsd"/>
      </p:step>
    </p:when>

    <p:otherwise>
      <p:output name="valid" step="val2" source="result"/>
      <p:step type="p:validate" name="val2">
        <p:input port="document" step="fig2" source="doc"/>
        <p:input port="schema" href="v2schema.xsd"/>
      </p:step>
    </p:otherwise>
  </p:choose>

  <p:step type="p:xslt" name="xform">
    <p:input port="document" step="vcheck" source="valid"/>
    <p:input port="stylesheet" href="stylesheet.xsl"/>
  </p:step>
</p:pipeline>
private void Run(string[] args) {
    XslCompiledTransform xslt = new XslCompiledTransform();
    try {
        xslt.Load(args[0]);
    }
    catch (XsltException) {
        string errors = GetCompileErrors(xslt);
        if (errors == null) {
            // Failed to obtain list of compile errors
            throw;
        }
        Console.Write(errors);
    }
}

// True to output full file names, false to output user-friendly file names
private bool fullPaths = false;

// Cached value of Environment.CurrentDirectory
private string currentDir = null;

/// 
/// Returns user-friendly file name. First, it tries to obtain a file name
/// from the given uriString.
/// Then, if fullPaths == false, and the file name starts with the current
/// directory path, it removes that path from the file name.
/// 
private string GetFriendlyFileName(string uriString) {
    Uri uri;

    if (uriString == null ||
        uriString.Length == 0 ||
        !Uri.TryCreate(uriString, UriKind.Absolute, out uri) ||
        !uri.IsFile
    ) {
        return uriString;
    }

    string fileName = uri.LocalPath;

    if (!fullPaths) {
        if (currentDir == null) {
            currentDir = Environment.CurrentDirectory;
            if (currentDir[currentDir.Length - 1] != Path.DirectorySeparatorChar) {
                currentDir += Path.DirectorySeparatorChar;
            }
        }

        if (fileName.StartsWith(currentDir, StringComparison.OrdinalIgnoreCase)) {
            fileName = fileName.Substring(currentDir.Length);
        }
    }

    return fileName;
}

private string GetCompileErrors(XslCompiledTransform xslt) {
    try {
        MethodInfo methErrors = typeof(XslCompiledTransform).GetMethod(
            "get_Errors", BindingFlags.NonPublic | BindingFlags.Instance);

        if (methErrors == null) {
            return null;
        }

        CompilerErrorCollection errorColl = 
            (CompilerErrorCollection) methErrors.Invoke(xslt, null);
        StringBuilder sb = new StringBuilder();

        foreach (CompilerError error in errorColl) {
            sb.AppendFormat("{0}({1},{2}) : {3} {4}: {5}",
                GetFriendlyFileName(error.FileName),
                error.Line,
                error.Column,
                error.IsWarning ? "warning" : "error",
                error.ErrorNumber,
                error.ErrorText
            );
            sb.AppendLine();
        }
        return sb.ToString();
    }
    catch {
        // MethodAccessException or SecurityException may happen 
        //if we do not have enough permissions
        return null;
    }
}

An error occurred while compiling stylesheet 'file:///D:/projects2005/Test22/Test22/test.xsl': 
System.Xml.Xsl.XslLoadException: Name cannot begin with the '1' character, hexadecimal value 0x31.

test.xsl(11,5) : error : Name cannot begin with the '1' character, hexadecimal value 0x31.
test.xsl(12,5) : error : Name cannot begin with the '0' character, hexadecimal value 0x30.
test.xsl(13,5) : error : The empty string '' is not a valid name.
test.xsl(14,5) : error : The ':' character, hexadecimal value 0x3A, cannot be included in a name.
test.xsl(15,5) : error : Name cannot begin with the '-' character, hexadecimal value 0x2D.

using System;
using System.Xml;
using System.Xml.XPath;
using System.Xml.Xsl;

public class Test
{
  static void Main()
  {
    XPathDocument xdoc = new XPathDocument("books.xml");
    XslCompiledTransform xslt = new XslCompiledTransform();
    xslt.Load("foo.xslt", XsltSettings.TrustedXslt,
      new XmlUrlResolver());
    xslt.Transform(xdoc, null, Console.Out);
  }
}
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:ext="http://example.com/ext" 
extension-element-prefixes="ext">

  <ms:script implements-prefix="ext" 
  xmlns:ms="urn:schemas-microsoft-com:xslt" language="C#">
    public int line(XPathNavigator node)
    {
      IXmlLineInfo lineInfo = node as IXmlLineInfo;
      return lineInfo != null ? lineInfo.LineNumber : 0;
    }
  </ms:script>

  <xsl:template match="/">
    <foo>
      <xsl:value-of select="ext:line(//book)">
    </foo>
  </xsl:template>
</xsl:stylesheet>
selectNodes("foo[bar=\"Tom's BBQ\"]") 
selectNodes("foo[bar=$var]")
XPathCache.SelectSingleNode("//foo[bar=$var]",
    doc, new XPathVariable("var", "A'B'C\"D\""))
XMLInputFactory xif = XMLInputFactory.newInstance();
XMLStreamReader reader = xif.createXMLStreamReader(
    new StreamSource("foo.xml"));
reader = xif.createFilteredReader(reader, new StreamFilter() {
    private int ignoreDepth = 0;

    public boolean accept(XMLStreamReader reader) {
        if (reader.isStartElement()
            && reader.getLocalName().equals("ignoreme")) {
            ignoreDepth++;
            return false;
        } else if (reader.isEndElement()
           && reader.getLocalName().equals("ignoreme")) {
           ignoreDepth--;
           return false;
        }
        return (ignoreDepth == 0);
    }
});
// move to <root>
moveToNextTag(reader);
// move to <data>
moveToNextTag(reader);
// read data
System.out.println(reader.getElementText());
reader.close();
do {
    reader.next();
} while (!reader.isStartElement() && !reader.isEndElement());
public class Test
{
    private class XmlFilter : XmlWrappingReader
    {
        public XmlFilter(string uri)
            : base(XmlReader.Create(uri)) { }

        public override bool Read()
        {
            bool baseRead = base.Read();
            if (NodeType == XmlNodeType.Element &&
                LocalName == "ignoreme")
            {
                Skip();
                return base.Read();
            }
            return baseRead;
        }
    }

    static void Main(string[] args)
    {
        XmlFilter filter = new XmlFilter("../../foo.xml");
        XmlReader r = XmlReader.Create(filter, null);
        //move to <root>
        r.MoveToContent();
        //Move to <data>
        MoveToNextTag(r);
        Console.WriteLine(r.ReadString());
    }

    private static void MoveToNextTag(XmlReader r)
    {
        do
        {
            r.Read();
        } while (!(r.NodeType == XmlNodeType.Element) &&
        !(r.NodeType == XmlNodeType.EndElement));

    }
}
XPathDocument doc = 
    new XPathDocument("source.xml");
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load("XSLTFile1.xslt");
XmlReader resultReader = 
    xslt.Transform(new XmlInput(doc), null);
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas.Add("", "orders.xsd");
XmlReader validatingReader = 
    XmlReader.Create(resultReader, settings);
XmlWriter w = XmlWriter.Create(Console.Out);
w.WriteNode(validatingReader, false);
w.Close();
protected void Page_Load(object sender, EventArgs e)
{
  EXml1.XsltSettings = System.Xml.Xsl.XsltSettings.TrustedXslt;
  EXml1.TransformArgumentList = 
    new System.Xml.Xsl.XsltArgumentList();
  EXml1.TransformArgumentList.AddParam(
    "base-dir-for-images", "", MapPathSecure("~/images"));
  EXml1.TransformArgumentList.AddParam(
    "base-virtual-dir-for-images", "", "images");        
}

<catalog>
    <book xml:id="b101">...</book>
    <book xml:id="b102">...</book>
    <book xml:id="b102">...</book>
</catalog>
Mvp.Xml.Exslt
using (XmlReader src = XmlReader.Create("../../source.xml"))
{
  XslCompiledTransform xslt = new XslCompiledTransform();
  xslt.Load("../../style.xslt");
  XmlWriter result = XmlWriter.Create(Console.Out, xslt.OutputSettings);
  xslt.Transform(src, null, result, new XmlUrlResolver());
}

"number('foo')=number('bar')"
"number($val) = number($val)"
public virtual XPathNavigator CreateNavigator()
{
      return this.Clone();
}

using (XmlReader r = XmlReader.Create("../../source.xml"))
{
  while (r.Read())
    Console.WriteLine(r.NodeType);
}
declare namespace f="f.uri";

(: Test saxon:for-each-group extension function :)

declare function f:get-country ($c) { $c/@country };

declare function f:put-country ($group) {
    <country name="{$group[1]/@country}" 
        leading="{$group[1]/@name}" size="{count($group)}">
       {for $g in $group 
           order by $g/@name
           return <city>{ $g/@name }</city>
       }
    </country>
}; 

<out>
    {saxon:for-each-group(/*/city, 
         saxon:function('f:get-country', 1), 
         saxon:function('f:put-country', 1))}
</out>
XslTransform
accept-charset
xml:id
xml:id
From: jenglish@crl.com (Joe English)
Newsgroups: comp.text.sgml
Subject: A Song
Date: 24 Oct 1994 19:05:27 -0700
Organization: Helpless people on subway trains
Lines: 51
Message-ID: <38hp57$1r6@crl.crl.com>
NNTP-Posting-Host: crl.com

[ Allegro, with vigor ]

Well, if you can't do it with <!LINKTYPE ...>,
And features of SGML,
And if you can't hack it in HyTime,
No sweat!  It's in DSSSL!

	DSSSL!
	DSSSL!
	It's really cool!
	A useful tool!
	It's DSSSL!

"So tell me then, what does it look like?"
Afraid I can't -- nobody knows!
I guarantee you're gonna love it,
Just wait and see, that's how it goes.

	DSSSL!
	DSSSL!
	It's like a dream!
	It's based on Scheme!
	It's DSSSL!

The World-Wide-Web's gotta have stylesheets,
Or HTML's going to burst.
Will DSSSL come and save us
(Unless Netscape gets to it first)?

	DSSSL!
	DSSSL!
	Never fear,
	It's almost here!
	It's DSSSL!

So -- if -- FOSI's are driving you batty,
And PDF isn't enough,
This standard will solve all your problems
(But it isn't finished yet.  Tough.)

	DSSSL!
	DSSSL!
	It's amazingly great
	But you'll just have to wait
	For Dee-ess-ess-ess-ellllllll!

--Joe English

  jenglish@crl.com

<root>
    <item>Screwdriver</item>
    <item>Hammer</item>
</root>
<stylesheet version="1.0" 
xmlns="http://www.w3.org/1999/XSL/Transform" >
  <template match="item">
    <value-of select="position()"/>:<value-of select="."/>
  </template>
</stylesheet>
1:Screwdriver2:Hammer
    2:Screwdriver
    4:Hammer
<library>
  <book genre='novel' ISBN='1-861001-57-5'>
     <title>Pride And Prejudice</title>
  </book>
  <book genre='novel' ISBN='1-81920-21-2'>
     <title>Hook</title>
  </book>
</library>
<stylesheet version="1.0" 
xmlns="http://www.w3.org/1999/XSL/Transform" >
  <output indent="yes"/>
  <template match="/">
	<copy-of select="/"/>
  </template>
</stylesheet>
XslTransform xslt = new XslTransform();
xslt.Load("test.xsl");
XmlDocument doc = new XmlDocument();
doc.Load("foo.xml");
//Navigator over first child of document element
XPathNavigator nav = 
    new XmlNodeNavigator(doc.DocumentElement.FirstChild);
xslt.Transform(nav, null, Console.Out, null);
<book genre="novel" ISBN="1-861001-57-5">
  <title>Pride And Prejudice</title>
</book>
book
book
<?xml version="1.0">
<report><link 
url="http://www.internettrafficreport.com/main.htm">Internet Traffic Report</link>
reports on the current performance of major Internet routes around the world.</report>

<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:wx="http://schemas.microsoft.com/office/word/2003/auxHint"
xmlns:w="http://schemas.microsoft.com/office/word/2003/wordml">    
    <xsl:variable name="root" select="/*"/>
    <xsl:template match="/">
        <xsl:apply-templates 
        select="document('d:\temp\WordTemplate.xml')/node()" 
        mode="template"/>
    </xsl:template>
    <xsl:template match="@*|node()" mode="template">
        <xsl:copy>
            <xsl:apply-templates select="@*|node()" 
            mode="template"/>
        </xsl:copy>
    </xsl:template>
    <xsl:template match="w:body/wx:sect" mode="template">
        <xsl:copy>
            <xsl:apply-templates select="$root"/>
            <xsl:copy-of select="wx:sectPr"/>
        </xsl:copy>
    </xsl:template>
    <xsl:template match="report">
        <w:p>
            <w:pPr>
                <w:pStyle w:val="MyFancyStyle"/>
            </w:pPr>
            <xsl:apply-templates/>
        </w:p>        
    </xsl:template>
    <xsl:template match="text()">
        <w:r>
            <w:t><xsl:value-of select="."/></w:t>
        </w:r>
    </xsl:template>
    <xsl:template match="link">
        <w:hlink w:dest="{@url}">
            <w:r>  
                <w:rPr>
                    <w:rStyle w:val="Hyperlink"/>
                </w:rPr>              
                <xsl:apply-templates/>
            </w:r>
        </w:hlink>
    </xsl:template>    
</xsl:stylesheet>

w:body/wx:sect
MyFancyStyle
wx:sectPr
MyFancyStyle
public class XmlTransformingReader : XmlReader {
    private XmlReader _outReader;

    #region Constructors
    public XmlTransformingReader(string source, string transformSource) {
        XPathDocument doc = new XPathDocument(source);
        XslTransform xslt = new XslTransform();
        xslt.Load(transformSource);
        _outReader = xslt.Transform(doc, null, new XmlUrlResolver());
    }
    //...Dozen other constructors ...
    #endregion

    #region XmlReader impl methods	
    public override int AttributeCount {
        get { return _outReader.AttributeCount;}
    }
    public override string BaseURI {
        get { return _outReader.BaseURI; }
    }
    //The rest 20+ XmlReader methods/properies implemented in the same way
}
inventory.xml
<parts>
    <item SKU="1001" name="Hairdrier" price="39.99"/>
    <item SKU="1001" name="Lawnmower" price="299.99"/>
    <item SKU="1001" name="Spade" price="19.99"/>
    <item SKU="1001" name="Electric drill" price="99.99"/>
    <item SKU="1001" name="Screwdriver" price="9.99"/>
</parts>
filtering stylesheet
<xsl:stylesheet version="1.0" 
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="parts">
        <parts>
            <xsl:apply-templates select="item">
                <xsl:sort data-type="number" 
                order="descending" select="@price"/>
            </xsl:apply-templates>
        </parts>
    </xsl:template>
    <xsl:template match="item">
        <xsl:if test="position() &lt;= 3">
            <xsl:copy-of select="."/>
        </xsl:if>
    </xsl:template>
</xsl:stylesheet>

XmlReader xtr = new XmlTransformingReader("inventory.xml", "filter.xsl");
//That's it, now let's dump out XmlTransformingReader to see what it returns
XmlTextWriter w = new XmlTextWriter(Console.Out);
w.Formatting = Formatting.Indented;
w.WriteNode(xtr, false);
xtr.Close();
w.Close();
<parts>
  <item SKU="1001" name="Lawnmower" price="299.99" />
  <item SKU="1001" name="Electric drill" price="99.99" />
  <item SKU="1001" name="Hairdrier" price="39.99" />
</parts>
w:pict
<xsd:import namespace="urn:schemas-microsoft-com:vml" 
schemaLocation="C:\SCHEMAS\vml.xsd"/>
<w:pict>
    <v:shapetype id="_x0000_t75" ...>
    ... VML shape template definition ...
    </v:shapetype>
    <w:binData w:name="wordml://02000001.jpg">
    ... Base64 encoded image goes here ...
    </w:binData>
    <v:shape id="_x0000_i1025" type="#_x0000_t75" 
      style="width:212.4pt;height:159pt">
         <v:imagedata src="wordml://02000001.jpg" 
           o:title="Image title"/>
    </v:shape>
</w:pict>

v:shapetype
w:binData
v:shape
v:shape
v:imagedata
<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="style.xsl"?>
<article title="Pussy cat">
	<para>Here goes a picture: <image 
              src="d:\cat.gif" alt="Cat"/></para>
</article>
<xsl:stylesheet version="1.0" 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:o="urn:schemas-microsoft-com:office:office"
xmlns:w="http://schemas.microsoft.com/office/word/2003/wordml" 
xmlns:msxsl="urn:schemas-microsoft-com:xslt" 
xmlns:ext="my extension" 
xmlns:v="urn:schemas-microsoft-com:vml" 
exclude-result-prefixes="msxsl ext">
  <msxsl:script language="C#" implements-prefix="ext">
  public static string EncodeBase64(string file) {
    System.IO.FileInfo fi = new System.IO.FileInfo(file);
    if (!fi.Exists)
      return String.Empty;
    using (System.IO.FileStream fs = System.IO.File.OpenRead(file)) {
      System.IO.BinaryReader br = new System.IO.BinaryReader(fs);
      return Convert.ToBase64String(br.ReadBytes((int)fi.Length));
    }
  }
  </msxsl:script>
  <xsl:template match="/">
    <xsl:processing-instruction 
      name="mso-application">progid="Word.Document"</xsl:processing-instruction>
    <w:wordDocument>
      <xsl:apply-templates/>
    </w:wordDocument>
  </xsl:template>
  <xsl:template match="article">
    <o:DocumentProperties>
      <o:Title>
        <xsl:value-of select="@title"/>
      </o:Title>
    </o:DocumentProperties>
    <w:body>
      <xsl:apply-templates/>
    </w:body>
  </xsl:template>
  <xsl:template match="para">
    <w:p>
      <xsl:apply-templates/>
    </w:p>
  </xsl:template>
  <xsl:template match="para/text()">
    <w:r>
      <w:t>
        <xsl:attribute name="xml:space">preserve</xsl:attribute>
        <xsl:value-of select="."/>
      </w:t>
    </w:r>
  </xsl:template>
  <xsl:template match="image">
    <!-- internal url of the image -->
    <xsl:variable name="url">
      <xsl:text>wordml://</xsl:text>
      <xsl:number count="image" format="00000001"/>
      <xsl:text>.gif</xsl:text>
    </xsl:variable>
    <w:r>
      <w:pict>
        <w:binData w:name="{$url}">
          <xsl:value-of select="ext:EncodeBase64(@src)"/>
        </w:binData>
        <v:shape id="{generate-id()}" style="width:100%;height:auto">
          <v:imagedata src="{$url}" o:title="{@alt}"/>
        </v:shape>
      </w:pict>
    </w:r>
  </xsl:template>
</xsl:stylesheet>

width:100%;height:auto
<report>
  <p>Northwind employees:</p>
  <xi:include 
href="sqlxml://LOCO055/Northwind?query=
SELECT FirstName, LastName FROM Employees FOR XML AUTO"
xmlns:xi="http://www.w3.org/2001/XInclude"/>
</report>

sqlxml://
LOCO055
Northwind
query
public class SqlXmlResolver : XmlUrlResolver {
  static string NorthwindConnString = 
    "Provider=SQLOLEDB;Server={0};
     database={1};Integrated Security=SSPI";
  public override object GetEntity(Uri absoluteUri, 
          string role, Type ofObjectToReturn) {
    if (absoluteUri.Scheme == "sqlxml") {
      //Extract server and database names from the URI
      SqlXmlCommand cmd = 
        new SqlXmlCommand(string.Format(NorthwindConnString, 
        absoluteUri.Host, absoluteUri.LocalPath.Substring(1)));
      cmd.RootTag = "EmployeesList";
      //Extract SQL statement from the URI
      cmd.CommandText = 
        absoluteUri.Query.Split('=')[1].Replace("%20", " ");
      return cmd.ExecuteXmlReader();
    } else
      return base.GetEntity(absoluteUri, role, ofObjectToReturn);
    }
  }
}
sqlxml://
XIncludingReader reader = new XIncludingReader("report.xml");
reader.XmlResolver = new SqlXmlResolver();
XPathDocument doc = new XPathDocument(reader);
...
<report>
  <p>Northwind employees:</p>
  <EmployeesList>
    <Employees FirstName="Nancy" LastName="Davolio"/>
    <Employees FirstName="Andrew" LastName="Fuller"/>
    <Employees FirstName="Janet" LastName="Leverling"/>
    <Employees FirstName="Margaret" LastName="Peacock"/>
    <Employees FirstName="Steven" LastName="Buchanan"/>
    <Employees FirstName="Michael" LastName="Suyama"/>
    <Employees FirstName="Robert" LastName="King"/>
    <Employees FirstName="Laura" LastName="Callahan"/>
    <Employees FirstName="Anne" LastName="Dodsworth"/>
  </EmployeesList>
</report>

/foo/a
b/c
<foo>
    <a>
        <b>
            <c/>
        </b>
    </a>
</foo>
<update match="/books/book[@title='Effective XML']">
    <set-attribute name="on-load" value="Arthur"/>
</update>

href
xpointer
<xi:include href="books.xml#bk101/>
<xi:include href="books.xml" xpointer="bk101"/>
accept, accept-charset and accept-language
class Test {
  static void Main(string[] args) {
    using (FileStream fs = File.Open("log.xml", 
        FileMode.Append, FileAccess.Write, FileShare.Read)) {
        XmlTextWriter writer = new XmlTextWriter(fs, Encoding.ASCII);
        for (int i=0; i<3; i++) {
          writer.WriteElementString("item", "", 
            DateTime.Now.ToString());
          writer.WriteWhitespace("\n");
        }
        writer.Close();
    }
  }
}

log.xml
<item>7/22/2003 11:15:42 AM</item>
<item>7/22/2003 11:15:42 AM</item>
<item>7/22/2003 11:15:42 AM</item>

<item>7/22/2003 11:15:42 AM</item>
<item>7/22/2003 11:15:42 AM</item>
<item>7/22/2003 11:15:42 AM</item>
<item>7/22/2003 11:16:12 AM</item>
<item>7/22/2003 11:16:12 AM</item>
<item>7/22/2003 11:16:12 AM</item>

class Test {
  static void Main(string[] args) {
    using (FileStream fs = File.OpenRead("log.xml")) {
      XmlParserContext context = new XmlParserContext(
        new NameTable(), null, null, XmlSpace.Default);
      XmlTextReader reader = new XmlTextReader(fs, 
        XmlNodeType.Element, context);
      while (reader.Read()) {
        if (reader.NodeType == XmlNodeType.Element) {
          Console.WriteLine("Element: {0}, Value: {1}", 
            reader.Name, reader.ReadElementString());
        }
      }
    }
  }
}

D:\projects\Test2\bin\Debug>Test2.exe
Element: item, Value: 7/22/2003 11:15:42 AM
Element: item, Value: 7/22/2003 11:15:42 AM
Element: item, Value: 7/22/2003 11:15:42 AM
Element: item, Value: 7/22/2003 11:16:12 AM
Element: item, Value: 7/22/2003 11:16:12 AM
Element: item, Value: 7/22/2003 11:16:12 AM 

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="/">
        <xsl:processing-instruction 
name="mso-application">progid="Word.Document"</xsl:processing-instruction>
        <w:wordDocument
xmlns:w="http://schemas.microsoft.com/office/word/2003/2/wordml">
            <w:body>
                <w:p>
                    <w:r>
                        <w:t>Hello Word!</w:t>
                    </w:r>
                </w:p>
            </w:body>
        </w:wordDocument>
    </xsl:template>
</xsl:stylesheet>

<?xml-stylesheet type="text/xsl" href="style.xsl"?>
<chapter title="XSLT Programming">
    <para>It's <i>very</i> simple. Just ask <link
url="http://google.com">Google</link>.</para>
</chapter>

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:o="urn:schemas-microsoft-com:office:office"
xmlns:w="http://schemas.microsoft.com/office/word/2003/2/wordml">
    <xsl:template match="/">
        <xsl:processing-instruction 
name="mso-application">progid="Word.Document"</xsl:processing-instruction>
        <w:wordDocument>
            <xsl:apply-templates/>
        </w:wordDocument>
    </xsl:template>
    <xsl:template match="chapter">
        <o:DocumentProperties>
            <o:Title>
                <xsl:value-of select="@title"/>
            </o:Title>
        </o:DocumentProperties>
        <w:styles>
            <w:style w:type="paragraph" w:styleId="Heading3">
                <w:name w:val="heading 3"/>
                <w:pPr>
                    <w:pStyle w:val="Heading3"/>
                    <w:keepNext/>
                    <w:spacing w:before="240" w:after="60"/>
                    <w:outlineLvl w:val="2"/>
                </w:pPr>
                <w:rPr>
                    <w:rFonts w:ascii="Arial" w:h-ansi="Arial"/>
                    <w:b/>
                    <w:sz w:val="26"/>
                </w:rPr>
            </w:style>
            <w:style w:type="character" w:styleId="Hyperlink">
                <w:rPr>
                    <w:color w:val="0000FF"/>
                    <w:u w:val="single"/>
                </w:rPr>
            </w:style>
        </w:styles>
        <w:body>
            <w:p>
                <w:pPr>
                    <w:pStyle w:val="Heading3"/>
                </w:pPr>
                <w:r>
                    <w:t>
                        <xsl:value-of select="@title"/>
                    </w:t>
                </w:r>
            </w:p>
            <xsl:apply-templates/>
        </w:body>
    </xsl:template>
    <xsl:template match="para">
        <w:p>
            <xsl:apply-templates/>
        </w:p>
    </xsl:template>
    <xsl:template match="i">
        <w:r>
            <w:rPr>
                <w:i/>
            </w:rPr>
            <xsl:apply-templates/>
        </w:r>
    </xsl:template>
    <xsl:template match="text()">
        <w:r>
            <w:t xml:space="preserve"><xsl:value-of 
select="."/></w:t>
        </w:r>
    </xsl:template>
    <xsl:template match="link">
        <w:hlink w:dest="{@url}">
            <w:r>
                <w:rPr>
                    <w:rStyle w:val="Hyperlink"/>
                    <w:i/>
                </w:rPr>
                <xsl:apply-templates/>
            </w:r>
        </w:hlink>
    </xsl:template>
</xsl:stylesheet>

import org.xml.sax.*;
import org.xml.sax.helpers.*;

public class Attrs2ElementsFilter extends XMLFilterImpl {
    public void startElement(String namespaceURI, String localName,
      String qualifiedName, Attributes atts) throws SAXException {
      AttributesImpl newAttributes = new AttributesImpl();
      super.startElement(namespaceURI, localName, 
          qualifiedName, newAttributes); 
      for (int i = 0; i < atts.getLength(); i++) {
          super.startElement("", atts.getLocalName(i), 
              atts.getQName(i), newAttributes);
          super.characters(atts.getValue(i).toCharArray(), 0, 
              atts.getValue(i).length());
          super.endElement("", atts.getLocalName(i), 
              atts.getQName(i));
        }
    }
}

Recently in XML Category

Denial of Service Attacks

Cross-Site Attacks

XSLT Scripts Are Prohibited by Default

The XSLT document Function Is Disallowed by Default

Loading External Files Is Prohibited by Default

Script Blocks

Extension Objects

1.1 Relationship to XLink