XML PDF

http://www.labo-dotnet.
com
XML XSL XSD

SUPINFO DOT NET TRAINING COURSE
Auteur : Guillaume de Vinzelles

Version 1.1 – 4 septembre 2003
Nombre de pages : 43
Ecole Supérieure d’Informatique de Paris

23. rue Château Landon 75010 – PARIS
www.supinfo.com
XML XSL XSD 2 / 43
Table des matières
1. HISTORIQUE ET PRESENTATION............................................................................................................. 3
1.1. CONTEXTE HISTORIQUE................................................................................................................................. 3
1.2. LES STANDARDS ASSOCIES ............................................................................................................................ 6
2. XML.................................................................................................................................................................... 8
2.1. SYNTAXE DU XML ....................................................................................................................................... 8
2.2. ELEMENTS................................................................................................................................................... 10
2.3. ATTRIBUTS .................................................................................................................................................. 12
2.4. VALIDATION ............................................................................................................................................... 12
2.5. NAMESPACES .............................................................................................................................................. 13
2.6. CDATA ...................................................................................................................................................... 13
2.7. ENCODAGE .................................................................................................................................................. 14
3. XSL ................................................................................................................................................................... 15
3.1. SYNTAXE GENERALE ................................................................................................................................... 15
3.2. UN PREMIER EXEMPLE................................................................................................................................. 15
3.3. TEMPLATES ................................................................................................................................................. 18
3.4. VARIABLES ET PARAMETRES ....................................................................................................................... 22
3.5. TESTS ET BOUCLES ...................................................................................................................................... 24
3.6. COPIE .......................................................................................................................................................... 26
3.7. CREATION DYNAMIQUE ............................................................................................................................... 26
4. XSD................................................................................................................................................................... 28
4.1. QU’EST CE QU’UN SCHEMA XML ? ............................................................................................................. 28
4.2. POURQUOI UTILISER LES SCHEMAS XML ? ................................................................................................. 28
4.3. UN PREMIER EXEMPLE................................................................................................................................. 29
4.4. SCHEMA ...................................................................................................................................................... 30
4.5. LES ELEMENTS SIMPLES (SIMPLE ELEMENT). .............................................................................................. 31
4.6. LES ELEMENTS COMPLEXES (COMPLEX ELEMENT). .................................................................................... 31
4.7. ELEMENT ..................................................................................................................................................... 31
4.8. ATTRIBUTE .................................................................................................................................................. 32
4.9. ATTRIBUTEGROUP ....................................................................................................................................... 32
4.10. COMPLEXTYPE ............................................................................................................................................ 33
4.11. SIMPLETYPE ................................................................................................................................................ 34
4.12. GROUP ......................................................................................................................................................... 34
4.13. ANY ............................................................................................................................................................. 35
4.14. ANYATTRIBUTE........................................................................................................................................... 35
4.15. KEY ............................................................................................................................................................. 36
4.16. UN EXEMPLE COMPLET ............................................................................................................................... 36
5. LES OUTILS XML DE VISUAL STUDIO .NET ....................................................................................... 41
5.1. MANIPULATION DE FICHIER XML............................................................................................................... 41
5.2. MANIPULATION DE SCHEMA XSD............................................................................................................... 42
http://www.labo-dotnet.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
XML XSL XSD 3 / 43
1. Historique et présentation
1.1. Contexte historique
Le développement de XML a commencé en 1996 par le XML Working Group formé sous les auspices
du World Wide Web Consortium (W3C). Il était présidé par Jon Bosak de Sun Microsystems avec la
participation active du XML Special Interest Group également organisé par le W3C. La première
recommandation date de février 1998.
Les objectifs de conception de XML étaient les suivants :
• XML sera utilisable sans difficulté sur Internet
• XML soutiendra une grande variété d'applications
• XML sera compatible avec SGML
• Il sera facile d'écrire des programmes traitant les documents XML
• Le nombre d'options dans XML doit être réduit au minimum, idéalement à aucune
• Les documents XML devraient être lisibles par l'homme et raisonnablement clairs
• La conception de XML devrait être préparée rapidement
• La conception de XML sera formelle et concise
• Il sera facile de créer des documents XML
• La concision dans le balisage de XML est de peu d'importance
On peut consulter la documentation du W3C à l’adresse suivante : www.w3.org

Des informations spécifiques sur le XML peuvent être trouvées sur www.w3.org/XML/.
Des informations spécifiques sur le XSL peuvent être trouvées sur www.w3.org/XSL/.
Des informations spécifiques sur le XSD peuvent être trouvées sur www.w3.org/XML/Schema.
1.1.1. SGML
SGML (Standard Generalized Markup Language) (ISO 8879) est une norme internationale adoptée
dès 1986 pour apporter une réponse à des problèmes bien connus :
• Données consultées par une population d'utilisateurs hétérogènes
• Données complexes comportant des liens dynamiques
• Données susceptibles d'être souvent modifiées
• Données nécessaires à l'entreprise et à longue durée de vie
• Données de nature à être transposées sous divers formats d'édition
SGML dissocie la structure d'un texte de sa présentation physique. A ce titre, il permet de mieux
hiérarchiser et conserver vos données. Cette norme repose sur le principe du marquage des éléments
qui définissent la structure logique d'un texte, c'est à dire tous les éléments extérieurs au contenu d'un
texte, titre ou liste par exemple, qui concourent à sa structure.
Imaginons par exemple un ouvrage qui porte le titre « Le langage XML » :
<titre>Le langage XML</titre>
Comme vous pouvez le constater, tous les attributs typographiques sont écartés de cette représentation.
Le texte est systématiquement marqué par une chaîne de balises entre des caractères "inférieur" et
"supérieur" qui énoncent seulement que l’élément structurel <titre> est le titre de l’ouvrage.
Intérêts du SGML :
• Portabilité
• Standard ISO
• Nombreux logiciels
XML XSL XSD 4 / 43
• Séparation des données de la présentation

• Modularité, réutilisabilité
• Basé sur un ensemble de règles et pas sur un jeu de tags figé.
Inconvénients du SGML :
• La complexité du SGML engendre des coûts importants d'étude de mise en œuvre et maintenance.
1.1.2. HTML
Un document HTML (Hypertext Markup Language) est constitué de tags définissant la structure de la
page, et de texte définissant le contenu ou le comportement du document.
Par exemple :
<HTML>
<BODY>
<P><FONT COLOR="#000000">Hello World !</FONT></P>
</BODY>
</HTML>
Le corps du document contient sous forme de tags la structure et le contenu de ce qui sera affiché au
travers un navigateur.
Intérêts du HTML :
• Portabilité
• Nombreux logiciels bon marché, voire gratuits
• Nombreux plugs-in permettant l'exécution (affichage ou audition) de données multimédia, images,
…
• Apprentissage aisé
• Base d'information importante
• Navigateurs puissants, faciles d'utilisation
• Liens hypertexte
Inconvénients du HTML :
• Le jeu de balises est figé
• Le document HTML regroupe les données leur représentation et leur comportement
1.1.3. XML
XML est directement issu de SGML, comme HTML. XML est une forme simplifiée de SGML. La
complexité du SGML l'a cantonné à des applications marginales, ne pouvant être mis en œuvre que
par des experts. Le XML, tout en étant conforme à la norme SGML en conserve néanmoins 80% des
fonctionnalités pour seulement 20% de complexité, ce qui le met à la portée du plus grand nombre.
XML est l'acronyme de eXtensible Markup Language, ce n'est pas un langage sémantiquement figé
comme peut l'être HTML mais au contraire un langage ouvert. L'auteur d'un document XML peut
créer ses propres balises. Contrairement à l’usage avec HTML, on emploiera le terme « élément » à la
place des termes « balise » et « tag ». Cette distinction met en évidence la nature plus structurée de
XML par rapport à HTML.
Par exemple, l’élément <INSTRUMENT> peut être utilisé pour désigner un instrument de musique :
<INSTRUMENT>Guitare</INSTRUMENT>
XML XSL XSD 5 / 43
La structure typique d'un document XML exclut toutes les balises de mise en page que l'on trouve en
HTML. Un document XML ne contient que des données sans mise en forme. La présentation physique
du document est réalisée par une feuille de style dans le cas où le document doit être visualisé.
Utilisation d’éléments XML pour décrire un véhicule par exemple :
<ANNEE>, <CHASSIS>, <MOTEUR>, <COULEUR>, ...
Les données pouvant être structurées, on définit un enregistrement MOTEUR de la façon suivante :
<MOTEUR>
<PUISSANCE>......</PUISSANCE>
<CYLINDREE>......</CYLINDREE>
<CARBURANT>......</CARBURANT>
</MOTEUR>
Grâce à la structure hiérarchisée des éléments, un document XML peut être représenté sous forme
d'arbre :
VEHICULE
ANNEE CHASSIS MOTEUR COULEUR
PUISSANCE CYLINDREE CARBURANT
Et voici le document XML associé :

<VEHICULE>
<ANNEE>1998</ANNEE>
<CHASSIS>12542578FDGR12F</CHASSIS>
<MOTEUR>
<PUISSANCE>5</PUISSANCE>
<CYLINDREE>1200</CYLINDREE>
<CARBURANT>ESSENCE</CARBURANT>
</MOTEUR>
<COULEUR>BLANCHE</COULEUR>
</VEHICULE>
Dans un document XML, l'information étant structurée dans des éléments portant des noms
significatifs, il est plus facile de retrouver l'information en utilisant le nom de ces éléments pour
effectuer des recherches précises.
Intérêts du XML :
• Portable, gratuit, rapide et facile à apprendre.
• Extensible, Compatible HTML, SGML
• Indépendant des éditeurs.
• Nombreux logiciels bon marché, voire gratuits
Inconvénients du XML :
• Plus volumineux que de simples fichiers txt ou autre format propriétaire compressé.
XML XSL XSD 6 / 43
1.2. Les standards associés

XML est un métalangage de balises extensible et dispose d'une syntaxe permettant de créer des
langages déclaratifs. Ces mécanismes ont permis de créer des langages complémentaires permettant de
décrire en XML le contenu (la grammaire du document XML ou schéma), le format d'affichage ou
d'impression (les styles ou XSL) et le comportement d'un document XML.
1.2.1. XSL
Le langage XSL (eXtended Style Language) permet de décrire (en XML) le format d'affichage d'un
document et permet également d'effectuer la transformation des données.
De la même manière que le CSS est un complément du HTML permettant de décrire la manière dont
certains éléments doivent s'afficher, les feuilles de style permettent de décrire le format d'affichage des
documents XML.
Le langage XSL, permet d'aller beaucoup plus loin que la simple application d'un style sur un élément.
XSL est un langage permettant de transformer un document XML de données en une page HTML par
exemple. Une simple transformation permet de changer l'ordre des colonnes d'un tableau ou bien
d'afficher la même grappe de données en formulaire.
XML + XSL = XML ou XML + XSL = HTML ou XML + XSL = WML ou …
Fichier accueil.xml :
<?xml:stylesheet type="text/xsl" href="accueil.xsl"?>
<document>
<sortie>Au revoir!</sortie>
<entree>Bonjour</entree>
</document>
Fichier accueil.xsl :
<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<xsl:template match="/">
<xsl:apply-templates select="document"/>
</xsl:template>
<xsl:template match="document">
<p><b><xsl:value-of select="entree"/></b></p>
<p><xsl:value-of select="sortie"/></p>
</xsl:template>
</xsl:stylesheet>
1.2.2. XPath
XPath est un langage permettant l'adressage des parties d'un document XML et, conçu pour être
employé par XSLT et XPOINTER
1.2.3. XHTML
XHTML 1.0 est une re-formulation de HTML 4 en tant qu'application de XML 1.0. Un document
XHTML est un document HTML respectant la syntaxe XML : toutes les balises doivent être fermées.
La sémantique des éléments et leurs attributs est définie par le W3C.
1.2.4. DTD et XSD

Le DTD (Document Type Definition) provient de la norme SGML et permet de définir les éléments,
attributs et entités d'un document mais aussi la structure du document, l'ordre et les relations entre les
éléments. Les définitions de type de document (DTD) ont rapidement laissé apparaître des carences
dans le domaine des contraintes de structures et de données.
De plus, la syntaxe des DTD est issue du langage EBNF (Extended Backus Naur Form), beaucoup
plus compliqué et lourd que ne l'est le langage XML.
L'universalité du langage XML requiert la création d'un ensemble d'applications verticales allant de la
définition des documents (XSD), en passant par leur structuration et composition (XML) et jusqu'à
leur présentation à l'utilisateur final (XSL). L'adoption d'un langage de définition des documents basé
sur XML, était donc inévitable afin de conserver une homogénéité dans la chaîne de création de
documents.
La fonctionnalité la plus remarquable des schémas XML est la prise en charge des types de données
garantissant le contenu à affecter à un élément XML et apportant une validation plus efficace, non
seulement sur la structure du document, mais aussi sur son contenu. Ainsi, une balise destinée à
accueillir une date sera définie comme telle dans le schéma et par la suite sera en mesure de délivrer sa
valeur à un programme sans soucis de conversion d'une chaîne de caractères en date.
Le modèle de contenu devient davantage exhaustif avec les schémas XML qu'il ne l'était auparavant
avec les DTD. En effet, outre que les schémas définissent tous les éléments et la structure constituant
un document XML, ils déterminent également le nombre d'occurrences des éléments, gèrent les
contenus mixtes, les éléments nommés, les groupes d'attributs ainsi que des annotations utilisés pour la
création d'une documentation à propos du modèle de contenu.
L'extensibilité des définitions des documents apportée par les schémas XML, facilite l'échange, la
fusion ou la réutilisation de données provenant d'une ou plusieurs sources.
La génération dynamique de documents XML et du modèle de contenu associé, devient alors
beaucoup plus commode.
1.2.5. DOM
Le DOM (Document Object Model) donne une représentation objet d'un document XML et fournit
une API permettant de manipuler les éléments d'un document par programmation. Tous les objets d'un
document sont accessibles par le programme. Le standard DOM définit les méthodes d'accès aux
objets d'un document.
XML XSL XSD 8 / 43
2. XML
2.1. Syntaxe du XML
2.1.1. Un exemple de document XML
Les documents XML utilisent une syntaxe simple et auto descriptive.
<?xml version="1.0" encoding="ISO-8859-1"?>
<note>
<to>skyce</to>
<from>Ben</from>
<heading>Rappel</heading>
<body>N’oublie pas la réunion pour le développement du site du
labo !</body>
</note>
La première ligne de ce document – la déclaration XML – définit la version XML utilisée et
l’encodage des caractères du document. Dans ce cas le document se conforme à la spécification 1.0 du
XML et utilise le jeu de caractères ISO-8859-1 (Latin-1/West European).
De plus, il permet de préciser si le document contient des références externes.
La ligne suivante décrit l’élément racine du document :
<note>
Les quatre lignes suivantes décrivent les quatre éléments de la racine (to, from, heading, et body):
<to>skyce</to>
<from>Ben</from>
labo !</body>
Pour finir, la dernière ligne définit la fin de l’élément racine :
</note>
2.1.2. Balises Fermantes

Tous les éléments XML doivent avoir une balise fermante.
Avec XML, il est illégal d’omettre la balise fermante.
Avec l’HTML, certains éléments n’ont pas de balise fermante. Le code suivant est correct en HTML :
<p>Ceci est un paragraphe
<p>Ceci est un autre paragraphe
En XML tous les éléments doivent avoir des balises fermantes, comme ceci :
<p>Ceci est un paragraphe</p>
<p>Ceci est un autre paragraphe</p>
Note : vous avez sans doute remarqué dans l’exemple précédent que la déclaration XML n’avait pas
de balise fermante. Ce n’est pas une erreur. La déclaration ne fait pas partie du document XML lui-
même. Ce n’est pas un élément XML, et pour cette raison, n’a pas de balise fermante.
2.1.3. Casse
A la différence du HTML, les balises XML sont sensibles à la casse.
Ainsi en XML, la balise <Lettre> est différente de la balise <lettre>.
XML XSL XSD 9 / 43
Les balises ouvrantes et fermantes doivent respecter la même casse :

<Message>Ceci n’est pas correct</message>
<message>Ceci est correct</message>
2.1.4. Imbrication
Tous les éléments XML doivent être correctement imbriqués.
En HTML, les éléments peuvent être imbriqués de façon incorrecte comme ceci :
<b><i>Ce texte est gras et italique</b></i>
En XML, tous les éléments doivent être imbriqués correctement les uns dans les autres :
<b><i> Ce texte est gras et italique</i></b>
2.1.5. Balise Racine

Tous les documents XML doivent avoir une balise racine, qui est également le premier élément du
document XML. Dans tous les documents XML, une seule paire de balise permet de définir l’élément
racine, tous les autres éléments doivent être imbriqués dans cet élément.
Tous les éléments peuvent avoir des sous éléments (enfants). Les sous éléments doivent être
correctement imbriqués dans les éléments parents.
<racine>
<enfant>
<sous-enfant>.....<sous-enfant>
</enfant>
</racine>
2.1.6. Valeur des Attributs

Les valeurs des attributs doivent toujours être entre guillemet.
Les éléments XML peuvent avoir des attributs formés d’une paire nom/valeur comme en HTML. En
XML, la valeur de l’attribut doit toujours être entre guillemet :
<note date="12/11/99">
<to>skyce</to>
<from>Ben</from>
labo !</body>
</note>
2.1.7. Espaces
A la différence de l’HTML, en XML, les espaces ne sont pas tronqués
Avec l’HTML, une séquence comme celle-ci :
Hello my name is skyce,
sera affiché ainsi :
Hello my name is skyce,
car l’HTML supprime les espaces surnuméraires.
Les espaces sont définis par les caractères " ", "\t", "\r" et "\n" dans un document XML.
XML XSL XSD 10 / 43
2.1.8. Commentaires en XML

La syntaxe pour écrire des commentaires en XML est similaire à celle de l’HTML :

2.1.9. Caractère spéciaux

Certains caractères sont impossibles à représenter au clavier (espace insécable...) ou dépendent de la
configuration internationale (symboles spécifiques à une langue). On utilise pour cela des codes ISO.
Un code ISO commence toujours par un ampersand ("&") et finit obligatoirement par un point-virgule
(;).
2.2. Eléments
2.2.1. Les documents XML sont extensibles
Les documents XML peuvent être étendus pour contenir plus d’informations. Reprenons l’exemple de
document XML du début.
<note date="12/11/99">
<to>skyce</to>
<from>Ben</from>
labo !</body>
</note>
Imaginons que nous avons développé une application qui utilise les informations contenues dans ce
document XML. Si nous ajoutons des éléments supplémentaires, comme ceci :
<note date="12/11/99">
<note hour="22:05:23">
<to>skyce</to>
<from>Ben</from>
labo !</body>
</note>
Notre application XML continuera à fonctionner sans problème car les documents XML sont
extensibles.
2.2.2. Les éléments XML sont liés

Les éléments XML sont liés comme parents et enfants. Pour comprendre la terminologie XML, il est
nécessaire de savoir comment les relations entre les éléments XML sont nommées, et comment le
contenu de l’élément est décrit.
Voici par exemple la description d’un livre, que l’on souhaiterait traduire sous forme d’un document
XML :
XML XSL XSD 11 / 43
Titre du livre : Mon premier XML

Chapitre 1 : Introduction au XML
Qu’est ce que l’HTML ?
Qu’est ce que le XML ?
Chapitre 2 : Syntaxe du XML
Les éléments doivent avoir des balises fermantes
Les éléments doivent être correctement imbriqués
Voici le document XML correspondant :

<livre>
<titre>Mon premier XML</titre>
<prod id="33-657" media="papier"></prod>
<chapitre> Introduction au XML
<para> Qu’est ce que l’HTML ?</para>
<para> Qu’est ce que le XML ?</para>
</chapitre>
<chapitre>Syntaxe du XML
<para> Les éléments doivent avoir des balises
fermantes</para>
<para> Les éléments doivent être correctement
imbriqués</para>
</chapitre>
</livre>
‘livre’ est l’élément racine. ‘titre’, ‘prod’ et ‘chapitre’ sont des éléments enfants de ‘livre’. ‘livre’ est
l’élément parent de ‘titre’, ‘prod’ et ‘chapitre’. ‘titre’, ‘prod’ et ‘chapitre’ sont des éléments frères car
ils ont le même parent.
2.2.3. Les éléments XML peuvent être de types différents

Un élément XML est constitué d’une balise ouvrante, d’un contenu et d’une balise fermante.
Le contenu d’un élément XML peut être un élément, un contenu mixte, un contenu simple ou un
contenu vide. Un élément peut également avoir des attributs.
Dans l’exemple précédent, ‘livre’ a un contenu de type élément, car il contient d’autres éléments.
‘chapitre’ a un contenu mixte car il contient à la fois du texte et d’autres éléments. ‘para’ a un contenu
simple (ou de type texte) car il ne contient que du texte. ‘prod’ a un contenu vide, car il ne contient pas
d’informations. Dans l’exemple précédent, seul l’élément ‘prod’ a des attributs. L’attribut nommé ‘id’
a la valeur ‘33-657’ et l’attribut nommé ‘media’ a la valeur ‘papier’.
2.2.4. Noms des éléments

Les noms des éléments XML doivent suivre ces règles :
• ils peuvent contenir des lettres, des numéros, et d’autres caractères spéciaux
• ils ne doivent pas commencer avec un nombre ou un caractère de ponctuation
• ils ne peuvent contenir d’espaces.
En créant vos noms d’éléments XML, veillez à suivre ces règles simples :
Tous les noms peuvent être utilisés, il n’y a pas de mots réservés, mais il convient d’utiliser des noms
descriptifs.
XML XSL XSD 12 / 43
Il faut éviter d’utiliser ‘-’ et ‘.’, cela peut poser des problèmes car le logiciel peut tenter de réaliser des
soustractions ou considérer que le nom trouvé après le point est la méthode d’un objet. Les
underscores sont pratiques pour faire des séparations.
Exemples : <nom_auteur>, <couleur_carrosserie>

Le nom des éléments peut être aussi long que vous le souhaitez, mais il est inutile d’exagérer. Les
documents XML sont souvent extraits de bases de données. Il est souvent pertinent d’utiliser le nom
des champs de la base pour créer le nom des éléments.
Les lettres non anglo-saxonnes comme éèà sont parfaitement autorisés en XML, mais le logiciel utilisé
pour parser le document ne les supportera pas forcément.
Le caractère ‘:’ ne doit pas être utilisé pour nommer des éléments car il est utilisé avec les
namespaces, que nous verrons plus tard.
2.3. Attributs
Un élément peut contenir plusieurs attributs, en effet à partir d’une balise ouvrante (<element …>) on
peut affecter un ou plusieurs attributs à l’élément. Aussi, on ne retrouvera pas d’attributs
accompagnant de balises fermantes. Ceci est valable pour les éléments vides.
Exemple:
<prod id="33-657" media="papier"></prod>
Il existe trois types d’attributs :
• Un type chaîne peut prendre la valeur de toute chaîne littérale
• Une série de types prédéfinis (aussi appelés types atomiques) subissent différentes contraintes
lexicales et sémantiques
• Les types énumérés peuvent prendre une valeur parmi une liste de valeurs fournie dans la
déclaration.
•
Quelles sont les limitations des attributs ?
• Les attributs ne sont pas faciles à étendre
• Les attributs ne peuvent pas décrire de structures
• Les attributs sont plus difficiles à manipuler par programmation que les éléments enfants
2.4. Validation
Un document XML est bien formé si :
• Le document XML est construit selon la structure logique : déclaration, élément racine, arbre
d’éléments et d’attributs, commentaires.
• Le document XML doit respecter les contraintes de formes, c’est-à-dire la hiérarchie des éléments
XML. Une balise ouverte avant une deuxième se doit d’être fermée avant et d’éviter les
chevauchements d’éléments.
• Le document n’utilise pas de DTD ou de XSD et que sa structure est conforme à XML.
Un document XML est valide si :

• Si il s’agit d’un document XML bien formé, qui se conforme également aux règles d’un
Document Type Definition (DTD) ou, désormais d’un XML Schema Definition (XSD)
Voici un exemple de document XML qui est bien formé, et qui fait une référence à un DTD, et qui est,
de ce fait, valide.
XML XSL XSD 13 / 43

<!DOCTYPE note SYSTEM "InternalNote.dtd">
<note date="12/11/99">
<to>skyce</to>
<from>Ben</from>
labo !</body>
</note>
2.5. Namespaces
Les namespaces XML fournissent une méthode qui permet d’éliminer les conflits de nom d’éléments.
Les namespaces, ou domaine de noms XML, correspondent à une collection de noms uniques
identifiée par une URI (Uniform Ressource Identifiers).
Une URI représente toutes les syntaxes identifiant une ressource internet. La ressource Internet la plus
utilisée est URL (Uniform Ressource Locators).
Notez que l’adresse n’est utilisée que pour identifier le namespace, elle n’est pas utilisée par le parser
pour quelque opération que ce soit. Le seul but est de donner un nom unique au namespace. Toutefois,
il n’est pas rare que l’URL mentionné pointe vers une véritable page web contenant des informations
sur le namespace.
Le nom d’un namespace apparaît sous la forme d’un préfixe de namespaces et d’un nom local qui sont
séparés par le caractère « : ». Le préfixe qui pointe sur une URI, sélectionne le namespace. Cette
technique garantit ainsi l’unicité des identificateurs dans le document XML.

<x:Screen
xmlns:x="http://www.labo-dotnet.com"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<x:TabControl>
<Tabs>
<Tab>
<Caption>Organisation</Caption>
</Tab>
</Tabs>
</x:TabControl>
</x:Screen>
Un ‘namespace’ est déclaré par l’attribut xmlns. La syntaxe est la suivante :
<element xmlns :prefixe=URI>
2.6. CDATA
La totalité du document XML est interprété (« parsé ») par le logiciel qui doit traiter les données
contenues dans ce document.
Quand on veut, pour une raison ou une autre, intégrer du code qui ne sera pas interprété par le logiciel
on utilise un CDATA dont voici un exemple :
<script>
<![CDATA[
function matchwo(a,b)
{
if (a < b && a < 0) then
XML XSL XSD 14 / 43
{
return 1
}
else
{
return 0
}
}
]]>
</script>
Les CDATA peuvent aussi être employé pour faire figurer à l’intérieur d’un document XML des
fragments de texte contenant des caractères spéciaux encodés.
Les CDATA sont intéressants si l’on veut stocker du code HTML ou XML, c'est-à-dire des balises
qui ne doivent pas être interprétées comme faisant partie du document XML lui-même.
2.7. Encodage
Dans un document XML, certains caractères spéciaux ne peuvent pas être accessibles à partir du
clavier. Aussi pour les inclure dans ce document, il est nécessaire de connaître leur valeur dans
l’alphabet unicode.
Le standard UNICODE est basé sur le système d'encodage défini dans la norme ISO 10646, qui elle-
même définit deux méthodes d'encodage à 16 et 32 bits respectivement. Un texte en français encodé
en UNICODE est deux fois plus grand que le même texte encodé en ASCII.
Il existe différents types de codages :
UTF-8 : codage des caractères sur 8 bits est le codage le plus courant, en fait les 128 premiers
caractères sont identiques au codage ASCII, les suivants sont utilisés pour coder le reste d'Unicode en
séquences de 2 à 6 octets.
UTF-16 : ce codage est semblable à UTF-8 mais il utilise une méthode de représentation de 16 plans
suivants les 64 000 caractères représentés comme deux caractères de 16 bits.
ISO-8859-1 : pour plus d'informations vous trouverez la référence Unicode à l'adresse suivante :
http://www.unicode.org
XML XSL XSD 15 / 43
3. XSL
On distingue deux types de feuilles de styles que l’on peut associer aux documents XML : CSS
(Cascading Style Sheets) et XSL (eXtensible Style Language). Les CSS sont utilisées pour des
applications Web, mais cette technique est limitée au niveau de la présentation des données et ne
permet pas d’en réorganiser les éléments. XSL est un outil puissant de transformation, puisqu’en
partant d’un document XML source, on délivre un document XML résultat.
3.1. Syntaxe générale

Le XSL est un langage de transformation, qui peut être associé à un document XML. Cette association
se réalise par l’instruction "xml-stylesheet" et en précisant dans l’URI la feuille de style XSL à utiliser.
Exemple :
<?xml-stylesheet type=”test/xsl” href=”test_xsl.xsl”?>
Nous allons utiliser le document XML suivant dans nos exemples :

<catalogue>
<cd>
<titre>Empire Burlesque</titre>
<artiste>Bob Dylan</artiste>
<pays>USA</pays>
<maison_disque>Columbia</maison_disque>
<prix>10.90</prix>
<annee>1985</annee>
</cd>
<cd>
<titre>Hide your heart</titre>
<artiste>Bonnie Tyler</artiste>
<pays>UK</pays>
<maison_disque>CBS Records</maison_disque>
<prix>9.90</prix>
<annee>1988</annee>
</cd>
<cd>
<titre>Greatest Hits</titre>
<artiste>Dolly Parton</artiste>
<pays>USA</pays>
<maison_disque>RCA</maison_disque>
<prix>9.90</prix>
<annee>1982</annee>
</cd>
</catalogue>
3.2. Un premier exemple

Voici un premier exemple de fichier XSL qui vous éclairera sans doute sur l’utilisation de ces
documents :
<xsl:stylesheet version="1.0"
<html>
<body>
<h2>Ma collection de CD</h2>
XML XSL XSD 16 / 43
<table border="1">
<tr bgcolor="#9acd32">
<th>Titre</th>
<th>Artiste</th>
</tr>
<tr>
<td>.</td>
<td>.</td>
</tr>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Comme le document XSL est lui-même un document XML, le fichier commence avec une déclaration
XML :
La balise
détermine le début de la feuille de style XSL, on remarquera la présence d’un namespace XML.
La balise
sur la troisième ligne défini le nœud qui sera début du ‘template’, un template étant une règle de
transformation interprétée par l’analyseur syntaxique.
Le mot clé
match="/"
associe le ‘template’ à la racine du document XML.
Le reste du document contient la mise en forme elle-même, à l’exception des deux dernières lignes qui
définissent la fin du ‘template’ et du document XML.
Le résultat de la transformation (à l’aide d’IE6 par exemple) aura cette apparence :
Ma collection de CD
Titre Artiste
. .
Et voici le code HTML correspondant :

<h2>Ma Collection de CD</h2>
<table border="1">
<th>Titre</th>
<th>Artiste</th>
</tr>
<tr>
<td>.</td>
<td>.</td>
</tr>
</table>
XML XSL XSD 17 / 43
Il faut maintenant copier les valeurs contenues dans le document XML dans notre tableau. Voyons
comment faire avec la balise
<xsl:value-of>
Cette balise extrait la valeur d’un nœud sélectionné. Elle est utilisée pour ajouter la valeur d’un nœud
XML au flux d’information, après interprétation.
Voici notre exemple avec notre nouvelle balise :
<html>
<body>
<table border="1">
<th>Titre</th>
<th>Artiste</th>
</tr>
<tr>
<td><xsl:value-of select="catalogue/cd/titre"/></td>
<td><xsl:value-of select="catalogue/cd/artiste"/></td>
</tr>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Et voici le résultat obtenu et le code HTML correspondant :

Ma collection de CD
Titre Artiste
Empire Burlesque Bob Dylan

<table border="1">
<th>Title</th>
<th>Artist</th>
</tr>
<tr>
<td>Empire Burlesque</td>
<td>Bob Dylan</td>
</tr>
</table>
Tout n’est pas encore parfait puisque seulement un nœud de notre fichier XML a été copié.
Voyons comment l’on peut généraliser cette copie avec la balise
<xsl:for-each>
Cette balise est utilisée pour sélectionner tous les éléments XML d’un nœud.
Voici notre exemple agrémenté de cette nouvelle balise :
XML XSL XSD 18 / 43
<html>
<body>
<table border="1">
<th>Titre</th>
<th>Artiste</th>
</tr>
<xsl:for-each select="catalogue/cd">
<tr>
<td><xsl:value-of select="titre"/></td>
<td><xsl:value-of select="artiste"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Et voici le résultat obtenu et le code HTML correspondant :
Ma Collection de CD
Titre Artiste
Empire Burlesque Bob Dylan
Hide your heart Bonnie Tyler
Greatest Hits Dolly Parton
Etudions maintenant en détails les différents mots clés aperçus dans ce premier exemple.
3.3. Templates
3.3.1. Templates avec attribut ‘match’
La balise ‘template’ sert à déterminer un gabarit dans lequel on va transformer des éléments du fichier
XML sous une forme que notre logiciel (navigateur ou autre) pourra afficher. Les éléments concernés
du fichier XML sont déterminés par l’attribut ‘match’.
Voici un exemple avec match="cd", ce qui signifie que le ‘template’ sera appliqué à chaque fois qu’un
élément ‘cd’ sera rencontré :
<xsl:template match="cd">
<html>
<body>
<xsl:apply-templates/>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
XML XSL XSD 19 / 43
L’appel à ‘xsl:apply-templates’ indique que l’on souhaite appliquer notre gabarit à cet endroit
spécifique du fichier HTML généré par notre couple XML/XSL.
Attention l’utilisation de la balise ‘xsl:apply-templates’ sans attribut copiera tous les éléments du
fichier XML.
Voici le résultat obtenu sur le fichier XML précédemment évoqué :
On peut voir dans cet exemple que le ‘template’ ne fait pas de distinction entre les éléments. Voyons
comment l’on peut choisir le prochain nœud qui sera affiché :
Il est possible de spécifier sur quels éléments on veut continuer à descendre en utilisant l’attribut select
de ‘xsl:apply-templates’ :
<xsl:apply-templates select="book"/>
Voici toujours notre exemple, cette fois ci avec l’attribut ‘select’ en action :
Et voici le XSL correspondant :

<html>
<body>
<table border="1">
<th>Titre</th>
<th>Artiste</th>
</tr>
<tr>
<td>
XML XSL XSD 20 / 43
<xsl:apply-templates select="title"/>
</td>
<td>
<xsl:apply-templates select="artist"/>
</td>
</tr>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
3.3.2. Template avec attribut name (template nommée)

Si l’attribut ‘name’ est utilisé dans le ‘template’, celui-ci se comportera comme une fonction. La
fonction générée est appelée explicitement par son nom avec l’élément ‘xsl:call-template’.
En voici un exemple qui affiche la conversion de l’Euro vers le Franc du prix de chaque CD.
<xsl:template name="prix_en_francs">
<xsl:value-of select="price*6.55957"/>
</xsl:template>
<html>
<body>
<table border="1">
<th>Titre</th>
<th>Artiste</th>
<th>Prix en Francs</th>
</tr>
<tr>
<td>
</td>
<td>
</td>
<td>
<xsl:call-template name="prix_en_francs">
</xsl:call-template>
</td>
</tr>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Et voici le résultat dans le navigateur :
Outre les règles de style contenues dans le ‘template’ appelé, des paramètres peuvent également êtres
passés par l’intermédiaire des éléments ‘xsl:param’ dans la fonction ‘template’ et ‘xsl:with-param’
dans ‘xsl:call-template’ :
<xsl:template name="conversion">
<xsl:param name="euro"/>
<xsl:param name="rouble"/>
<xsl:if test="$euro"><xsl:value-of select="price*1.014302"/></xsl:if>
<xsl:if test="$rouble"><xsl:value-of select="price*31.70"/></xsl:if>
</xsl:template>
<html>
<body>
<table border="1">
<th>Titre</th>
<th>Artiste</th>
<th>Prix en Euros</th>
<th>Prix en Roubles Russes</th>
</tr>
<tr>
<td>
</td>
<td>
</td>
<td>
<xsl:call-template name="conversion">
<xsl:with-param name="euro" select="price"/>
</td>
<td>
<xsl:call-template name="conversion">
<xsl:with-param name="rouble" select="price"/>
</td>
</tr>
XML XSL XSD 22 / 43
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Voici le résultat de ce traitement dans un navigateur web :
3.4. Variables et paramètres

Il est possible d’utiliser des variables et des paramètres. Les deux sont identiques, excepté que la
valeur d’un paramètre peut être spécifiée par ‘with-param’ ou lors de l’invocation du XSL.
3.4.1. Variables
Voici un exemple de déclaration de variable :
<xsl:variable name="auteur" select="skyce"/>
Reprenons notre fichier XSL et modifions le de manière à utiliser les variables :

<xsl:variable name="firstline">Ma collection de CD</xsl:variable>
<html>
<body>
<h2><xsl:value-of select="$firstline"/></h2>
<table border="1">
<th>Titre</th>
<th>Artiste</th>
</tr>
<tr>
<td>
</td>
<td>
</td>
</tr>
</table>
</body>
</html>
XML XSL XSD 23 / 43
</xsl:template>
</xsl:stylesheet>
Et voici le résultat (assez prévisible) dans le navigateur :
Voici comment on initialise une variable avec la valeur retournée par la fonction position :
<xsl:variable name="Position" select="position()"/>
Voici le même exercice pour l’initialisation d'une variable avec la valeur d'un élément :
<xsl:variable name="Position" select="title"/>
Et enfin, pour l’initialisation d'une variable avec une valeur fixe :
<xsl:variable name="Position">12</xsl:variable>
3.4.2. Paramètres
Déclaration d’un paramètre :
<xsl:template name="conversion">
<xsl:param name="euro" select="euro"/>
<xsl:param name="rouble" select="rouble"/>
<xsl:if test="$euro"><xsl:value-of select="price*1.014302"/></xsl:if>
<xsl:if test="$rouble"><xsl:value-of select="price*31.70"/></xsl:if>
</xsl:template>
L’attribut ‘select’ permet de spécifier la valeur par défaut du paramètre.
On peut se rapporter au 3.3.2 pour plus de détails sur les paramètres.
3.4.3. Valeurs
Pour lire la valeur d’un élément, d’un attribut, d’une variable ou d’un paramètre, il est possible
d’utiliser ‘xsl:value-of’.
Lecture de la valeur d’un élément :
<xsl:value-of select="title"/>
D'un attribut :
<xsl:value-of select="@genre"/>
D’une variable ou paramètre :
<xsl:value-of select="$Position"/>
De même, on peut se rapporter au 3.3.2 pour plus de détails sur la lecture des valeurs.
XML XSL XSD 24 / 43
3.5. Tests et boucles

3.5.1. Tests
‘xsl:if’ permet de tester la présence d’un élément ou d’un attribut, de tester une valeur… Dans
l’exemple suivant, une étoile est ajoutée si l’attribut ‘count’ est présent sur l’élément courant :
<td>
<xsl:value-of select="price"/>
<xsl:if test="@count">*</xsl:if>
</td>
Dans l’exemple suivant, une étoile est ajoutée si la valeur de l’attribut ‘price’ de l’élément courant est
supérieure à 10 :
<html>
<body>
<table border="1">
<th>Titre</th>
<th>Artiste</th>
<th>Prix</th>
<th>Cher?</th>
</tr>
<tr>
<td>
</td>
<td>
</td>
<td>
<xsl:apply-templates select="price"/>
</td>
<td>
<xsl:if test="price > 10">
*
</xsl:if>
</td>
</tr>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Voici le résultat obtenu dans le navigateur :
XML XSL XSD 25 / 43
‘xsl:choose’ reproduit le même fonctionnement que l’instruction case du Pascal ou ‘switch’ du C :

<html>
<body>
<table border="1">
<th>Titre</th>
<th>Artiste</th>
<th>Prix</th>
<th>Evaluation</th>
</tr>
<tr>
<td>
</td>
<td>
</td>
<td>
<xsl:apply-templates select="price"/>
</td>
<td>
<xsl:choose>
<xsl:when test="price > 10">Cher</xsl:when>
<xsl:otherwise>Pas Cher</xsl:otherwise>
</xsl:choose>
</td>
</tr>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Nous pouvons donc afficher une « appréciation » du prix dans la sortie de notre document. Voici le
document après traitement par le navigateur web :
XML XSL XSD 26 / 43
3.5.2. Boucles
Il est possible de déclencher des itérations avec ‘xsl:for-each’. Le contenu de l’élément ‘xsl:for-each’
ci-dessous sera ainsi appliqué autant de fois qu’il a d’éléments ‘titre’ et ‘artiste’ comme fils de
l’élément ‘cd’ :
<xsl:for-each select="catalogue/cd">
<tr>
<td><xsl:value-of select="titre"/></td>
<td><xsl:value-of select="artiste"/></td>
</tr>
</xsl:for-each>
C’est la méthode que nous avons employée pour notre document d’exemple.
3.6. Copie
‘xsl:copy’ permet de copier l'élément courant dans le document transformé. Les attributs et éléments
descendants ne sont pas copiés.
L'exemple suivant permet de copier tous les éléments et attributs d'un document xml :
<xsl:template match="*|@*|comment|pi|text">
<xsl:copy>
<xsl:apply-templates select="*|@*|comment|pi|text"/>
</xsl:copy>
</xsl:template>
3.7. Création dynamique

‘xsl:attribute’ permet de créer un attribut en sortie. Dans l’exemple suivant, un attribut ‘title’ est ajouté
sur l'élément ‘tr’.
<tr>
<xsl:attribute name="title">Genre:
<xsl:value-of select="@genre"/>
</xsl:attribute>
<td>
XML XSL XSD 27 / 43
</td>
<td>
<xsl:value-of select="author"/>
</td>
<td>
<xsl:value-of select="price"/>
<xsl:if test="@count">*</xsl:if>
</td>
</tr>
L'élément créé en réponse ressemblera à ceci :
<tr title="Genre: technical">
...
</tr>
‘xsl:element’ permet de créer un élément :
<xsl:element name="td">
</xsl:element>
Ce qui est équivalent à :
<td>
</td>
Il est possible de générer des commentaires avec ‘xsl:comment’ :
<xsl:comment>Line for book
</xsl:comment>
Un commentaire de ce type sera alors généré :

XML XSL XSD 28 / 43
4. XSD
4.1. Qu’est ce qu’un schéma XML ?
Le but d’un schéma XML est de définir la façon valide de construire des blocs de données XML,
comme un DTD, mais de manière plus souple et plus performante.
Un schéma XML :
• Définit les éléments qui peuvent apparaître dans un document
• Définit les attributs qui peuvent apparaître dans un document
• Définit quels éléments sont les éléments fils
• Définit l’ordre des éléments fils
• Définit le nombre des éléments fils
• Définit si un élément est vide ou peut inclure du texte
• Définit les types de données pour les éléments et les attributs
• Définit les valeurs fixées et par défaut pour les éléments et les attributs.
Les schéma XML sont les successeurs des DTD, notamment car :
• Les XSD sont extensibles
• Les XSD sont plus riches et plus pratiques
• Les XSD sont écrits en XML
• Les XSD supportent les types de données
• Les XSD supportent les ‘namespaces’
4.2. Pourquoi utiliser les schémas XML ?

Pour plusieurs raisons :
Les XSD supportent les types de données :

• Il est plus facile de décrire les contenus autorisés des documents
• Il est plus facile de valider des données
• Il est plus facile de travailler avec des données venant de base de données
• Il est plus facile de déterminer des ‘facets’ (restrictions sur les données)
• Il est plus facile de déterminer des ‘patterns’ (formats de données)
• Il est plus facile de convertir des données de types différents
Les XSD utilisent la syntaxe XML :

• Pas besoin d’apprendre un nouveau langage
• On peut utiliser un éditeur XML pour éditer les XSD
• On peut utiliser un parseur XML pour visualiser un XSD
• On peut manipuler un XSD avec DOM ou XPath
• On peut transformer son XSD avec XSL
Les XSD uniformisent la représentation de l’information. En effet, comme XSD permet de mettre en
conformité la représentation de l’information XML avec un standard universel. Ainsi une date comme
1999-03-11 peut être interpréter comme le 11 Mars 1999 ou le 3 Novembre 1999. Avec un XML
validé par un schéma, on sait que cette date est le 11 Mars 1999.
Les XSD sont extensibles :

• Réutilisation d’un schéma dans un autre
• Création de type de données propres dérivées des types standards
• On peut faire référence à de multiples schémas à partir du même document
XML XSL XSD 29 / 43
4.3. Un premier exemple

Considérons ce document XML simple, nommé ‘note.xml’ :
<note>
<to>skyce</to>
<from>Ben</from>
labo !</body>
</note>
Voici le document XSD ‘note.xsd’ décrivant les éléments du document XML ‘note.xml’ :
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3schools.com"
xmlns="http://www.w3schools.com"
elementFormDefault="qualified">
<xs:element name="note">
<xs:complexType>
<xs:sequence>
<xs:element name="to" type="xs:string"/>
<xs:element name="from" type="xs:string"/>
<xs:element name="heading" type="xs:string"/>
<xs:element name="body" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
L’élément ‘note’ est décrit comme étant de type complexe ‘complex type’ car il contient d’autres
éléments. Les autres éléments (‘to’, ‘from’, ‘heading’, ‘body’) sont décrit comme étant des types
simples ‘simple type’ car il ne contienne pas d’autres éléments. Nous en verrons plus sur les types
simples et complexes dans les chapitres suivants.
Afin de faire référence à un XSD, un document XML doit comporter certaines informations. Voici
notre fichier ‘note.xsd’, correctement complété :
<note
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="note.xsd">
<to>skyce</to>
<from>Ben</from>
labo !</body>
</note>
Voyons à quoi servent les différentes informations contenues dans l’en-tête du fichier XML :
Le fragment suivant:
spécifie le ‘namespace’ par défaut. Cette déclaration indique au validateur de schéma que tous les
éléments utilisés dans le document XML vient du ‘namespace’ "http://www.w3schools.com".
XML XSL XSD 30 / 43
Ce fragment:
indique au validateur de schéma que l’attribut ‘schemaLocation’ que nous utilisons se trouve dans le
‘namespace’ ‘XMLSchema-instance’.
Ce fragment:
xsi:schemaLocation="note.xsd"
indique le chemin du schéma utilisé pour ce document XML.
4.4. schema
L'élément schema encadre une définition de schéma en se comportant comme un élément racine.
<schema
name="schema-name"
xmlns="namespace">
...
</schema>
L'attribut name représente le nom du schéma.
L'attribut xmlns indique un ou plusieurs espaces de noms destinés à être utilisé avec le schéma.
L'élément schema est unique et ne peut posséder de parents. Par contre, il est susceptible de contenir
des éléments enfants tels que ElementType, AttributeType et description.
Les espaces de noms spécifiés utilisant l'attribut xmlns doivent inclure l'espace de noms pour les
éléments de définition du schéma, soit ElementType, AttributeType, etc…
N'importe quel préfixe peut être utilisé, mais il est opportun de créer un espace de nom par défaut pour
le schéma afin d'éviter d'utiliser des préfixes devant les éléments le composant.
L'élément schema dans un schéma XML doit aussi contenir des déclarations d'espaces de noms pour
tous les autres schémas, comme l'espace de noms qui définit les types de données insérés dans le
schéma.
Voici les différentes déclarations contenues dans notre exemple :
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified">
Détaillons ces différentes informations :
xmlns:xs="http://www.w3.org/2001/XMLSchema"
Cette déclaration indique que les éléments, les types de données utilisés dans ce schéma (‘schema’,
‘element’, ‘complexType’, ‘sequence’, ‘string’, ‘boolean’, etc…) viennent du ‘namespace’
« http://www.w3.org/2001/XMLSchema ». Elle précise aussi que tous les éléments et les types de
données qui viennent de ce ‘namespace’ doivent être préfixées avec ‘xs :’.
indique que les éléments définis par ce schéma (note, to, from, heading, body) viennent du
‘namespace’ « http://www.w3schools.com ».
Le fragment
indique que le ‘namespace’ par défaut est « http://www.w3schools.com ».
Enfin, le fragment :
elementFormDefault="qualified"
indique que chaque élément utilisé par l’instance XML de ce document doit être qualifié par un
‘namespace’.
XML XSL XSD 31 / 43
4.5. Les éléments simples (Simple Element).

Un élément simple est un élément XML qui ne contient que du texte. Il ne peut contenir d’autres
éléments ou attributs.
En revanche, la restriction « texte seulement » est assez trompeuse dans le sens où un texte peut être
de types très différents. Cela peut être un de ceux qui sont inclus dans la définition des schémas XML
(boolean, string, date, etc…), ou cela peut également être un type personnalisé.
4.6. Les éléments complexes (Complex Element).

Un élément complexe est un élément XML qui contient d’autres éléments et/ou des attributs.
Il y a quatre types d’éléments complexes :
• Les éléments vides
• Les éléments qui ne contiennent que d’autres éléments
• Les éléments qui ne contiennent que du texte
• Les éléments qui contiennent à la fois d’autres éléments et du texte.
Voici quelques exemples d’éléments complexes :
Un élément complexe “product” qui est vide:

<product pid="1345"/>
Un élément complexe “employee” qui ne contient que d’autres éléments :

<employee>
<firstname>John</firstname>
<lastname>Smith</lastname>
</employee>
Un élément complexe “food” qui ne contient que du texte:

<food type="dessert">Ice cream</food>
Un élément complexe “description” qui contient à la fois texte et éléments:

<description>
It happened on <date lang="norwegian">03.03.99</date> ....
</description>
4.7. element
L'élément element se réfère à un type d'élément déclaré qui peut apparaître à l'intérieur de la portée de
l'élément ElementType nommé.
<element type="Type_Element"
[minOccurs="{0 | 1}"]
[maxOccurs="{1 | *}"]>
</element>
L'attribut type indique le nom d'un élément ElementType défini dans le schéma ou un autre schéma
spécifié par un espace de noms fourni. La valeur donnée doit correspondre à l'attribut name de
l'élément ElementType. Le type peut inclure un préfixe d'espace de noms.
L'attribut minOccurs détermine si l'élément est requis au mois une fois (1) ou ne l'est pas (0).
L'attribut maxOccurs détermine si l'élément doit apparaître au maximum une fois (1) ou un nombre de
fois illimité.
Les attributs minOccurs et maxOccurs ont la valeur 1 par défaut. Un élément sans attribut spécifié
utilise ces valeurs par défaut et par conséquent doit apparaître une seule fois dans un modèle de
contenu.
XML XSL XSD 32 / 43
L'élément element peut posséder un élément parent ElementType ou group, mais aucun élément
enfant.
Les déclarations d'élément ElementType peuvent contraindre le contenu et les attributs qui
apparaissent dans les éléments de type nommé en se référant à d'autres déclarations de types d'élément
ou d'attribut.
4.8. attribute
L'élément attribute permet de représenter un attribut XML dans une définition de schéma.
<xsd:attribute
default = string
fixed = string
form = (qualified | unqualified)
id = ID
name = NCName
ref = QName
type = QName
use = (optional | prohibited | required) : optional
{tout attribut ayant un espace de noms
différent de celui du schéma...}>
Contenu : (annotation?, (simpleType?))
</xsd:attribute>
L'élément attribute possède plusieurs attributs destinés à définir précisément l'attribut d'un élément
XML.
Attributs Description
default précise une valeur par défaut pour l'attribut.
fixed empêche une dérivation par restriction du type de l'attribut.
form indique si l'attribut XML doit être ou non qualifié par un espace de noms.
id précise un identificateur unique pour l'attribut.
name indique le nom de l'attribut XML.
ref spécifie une référence à un autre élément de schéma.
type fournit le type de données accepté par l'attribut.
use indique comment l'attribut doit apparaître.
L'élément attribute ne peut être inclus que dans les éléments suivants :
• attributeGroup
• complexType
• extension
• schema
4.9. attributeGroup
L'élément attributeGroup permet de regrouper la définition de plusieurs attributs XML.
<xsd:attributeGroup
id = ID
name = NCName
ref = QName
Contenu : (annotation?)
</xsd:attributeGroup>
XML XSL XSD 33 / 43
L'élément attributeGroup possède deux attributs destinés à identifier l'élément et à se référer à un

groupe d'attributs XML.
id précise un identificateur unique pour l'élément.
name indique le nom du groupe.
ref indique une référence à un groupe d'attributs.
L'élément attributeGroup ne peut être inclus que dans les éléments suivants :
• attributeGroup
• complexType
• extension
• redefine
• schema
4.10. complexType
L'élément complexType définit un type de données complexe pour des éléments XML.
<xsd:complexType
abstract = booléen : false
block = (#all | Liste de (extension | restriction))
final = (#all | Liste de (extension | restriction))
id = ID
mixed = booléen : false
name = NCName
Contenu : (annotation?, (simpleContent | complexContent |
((group | all | choice | séquence)?,
((attribute | attributeGroup)*, anyAttribute?))))
</xsd:complexType>
L'élément complexType possède plusieurs attributs destinés à définir les caractéristiques du type de
données complexe.
abstract provoque l'abstraction (true) de l'élément XML, devant être remplacé par un autre
élément.
block spécifie une valeur de blocage du type dans des éléments attendant le type de base.
default précise une valeur par défaut pour l'élément.
final empêche la dérivation de type par restriction, extension ou les deux.
mixed indique un contenu mixte (true) ou un contenu à base d'éléments seuls (false) par
défaut.
name indique le nom de l'élément XML.
L'élément complexType ne peut être inclus que dans les éléments suivants :
• element
• redefine
• schema
XML XSL XSD 34 / 43
4.11. simpleType
L'élément simpleType définit un type de données simple pour des éléments XML.
<xsd:simpleType
final = (#all | (list | union | restriction))
id = ID
name = NCName
Contenu : (annotation?, (restriction | list | union))
</xsd:simpleType>
L'élément complexType possède plusieurs attributs destinés à définir les caractéristiques du type de
données simple.
final empêche la dérivation de type par restriction, extension ou les deux.
name indique le nom de l'élément XML.
L'élément simpleType ne peut être inclus que dans les éléments suivants :
• attribute
• element
• list
• redefine
• restriction
• schema
• union
4.12. group
L'élément group permet de définir un groupe d'éléments et d'y faire référence dans un schéma XML.
<xsd:group
id = ID
maxOccurs = (nonNegativeInteger | unbounded) : 1
minOccurs = nonNegativeInteger : 1
name = NCName
ref = QName
Contenu : (annotation? ,
(all | choice | sequence)?)
</xsd:group>
L'élément group possède plusieurs attributs destinés à définir les caractéristiques du groupe
d'éléments.
id précise un identificateur unique pour le groupe.
maxOccurs précise le nombre d'occurrences maximum du groupe. Par défaut, ce nombre est
égal à 1.
minOccurs précise le nombre d'occurrences minimum du groupe. Par défaut, ce nombre est
égal à 1.
name indique le nom du groupe.
ref indique une référence à un groupe d'attributs.
L'élément group ne peut être inclus que dans les éléments suivants :
• choice
XML XSL XSD 35 / 43
• complexType
• redefine
• schema
• sequence
4.13. any
L'élément any représente n'importe quel élément dans un schéma XML.
<xsd:any
id = ID
maxOccurs = (nonNegativeInteger | unbounded) : 1
minOccurs = nonNegativeInteger : 1
namespace = ((##any | ##other)
| Liste de (anyURI | (##targetNamespace | ##local)) )
: ##any
processContents = (lax | skip | strict) : strict
</xsd:any>
L'élément any possède plusieurs attributs destinés à définir précisément l'élément XML.
maxOccurs précise le nombre d'occurrences maximum de l'élément. Par défaut, ce
nombre est égal à 1.
minOccurs précise le nombre d'occurrences minimum de l'élément. Par défaut, ce
nombre est égal à 1.
namespace spécifie un ou plusieurs espaces de noms.
processContents précise le type de processus de contenu.
L'élément any ne peut être inclus que dans les éléments suivants :
• choice
• sequence
4.14. anyAttribute
L'élément anyAttribute représente n'importe quel attribut dans un schéma XML.
<xsd:anyAttribute
id = ID
namespace = ((##any | ##other)
| Liste de (anyURI
| (##targetNamespace | ##local)) )
: ##any
processContents = (lax | skip | strict) : strict
</xsd:anyAttribute>
L'élément anyAttribute possède plusieurs attributs destinés à définir précisément l'attribut XML.
XML XSL XSD 36 / 43
namespace spécifie un ou plusieurs espaces de noms.

processContents précise le type de processus de contenu.
L'élément anyAttribute ne peut être inclus que dans les éléments suivants :
• attributeGroup
• complexType
• extension
4.15. key
L'élément key permet de définir un élément clé dans une structure XML.
<xsd:key
id = ID
name = NCName
Contenu : (annotation?, (selector, field+))
</xsd:key>
L'élément key possède plusieurs attributs destinés à l'identifier et à préciser son nom.
name spécifie un nom pour l'élément.
L'élément key ne peut être inclus que dans l'élément suivant :

element
4.16. Un exemple complet

4.16.1. Un document XML
Jettons un oeil à un document XML nommé ‘shiporder.xml’
<shiporder orderid="889923"
xsi:noNamespaceSchemaLocation="shiporder.xsd">
<orderperson>John Smith</orderperson>
<shipto>
<name>Ola Nordmann</name>
<address>Langgt 23</address>
<city>4000 Stavanger</city>
<country>Norway</country>
</shipto>
<item>
<title>Empire Burlesque</title>
<note>Special Edition</note>
<quantity>1</quantity>
<price>10.90</price>
</item>
<item>
<title>Hide your heart</title>
<quantity>1</quantity>
<price>9.90</price>
</item>
</shiporder>
XML XSL XSD 37 / 43
Le document XML ci-dessus est constitué d’un element racine ‘shiporder’, qui contient un attribute
abligatoire nommé ‘orderid’. L’élément ‘shiporder’ contient trois différents elements fils:
‘orderperson’, ‘shipto’ et ‘item’. L’élément ‘item’ apparaît deux fois, et contient un ‘titre’, un élément
optionnel ‘note’, et les éléments obligatoires ‘quantité’ et ‘prix’.
La ligne ‘xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' signifie que le document
XML doit être validé par un schéma. La ligne ‘xsi:noNamespaceSchemaLocation="shiporder.xsd"’
indique où se trouve le schéma.
4.16.2. Créer un schéma XML

Nous allons maintenant créer un schéma pour le document XML ci-dessus.
Commençons par créer un fichier que nous nommerons "shiporder.xsd". Pour créer le schéma nous
pouvons simplement suivre la structure du document XML et définir chaque élément quand nous le
rencontrons. Nous commençons par la déclaration standard XML, suivie par l’élément ‘xs:schema’ qui
définit un schéma.
<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
...
...
</xs:schema>
Dans le schéma ci-dessus nous utilisons le ‘namespace’ standard (xs) et l’URI associé avec ce
‘namespace’ est la définition du langage de schéma, qui a pour valeur par défaut
‘http://www.w3.org/2001/XMLSchema’.
Ensuite, nous définissons l’élément ‘shiporder’. Cet élément a un attribut et contient d’autres éléments,
et nous le considérons donc comme de type complexe. Les éléments fils de ‘shiporder’ est inclus dans
un élément ‘xs :sequence’ qui définit une séquence ordonnée de sous éléments :
<xs:element name="shiporder">
<xs:complexType>
<xs:sequence>
...
...
</xs:sequence>
...
</xs:complexType>
</xs:element>
Nous avons ensuite à definer l’élément ‘oderperson’ comme un type simple (car il ne contient pas
d’autres attributs ou d’autres éléments). Le type (‘xs:string’) est préfixé avec le ‘namespace’ qui
indique un type de données prédéfini :
<xs:element name="orderperson" type="xs:string"/>
Ensuite nous avons à définir deux éléments qui sont de type complexe : ‘shipto’ et ‘item’. Nous
commençons par définir l’élément ‘shipto’ :
<xs:element name="shipto">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Grâce aux schémas nous pouvons définir le nombre possible d’occurrences pour un élément avec les
attributs ‘maxOccurs’ et ‘minOccurs’. ‘maxOccurs’ spécifie le nombre maximum d’occurrences pour
un élément et ‘minOccurs’ définit le nombre minimum d’occurrences pour un élément. La valeur par
défaut de ces attributs est 1.
XML XSL XSD 38 / 43
Nous pouvons désormais définir l’élement ‘item’. Cet élément peut apparaître plusieurs fois au sein
d’un élément ‘shiporder’. Ceci est spécifié par l’attribut ‘maxOccurs’ qui est fixé à ‘unbounded’ ce qui
signifie qu’il peut y avoir autant d’occurrences de l’élément ‘item’ que l’auteur du schéma le souhaite.
Remarquez que l’élément ‘note’ est optionnel. Nous avons spécifié cela en assignant la valeur 0 à
l’attribut ‘minOccurs’.
<xs:element name="item" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string" minOccurs="0"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Nous pouvons maintenant declarer l’attribut de l’élément ‘shiporder’. Comme il s’agit d’un élément
obligatoire, nous devons utiliser l’attribut ‘required’.
<xs:attribute name="orderid" type="xs:string" use="required"/>
Voici le fichier ‘shiporder.xsd’ au complet.
<xs:complexType>
<xs:sequence>
<xs:complexType>
<xs:sequence>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="note" type="xs:string" minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="orderid" type="xs:string" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
4.16.3. Diviser le schéma

La méthode employée précédemment était très simple, mais peut se révéler extrêmement difficile à
lire et à maintenir quand les documents sont complexes.
The next design method is based on defining all elements and attributes first, and then reference to
them using the ref attribute.
XML XSL XSD 39 / 43
La méthode suivante commence par définir tous les éléments et attributs, et crée ensuite les références.
Voici la nouvelle version du fichier ‘shiporder.xsd’

<xs:element name="note" type="xs:string"/>

<xs:attribute name="orderid" type="xs:string"/>

<xs:complexType>
<xs:sequence>
<xs:element ref="name"/>
<xs:element ref="address"/>
<xs:element ref="city"/>
<xs:element ref="country"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="item">
<xs:complexType>
<xs:sequence>
<xs:element ref="title"/>
<xs:element ref="note" minOccurs="0"/>
<xs:element ref="quantity"/>
<xs:element ref="price"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:complexType>
<xs:sequence>
<xs:element ref="orderperson"/>
<xs:element ref="shipto"/>
<xs:element ref="item" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute ref="orderid" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
4.16.4. En utilisant les types nommés

La troisième méthode définie des classes ou types, qui nous permettent de réutiliser la définition des
éléments. Cela est fait en nommant les éléments de type simple et complexe, et en les utilisant ensuite
à travers l’attribut ‘type’ de l’élément.
Voici la nouvelle version du fichier ‘shiporder.xsd’
XML XSL XSD 40 / 43
<xs:simpleType name="stringtype">
<xs:restriction base="xs:string"/>
</xs:simpleType>
<xs:simpleType name="inttype">
<xs:restriction base="xs:positiveInteger"/>
</xs:simpleType>
<xs:simpleType name="dectype">
<xs:restriction base="xs:decimal"/>
</xs:simpleType>
<xs:simpleType name="orderidtype">
<xs:restriction base="xs:string">
<xs:pattern value="[0-9]{6}"/>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="shiptotype">
<xs:sequence>
<xs:element name="name" type="stringtype"/>
<xs:element name="address" type="stringtype"/>
<xs:element name="city" type="stringtype"/>
<xs:element name="country" type="stringtype"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="itemtype">
<xs:sequence>
<xs:element name="title" type="stringtype"/>
<xs:element name="note" type="stringtype" minOccurs="0"/>
<xs:element name="quantity" type="inttype"/>
<xs:element name="price" type="dectype"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="shipordertype">
<xs:sequence>
<xs:element name="orderperson" type="stringtype"/>
<xs:element name="shipto" type="shiptotype"/>
<xs:element name="item" maxOccurs="unbounded" type="itemtype"/>
</xs:sequence>
<xs:attribute name="orderid" type="orderidtype" use="required"/>
</xs:complexType>
<xs:element name="shiporder" type="shipordertype"/>
</xs:schema>
L’élément ‘restriction’ indique que le type de données est dérivé d’un schéma W3C.
Cette ligne signifie donc que l’élément ou l’attribut doit être de type ‘string’.
L’élément ‘restriction’ est plus souvent employé pour appliquer des restriction sur les éléments.
Voyons quelques lignes du schéma précédent.
<xs:simpleType name="orderidtype">
<xs:pattern value="[0-9]{6}"/>
</xs:restriction>
</xs:simpleType>
Ceci indique que la valeur des éléments ou attributs doit être un ‘string’ et doit exactement être de 6
caractères par rangée et que ces caractères doivent être des nombres de 0 à 9.
XML XSL XSD 41 / 43
5. Les outils XML de Visual Studio

.Net
5.1. Manipulation de fichier XML
Visual Studio .Net permet de manipuler les fichiers XML de manière simple. Il possède deux modes à
cet effet :
Un mode d’édition, qui se présente comme un éditeur de texte qui reconnaît la syntaxe XML et qui la
colorise.
Un mode de visualisation/saisie qui permet d’afficher un document XML comme des ‘DataTables’.
On peut basculer d’un mode à l’autre à l’aide des deux boutons se trouvant en bas à gauche du
document XML.
5.1.1. Mode édition

Voici l’apparence du dernier fichier XML sur lequel nous avons travaillé dans l’éditeur XML en mode
édition de Visual Studio .Net :
Cet éditeur offre plusieurs outils et fonctions comme la création automatique des balises fermantes, la
validation d’un document XML, et la création automatique d’un schéma XSD associé. La plupart de
ces options sont disponibles à l’aide du menu contextuel (bouton droit). La création automatique d’un
schéma est un outil extrêmement utile. Nous y reviendrons dans le chapitre suivant.
XML XSL XSD 42 / 43
5.1.2. Mode Visualisation/Saisie

Voici l’apparence du dernier fichier XML sur lequel nous avons travaillé dans l’éditeur XML en mode
visualisation/saisie de Visual Studio .Net :
Cet outil permet de parcourir les données XML sous forme de tableaux, de visualiser les liaisons entre
les données et notamment d’ajouter des données à la volée dans le document XML.
5.2. Manipulation de schéma XSD

On peut créer un schéma XSD de deux façons différentes, en utilisant le même outil à chaque fois :
soit en créant un fichier XSD de toutes pièces et en utilisant l’interface de construction qui se
manipule comme un outil de création de base de données, ou en rédigeant un fichier XML exhaustif et
en générant le fichier XSD d’un simple clic droit. Il est bien sûr possible de générer automatiquement
le fichier XSD puis d’ajouter ensuite des éléments supplémentaires afin de compléter le schéma.
Cet outil est également disponible en mode édition de texte, avec le même système que l’éditeur XML
(ce qui est normal puisque le fichier XSD est lui-même un fichier XML), ou en mode édition
graphique, beaucoup plus complexe et qui dépasse le cadre de notre cours.
Le passage d’un mode à l’autre est également assuré par une bascule à l’image de l’éditeur XML.
XML XSL XSD 43 / 43
5.2.1. Edition en mode texte
Cet éditeur comporte les mêmes fonctionnalités que l’éditeur XML.
5.2.2. Edition en mode graphique
Ce mode d’édition permet de créer un schéma de manière totalement graphique, avec des éléments
graphiques qui correspondent aux entités décrites dans le chapitre XSD.
Il permet de créer des liaisons entre les données, c'est-à-dire des arbres XML de manière simple et
graphique.

XML PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

XML PDF

Titre original :

Transféré par

Droits d'auteur :

Formats disponibles

http://www.labo-dotnet.

XML XSL XSD

Auteur : Guillaume de Vinzelles

Ecole Supérieure d’Informatique de Paris

Table des matières

On peut consulter la documentation du W3C à l’adresse suivante : www.w3.org

• Séparation des données de la présentation

ANNEE CHASSIS MOTEUR COULEUR

PUISSANCE CYLINDREE CARBURANT

Et voici le document XML associé :

1.2. Les standards associés

1.2.4. DTD et XSD

2.1.2. Balises Fermantes

Les balises ouvrantes et fermantes doivent respecter la même casse :

2.1.5. Balise Racine

2.1.6. Valeur des Attributs

2.1.8. Commentaires en XML

2.1.9. Caractère spéciaux

2.2.2. Les éléments XML sont liés

Titre du livre : Mon premier XML

Voici le document XML correspondant :

2.2.3. Les éléments XML peuvent être de types différents

2.2.4. Noms des éléments

Exemples : <nom_auteur>, <couleur_carrosserie>

Un document XML est valide si :

<?xml version="1.0" encoding="ISO-8859-1"?>

3.1. Syntaxe générale

Nous allons utiliser le document XML suivant dans nos exemples :

3.2. Un premier exemple

Et voici le code HTML correspondant :

Et voici le résultat obtenu et le code HTML correspondant :

<h2>Ma Collection de CD</h2>

Et voici le résultat obtenu et le code HTML correspondant :

Et voici le XSL correspondant :

3.3.2. Template avec attribut name (template nommée)

Voici le résultat de ce traitement dans un navigateur web :

3.4. Variables et paramètres

Reprenons notre fichier XSL et modifions le de manière à utiliser les variables :

Et voici le résultat (assez prévisible) dans le navigateur :

3.5. Tests et boucles

‘xsl:choose’ reproduit le même fonctionnement que l’instruction case du Pascal ou ‘switch’ du C :

3.7. Création dynamique

4.2. Pourquoi utiliser les schémas XML ?

Les XSD supportent les types de données :

Les XSD utilisent la syntaxe XML :

Les XSD sont extensibles :

4.3. Un premier exemple

Détaillons ces différentes informations :

4.5. Les éléments simples (Simple Element).

4.6. Les éléments complexes (Complex Element).

Voici quelques exemples d’éléments complexes :

Un élément complexe “product” qui est vide:

Un élément complexe “employee” qui ne contient que d’autres éléments :

Un élément complexe “food” qui ne contient que du texte:

Un élément complexe “description” qui contient à la fois texte et éléments:

L'élément attributeGroup possède deux attributs destinés à identifier l'élément et à se référer à un

namespace spécifie un ou plusieurs espaces de noms.

L'élément key ne peut être inclus que dans l'élément suivant :

4.16. Un exemple complet

4.16.2. Créer un schéma XML

4.16.3. Diviser le schéma

4.16.4. En utilisant les types nommés