Implémentation du processeur XSLT par la classe XslTransform

Article
04/27/2011

Remarque
La classe XslTransform est obsolète dans le .NET Framework version 2.0.Vous pouvez effectuer des transformations XSLT (Extensible Stylesheet Language Transformation) à l'aide de la classe XslCompiledTransform.Pour plus d'informations, voir Utilisation de la classe XslCompiledTransform et Migration depuis la classe XslTransform.

La classe XslTransform est un processeur XSLT qui implémente la recommandation XSL Transformations (XSLT) version 1.0. La méthode Load localise et lit des feuilles de style, et la méthode Transform transforme le document source donné. Tout magasin implémentant l'interface IXPathNavigable peut être utilisé comme document source pour l'objet XslTransform. Le .NET Framework implémente actuellement l'interface IXPathNavigable sur les objets XmlDocument, XmlDataDocument et XPathDocument, de sorte qu'ils peuvent être utilisés comme le document source d'entrée d'une transformation.

L'objet XslTransform du .NET Framework prend uniquement en charge la spécification XSLT 1.0, définie par l'espace de noms suivant :

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

La feuille de style peut être chargée, à l'aide de la méthode Load, à partir de l'une des classes suivantes :

XPathNavigator
XmlReader
Une chaîne représentant une URL

Il existe une méthode Load différente pour chacune des classes d'entrée ci-avant. Certaines méthodes prennent une combinaison de ces classes et la classe XmlResolver comme arguments. L'objet XmlResolver localise les ressources référencées par <xsl:import> ou <xsl:include> trouvées dans la feuille de style. Les méthodes suivantes prennent une chaîne, l'objet XmlReader ou XPathNavigator, comme entrée.

Overloads Public Sub Load(String)

public void Load(string);

Overloads Public Sub Load(String, XmlResolver)

public void Load(string, XmlResolver);

Overloads Public Sub Load(XmlReader, XmlResolver, Evidence)

public void Load(XmlReader, XmlResolver, Evidence);

Overloads Public Sub Load(XPathNavigator, XmlResolver, Evidence)

public void Load(XPathNavigator, XmlResolver, Evidence);

La plupart des méthodes Load illustrées ci-avant prennent un objet XmlResolver comme paramètre. L'objet XmlResolver s'utilise pour charger la feuille de style et toutes les feuilles de style référencées dans les éléments xsl:import et xsl:include.

La plupart des méthodes Load prennent également la preuve comme paramètre. Le paramètre de preuve correspond à l'objet Evidence associé à la feuille de style. Le niveau de sécurité de la feuille de style affecte le niveau de sécurité de toutes les ressources ultérieures qu'elle référence, comme le script qu'elle contient, toute fonction document() qu'elle utilise, et tous les objets d'extension utilisés par l'objet XsltArgumentList.

Si la feuille de style est chargée à l'aide de la méthode Load qui contient un paramètre d'URL et aucune preuve, la preuve de la feuille de style est calculée en combinant l'URL donnée avec son site et sa zone.

Si aucun URI ou aucune preuve n'est fourni, la preuve définie pour la feuille de style est d'un niveau de confiance suffisant. Ne chargez pas de feuilles de style à partir de sources non fiables ou n'ajoutez pas d'objets d'extension non fiables dans l'objet XsltArgumentList.

Pour plus d'informations sur les niveaux de sécurité et les preuves, ainsi que la manière dont celles-ci affectent la création de scripts, voir Écriture de scripts de feuille de style XSLT à l'aide de <msxsl:script>. Pour plus d'informations sur les niveaux de sécurité et les preuves, ainsi que la manière dont celles-ci affectent les objets d'extension, voir XsltArgumentList pour les paramètres de feuille de style et les objets d'extension.

Pour plus d'informations sur les niveaux de sécurité et les preuves, ainsi que la manière dont celles-ci affectent la fonction document(), voir Résolution de feuilles de style XSLT externes et de documents.

Une feuille de style peut être fournie par un nombre de paramètres d'entrée. La feuille de style peut également appeler des fonctions sur des objets d'extension. Tant les paramètres que les objets d'extension sont fournis à la feuille de style à l'aide de la classe XsltArgumentList. Pour plus d'informations sur l'objet XsltArgumentList, voir XsltArgumentList Members.

Utilisation sécurisée recommandée de la classe XslTransform

Les privilèges de sécurité de la feuille de style dépendent de la preuve fournie. Le tableau suivant résume l'emplacement de la feuille de style et donne une explication du type de preuve à fournir.

Scénario	Type de preuve à fournir
La feuille de style XSLT n'a pas de référence externe ou la feuille de style provient d'une base de code auquel vous faites confiance.	Fournissez la preuve à partir de votre assembly : `Dim xslt = New XslTransform() xslt.Load(stylesheet, resolver, Me.GetType().Assembly.Evidence)` `XsltTransform xslt = new XslTransform(); xslt.Load(stylesheet, resolver, this.GetType().Assembly.Evidence);`
La feuille de style XSLT provient d'une source externe. L'origine de la source est connue et il existe un URI vérifiable.	Créez la preuve à l'aide de l'URI. `Dim xslt As New XslTransform() Dim ev As Evidence = XmlSecureResolver.CreateEvidenceForUrl(stylesheetUri) xslt.Load(stylesheet, resolver, evidence)` `XslTransform xslt = new XslTransform(); Evidence ev = XmlSecureResolver.CreateEvidenceForUrl(stylesheetUri); xslt.Load(stylesheet, resolver, evidence);`
La feuille de style XSLT provient d'une source externe. L'origine de la source n'est pas connue.	Attribuez à la preuve la valeur null. Les blocs de script ne sont pas traités, la fonction document() XSLT n'est pas prise en charge et les objets d'extension privilégiés ne sont pas autorisés. En outre, vous pouvez également attribuer la valeur resolver au paramètre null. Vous garantissez ainsi que les éléments xsl:import et xsl:include ne sont pas traités.
La feuille de style XSLT provient d'une source externe. L'origine de la source n'est pas connue, mais vous avez besoin de la prise en charge des scripts.	Demandez une preuve à l'appelant.

Transformation de données XML

Dès qu'une feuille de style est chargée, la transformation démarre en appelant l'une des méthodes Transform et en fournissant un document source d'entrée. La méthode Transform est surchargée pour fournir diverses sorties de transformation. La transformation peut avoir comme résultat l'un des formats de sortie suivants :

XmlReader
XmlWriter
TextWriter
Stream
String URL de fichier

Le dernier format (String URL) prévoit un scénario généralement utilisé consistant à transformer un document d'entrée situé dans une URL et à écrire le document dans l'URL de sortie. Cette méthode Transform est une méthode pratique pour charger un document XML à partir d'un fichier, effectuer la transformation XSLT et écrire la sortie dans un fichier. Il n'est donc pas nécessaire de créer et de charger le document source d'entrée, puis d'écrire dans un flux de fichier. L'exemple de code suivant illustre l'utilisation de la méthode Transform utilisant le String URL en tant qu'entrée et sortie :

Dim xsltransform As XslTransform = New XslTransform()
xsltransform.Load("favorite.xsl")
xsltransform.Transform("MyDocument.Xml", "TransformResult.xml", Nothing)

XslTransform xsltransform = new XslTransform();
xsltransform.Load("favorite.xsl");
xsltransform.Transform("MyDocument.xml", "TransformResult.xml", null);

Transformation d'une section d'un document XML

Les transformations s'appliquent à l'ensemble du document. En d'autres termes, si vous passez dans un autre nœud que le nœud racine du document, cela n'empêche pas le processus de transformation d'accéder à tous les nœuds dans le document chargé. Pour transformer un fragment d'arbre résultat, vous devez créer un objet XmlDocument contenant uniquement le fragment d'arbre résultat et passer l'objet XmlDocument à la méthode Transform. L'exemple suivant effectue une transformation sur un fragment d'arbre résultat.

Dim xslt As New XslTransform()
xslt.Load("print_root.xsl")
Dim doc As New XmlDocument()
doc.Load("library.xml")
' Create a new document containing just the result tree fragment.
Dim testNode As XmlNode = doc.DocumentElement.FirstChild
Dim tmpDoc As New XmlDocument()
tmpDoc.LoadXml(testNode.OuterXml)
' Pass the document containing the result tree fragment 
' to the Transform method.
Console.WriteLine(("Passing " + tmpDoc.OuterXml + " to print_root.xsl"))
xslt.Transform(tmpDoc, Nothing, Console.Out, Nothing)

XslTransform xslt = new XslTransform();     
xslt.Load("print_root.xsl");
XmlDocument doc = new XmlDocument();
doc.Load("library.xml");
// Create a new document containing just the result tree fragment.
XmlNode testNode = doc.DocumentElement.FirstChild; 
XmlDocument tmpDoc = new XmlDocument(); 
tmpDoc.LoadXml(testNode.OuterXml);
// Pass the document containing the result tree fragment 
// to the Transform method.
Console.WriteLine("Passing " + tmpDoc.OuterXml + " to print_root.xsl");
xslt.Transform(tmpDoc, null, Console.Out, null);

L'exemple utilise les fichiers library.xml et print_root.xsl comme entrée et écrit ce qui suit dans la console.

Passing <book genre="novel" ISBN="1-861001-57-5"><title>Pride And Prejudice</title></book> to print_root.xsl 
Root node is book.

library.xml

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

print_root.xsl

<stylesheet version="1.0" xmlns="http://www.w3.org/1999/XSL/Transform" >
  <output method="text" /> 
  <template match="/">
     Root node is  <value-of select="local-name(//*[position() = 1])" /> 
  </template>
</stylesheet>

Migration de XSLT depuis le .NET Framework version 1.0 vers le .NET Framework version 1.1

Le tableau suivant illustre les méthodes obsolètes .NET Framework version 1.0 et les nouvelles méthodes .NET Framework version 1.1 pour la méthode Load. Les nouvelles méthodes vous permettent de limiter les autorisations de la feuille de style en spécifiant une preuve.

Méthodes Load obsolètes du .NET Framework version 1.0	Méthodes Load de remplacement du .NET Framework version 1.1
Load(entrée XPathNavigator) Load(entrée XPathNavigator, programme de résolution XmlResolver)	Load(feuille de style XPathNavigator, programme de résolution XmlResolver, preuve Evidence)
Load(feuille de style IXPathNavigable) Load(feuille de style IXPathNavigable, programme de résolution XmlResolver)	Load(feuille de style IXPathNavigable, programme de résolution XmlResolver, preuve Evidence)
Load(feuille de style XmlReader) Load(feuille de style XmlReader, programme de résolution XmlResolver)	Load(feuille de style XmlReader, programme de résolution XmlResolver, preuve Evidence)

Load(entrée XPathNavigator)

Load(entrée XPathNavigator, programme de résolution XmlResolver)

Load(feuille de style XPathNavigator, programme de résolution XmlResolver, preuve Evidence)

Load(feuille de style IXPathNavigable)

Load(feuille de style IXPathNavigable, programme de résolution XmlResolver)

Load(feuille de style IXPathNavigable, programme de résolution XmlResolver, preuve Evidence)

Load(feuille de style XmlReader)

Load(feuille de style XmlReader, programme de résolution XmlResolver)

Load(feuille de style XmlReader, programme de résolution XmlResolver, preuve Evidence)

Le tableau suivant illustre les méthodes obsolètes et nouvelles pour la méthode Transform. Les nouvelles méthodes prennent un objet XmlResolver.

Méthodes Transform obsolètes du .NET Framework version 1.0	Méthodes Transform de remplacement du .NET Framework version 1.1
XmlReader Transform(entrée XPathNavigator, argument XsltArgumentList)	XmlReader Transform(entrée XPathNavigator, argument XsltArgumentList, programme de résolution XmlResolver)
XmlReader Transform(entrée IXPathNavigable, argument XsltArgumentList)	XmlReader Transform(entrée IXPathNavigable, argument XsltArgumentList, programme de résolution XmlResolver)
Void Transform(entrée XPathNavigator, argument XsltArgumentList, sortie XmlWriter)	Void Transform(entrée XPathNavigator, argument XsltArgumentList, sortie XmlWriter, programme de résolution XmlResolver)
Void Transform(entrée IXPathNavigable, argument XsltArgumentList, sortie XmlWriter)	Void Transform(entrée IXpathNavigable, argument XsltArgumentList, sortie XmlWriter, programme de résolution XmlResolver)
Void Transform(entrée XPathNavigator, argument XsltArgumentList, sortie TextWriter)	Void Transform(entrée XPathNavigator, argument XsltArgumentList, sortie TextWriter, programme de résolution XmlResolver)
Void Transform(entrée IXPathNavigable, argument XsltArgumentList, sortie TextWriter)	Void Transform(entrée IXPathNavigable, argument XsltArgumentList, sortie TextWriter, programme de résolution XmlResolver)
Void Transform(entrée XPathNavigator, argument XsltArgumentList, sortie Stream)	Void Transform(entrée XPathNavigator, argument XsltArgumentList, sortie Stream, programme de résolution XmlResolver)
Void Transform(entrée IXPathNavigable, argument XsltArgumentList, sortie Stream)	Void Transform(entrée IXPathNavigable, argument XsltArgumentList, sortie Stream, programme de résolution XmlResolver)
Void Transform(entrée String, sortie String)	Void Transform(entrée String, sortie String, programme de résolution XmlResolver)

La propriété XslTransform.XmlResolver est obsolète dans le .NET Framework version 1.1. Utilisez à la place les nouvelles surcharges Transform qui prennent un objet XmlResolver.