Outil XML Schema Definition (Xsd.exe)

Article
11/28/2022
10 minutes de lecture

L'outil XML Schema Definition Tool (Xsd.exe) génère des classes du Common Language Runtime et du schéma XML à partir de fichiers XDR, XML et XSD ou de classes figurant dans un assembly de runtime.

L’outil définition de schéma XML (Xsd.exe) se trouve généralement dans le chemin d’accès suivant :
C:\Program Files (x86)\Microsoft SDKs\Windows\{version}\bin\NETFX {version} Tools\

Syntax

Exécutez l’outil à partir de la ligne de commande.

xsd file.xdr [-outputdir:directory][/parameters:file.xml]
xsd file.xml [-outputdir:directory] [/parameters:file.xml]
xsd file.xsd {/classes | /dataset} [/element:element]
             [/enableLinqDataSet] [/language:language]
                          [/namespace:namespace] [-outputdir:directory] [URI:uri]
                          [/parameters:file.xml]
xsd {file.dll | file.exe} [-outputdir:directory] [/type:typename [...]][/parameters:file.xml]

Conseil

Pour que les outils .NET Framework fonctionnent correctement, vous devez définir correctement vos variables d’environnement Includeet Lib vos Pathvariables d’environnement. Définissez ces variables d’environnement en exécutant SDKVars.bat, qui se trouve dans le <répertoire SDK>\<version>\Bin. SDKVars.bat doit être exécuté dans chaque interpréteur de commandes.

Argument

Argument Description

file.extension Spécifie le fichier d'entrée à convertir. Vous devez spécifier l’extension comme l’une des options suivantes : .xdr, .xml, .xsd, .dll ou .exe.

Si vous spécifiez un fichier de schéma XDR (extension .xdr), Xsd.exe convertit alors le schéma XDR en schéma XSD. Le fichier de sortie porte le même nom que celui du schéma XDR, mais son extension est .xsd.

Si vous spécifiez un fichier XML (extension .xml), Xsd.exe déduit alors un schéma à partir des données d'un fichier et génère un schéma XSD. Le fichier de sortie porte le même nom que celui du fichier XML, mais son extension est .xsd.

Si vous spécifiez un fichier de schéma XML (extension .xsd), Xsd.exe génère alors du code source pour les objets de runtime correspondant au schéma XML.

Si vous spécifiez un fichier d'assembly de runtime (extension .exe ou .dll), Xsd.exe génère alors des schémas pour un ou plusieurs types de cet assembly. Vous pouvez utiliser l'option /type pour spécifier les types pour lesquels générer des schémas. Les schémas de sortie sont nommés schema0.xsd, schema1.xsd, et ainsi de suite. Xsd.exe génère plusieurs schémas uniquement dans le cas où les types indiqués spécifieraient un espace de noms à l'aide de l'attribut personnalisé XMLRoot.

Argument	Description
file.extension	Spécifie le fichier d'entrée à convertir. Vous devez spécifier l’extension comme l’une des options suivantes : .xdr, .xml, .xsd, .dll ou .exe. Si vous spécifiez un fichier de schéma XDR (extension .xdr), Xsd.exe convertit alors le schéma XDR en schéma XSD. Le fichier de sortie porte le même nom que celui du schéma XDR, mais son extension est .xsd. Si vous spécifiez un fichier XML (extension .xml), Xsd.exe déduit alors un schéma à partir des données d'un fichier et génère un schéma XSD. Le fichier de sortie porte le même nom que celui du fichier XML, mais son extension est .xsd. Si vous spécifiez un fichier de schéma XML (extension .xsd), Xsd.exe génère alors du code source pour les objets de runtime correspondant au schéma XML. Si vous spécifiez un fichier d'assembly de runtime (extension .exe ou .dll), Xsd.exe génère alors des schémas pour un ou plusieurs types de cet assembly. Vous pouvez utiliser l'option `/type` pour spécifier les types pour lesquels générer des schémas. Les schémas de sortie sont nommés schema0.xsd, schema1.xsd, et ainsi de suite. Xsd.exe génère plusieurs schémas uniquement dans le cas où les types indiqués spécifieraient un espace de noms à l'aide de l'attribut personnalisé `XMLRoot`.

Options générales

Option	Description
/h[elp]	Affiche la syntaxe et les options de commande de l'outil.
/o[utputdir]:directory	Spécifie le répertoire des fichiers de sortie. Cet argument ne peut être spécifié qu'à une seule reprise. L'emplacement par défaut est le répertoire actif.
/?	Affiche la syntaxe et les options de commande de l'outil.
/p[arameters] :file.xml	Options de lecture pour différents modes d'opération à partir du fichier .xml spécifié. La forme abrégée est `/p:`. Pour plus d’informations, consultez la section Remarques .

Options de fichier XSD

Vous ne devez spécifier qu'une seule des options suivantes pour les fichiers .xsd.

Option	Description
/c[lasses]	Génère des classes correspondant au schéma spécifié. Pour lire les données XML dans l’objet, utilisez la méthode XmlSerializer.Deserialize.
/d[ataset]	Génère une classe dérivée de DataSet qui correspond au schéma spécifié. Pour lire les données XML dans la classe dérivée, utilisez la méthode DataSet.ReadXml.

Vous pouvez également spécifier les options suivantes pour les fichiers .xsd.

Option	Description
/e[lement]:element	Spécifie l'élément figurant dans le schéma pour lequel générer du code. Tous les éléments sont par défaut tapés. Vous pouvez spécifier cet argument à plusieurs reprises.
/enableDataBinding	Implémente l'interface INotifyPropertyChanged sur tous les types générés pour activer la liaison de données. La forme abrégée est `/edb`.
/enableLinqDataSet	(Forme courte : `/eld`.) Spécifie que l’ensemble de données généré peut être interrogé à l’aide de LINQ to DataSet. Cette option est utilisée lorsque l'option /dataset est également spécifiée. Pour plus d’informations, consultez Présentation de LINQ to DataSet et Interrogation de datasets typés. Pour plus d’informations sur l’utilisation de LINQ, consultez Language-Integrated Query (LINQ) - C# ou Language-Integrated Query (LINQ) - Visual Basic.
/f[ields]	Génère uniquement des champs. Par défaut, les propriétés avec des champs de stockage sont générées.
/l[anguage]:language	Spécifie le langage de programmation à utiliser. Vous avez le choix entre `CS` (C#, qui est la valeur par défaut), `VB` (Visual Basic), `JS` (JScript) ou `VJS` (Visual J#). Vous pouvez également spécifier un nom qualifié complet pour une classe implémentant System.CodeDom.Compiler.CodeDomProvider.
/n[amespace]:namespace	Spécifie l'espace de noms du runtime pour les types générés. L'espace de noms par défaut est `Schemas`.
/nologo	Supprime la bannière.
/order	Génère des identificateurs d'ordre explicites sur les membres de particule.
/o[ut]:nom_répertoire	Spécifie le répertoire de sortie dans lequel placer les fichiers. L'emplacement par défaut est le répertoire actif.
/u[ri]:uri	Spécifie l'URI des éléments figurant dans le schéma pour lequel générer du code. S'il existe, cet URI s'applique à tous les éléments spécifiés avec l'option `/element`.

Options de fichier DLL et EXE

Option Description

/t[ype]:typename Spécifie le nom du type pour lequel créer un schéma. Vous pouvez spécifier plusieurs arguments pour le type. Si nom_type ne spécifie pas d’espace de noms, Xsd.exe établit une correspondance entre tous les types de l’assembly et le type spécifié. Si nom_type spécifie un espace de noms, une correspondance est établie uniquement avec ce type. Si typename se termine par un caractère astérisque (*), l’outil correspond à tous les types qui commencent par la chaîne précédant le *. Si vous omettez l'option /type, Xsd.exe génère alors des schémas pour tous les types de l'assembly.

Option	Description
/t[ype]:typename	Spécifie le nom du type pour lequel créer un schéma. Vous pouvez spécifier plusieurs arguments pour le type. Si nom_type ne spécifie pas d’espace de noms, Xsd.exe établit une correspondance entre tous les types de l’assembly et le type spécifié. Si nom_type spécifie un espace de noms, une correspondance est établie uniquement avec ce type. Si typename se termine par un caractère astérisque (), l’outil correspond à tous les types qui commencent par la chaîne précédant le . Si vous omettez l'option `/type`, Xsd.exe génère alors des schémas pour tous les types de l'assembly.

Remarques

Le tableau suivant affiche les opérations que Xsd.exe exécute.

Opération	Description
De XDR en XSD	Génère un schéma XML à partir d'un fichier de schéma XDR (XML-Data-Reduced). XDR est l'un des premiers formats de schéma XML.
De XML en XSD	Génère un schéma XML à partir d'un fichier XML.
De XSD en DataSet	Génère des classes DataSet de Common Language Runtime à partir d'un fichier de schéma XSD. Les classes générées proposent un modèle objet riche aux données XML régulières.
De XSD en classes	Génère des classes de runtime à partir d'un fichier de schéma XSD. Les classes générées peuvent être associées à System.Xml.Serialization.XmlSerializer pour lire et écrire du code XML conforme au schéma.
De classes en XSD	Génère un schéma XML à partir d'un ou de plusieurs types dans un fichier d'assembly de runtime. Le schéma généré définit le format XML utilisé par le XmlSerializer.

Xsd.exe vous permet uniquement de manipuler les schémas XML conformes au langage XSD (XML Schema Definition) proposé par W3C (World Wide Web Consortium). Pour plus d’informations sur la proposition de définition de schéma XML ou la norme XML, consultez https://w3.org.

Définition d'options avec un fichier XML

À l’aide du commutateur /parameters, vous pouvez spécifier un fichier XML qui définit plusieurs options. Les options que vous pouvez définir dépendent de votre utilisation de l'outil XSD.exe. Les choix incluent la génération de schémas, la génération de fichiers de code ou la génération de fichiers de code qui incluent des fonctionnalités DataSet. Par exemple, vous pouvez définir l'élément <assembly> sur le nom d'un fichier exécutable (.exe) ou d'un fichier bibliothèque de types (.dll) lors de la génération d'un schéma, mais pas lors de la génération d'un fichier de code. Le code XML suivant indique comment utiliser l'élément <generateSchemas> avec un fichier exécutable spécifié :

<!-- This is in a file named GenerateSchemas.xml. -->
<xsd xmlns='http://microsoft.com/dotnet/tools/xsd/'>
<generateSchemas>
   <assembly>ConsoleApplication1.exe</assembly>
</generateSchemas>
</xsd>

Si le code XML précédent est contenu dans un fichier nommé GenerateSchemas.xml, utilisez le /parameters commutateur en tapant ce qui suit à l’invite de commandes et en appuyant sur Entrée :

 xsd /p:GenerateSchemas.xml

En revanche, si vous générez un schéma pour un seul type trouvé dans l'assembly, vous pouvez utiliser le code XML suivant :

<!-- This is in a file named GenerateSchemaFromType.xml. -->
<xsd xmlns='http://microsoft.com/dotnet/tools/xsd/'>
<generateSchemas>
   <type>IDItems</type>
</generateSchemas>
</xsd>

Mais pour utiliser le code précédent, vous devez également fournir le nom de l'assembly à l'invite de commandes. Entrez ce qui suit à l’invite de commandes (en supposant que le fichier XML soit nommé GenerateSchemaFromType.xml) :

xsd /p:GenerateSchemaFromType.xml ConsoleApplication1.exe

Vous ne devez spécifier qu'une seule des options suivantes pour l'élément <generateSchemas>.

Élément	Description
<assemblée>	Spécifie un assembly à partir duquel générer le schéma.
<type>	Spécifie un type trouvé dans un assembly pour lequel générer un schéma.
<xml>	Spécifie un fichier XML pour lequel générer un schéma.
<Xdr>	Spécifie un fichier XDR pour lequel générer un schéma.

Pour générer un fichier de code, utilisez l'élément <generateClasses>. L'exemple suivant génère un fichier de code. Notez que deux attributs sont également indiqués, ils vous permettent de définir le langage de programmation et l'espace de noms du fichier généré.

<xsd xmlns='http://microsoft.com/dotnet/tools/xsd/'>
<generateClasses language='VB' namespace='Microsoft.Serialization.Examples'/>
</xsd>
<!-- You must supply an .xsd file when typing in the command line.-->
<!-- For example: xsd /p:genClasses mySchema.xsd -->

Les options que vous pouvez définir pour l'élément <generateClasses> incluent les éléments suivants.

Élément	Description
<élément>	Spécifie un élément dans le fichier .xsd pour lequel générer du code.
<schemaImporterExtensions>	Spécifie un type dérivé de la classe SchemaImporterExtension.
<schema>	Spécifie un fichier de schéma XML pour lequel générer du code. Plusieurs fichiers de schéma XML peuvent être spécifiés à l’aide de plusieurs <éléments de schéma> .

Le tableau suivant affiche les attributs qui peuvent également être utilisés avec l'élément <generateClasses>.

Attribut	Description
langage	Spécifie le langage de programmation à utiliser. Vous avez le choix entre `CS` (C#, la valeur par défaut), `VB` (Visual Basic), `JS` (JScript) ou `VJS` (Visual J#). Vous pouvez également spécifier un nom qualifié complet pour une classe qui implémente CodeDomProvider.
espace de noms	Spécifie l'espace de noms pour le code généré. L'espace de noms doit se conformer aux normes CLR (par exemple, aucun espace ou barre oblique inverse).
options	L’une des valeurs suivantes : `none`, `properties` (génère des propriétés au lieu de champs publics), `order` ou `enableDataBinding` (consultez les commutateurs `/order` et `/enableDataBinding` dans la section Options de fichier XSD précédente).

Vous pouvez également contrôler comment le code DataSet est généré à l'aide de l'élément <generateDataSet>. Le code XML suivant spécifie que le code généré utilise DataSet des structures (telles que la DataTable classe) pour créer du code Visual Basic pour un élément spécifié. Les structures DataSet générées prendront en charge les requêtes LINQ.

<xsd xmlns='http://microsoft.com/dotnet/tools/xsd/'>
    <generateDataSet language='VB' namespace='Microsoft.Serialization.Examples' enableLinqDataSet='true'>
    </generateDataSet>
</xsd>

Les options que vous pouvez définir pour l'élément <generateDataSet> incluent les éléments suivants.

Élément	Description
<schema>	Spécifie un fichier de schéma XML pour lequel générer du code. Plusieurs fichiers de schéma XML peuvent être spécifiés à l’aide de plusieurs <éléments de schéma> .

Le tableau suivant affiche les attributs qui peuvent être utilisés avec l'élément <generateDataSet>.

Attribut	Description
enableLinqDataSet	Spécifie que le DataSet généré peut être interrogé par rapport à l'utilisation de LINQ to DataSet. La valeur par défaut est false.
langage	Spécifie le langage de programmation à utiliser. Vous avez le choix entre `CS` (C#, la valeur par défaut), `VB` (Visual Basic), `JS` (JScript) ou `VJS` (Visual J#). Vous pouvez également spécifier un nom qualifié complet pour une classe qui implémente CodeDomProvider.
espace de noms	Spécifie l'espace de noms pour le code généré. L'espace de noms doit se conformer aux normes CLR (par exemple, aucun espace ou barre oblique inverse).

Vous pouvez définir certains attributs sur l'élément <xsd> de niveau supérieur. Ces options peuvent être utilisées avec n'importe lequel des éléments enfants (<generateSchemas>, <generateClasses> ou <generateDataSet>). Le code XML suivant génère le code pour un élément nommé "IDItems" dans le répertoire de sortie nommé "MyOutputDirectory".

<xsd xmlns='http://microsoft.com/dotnet/tools/xsd/' output='MyOutputDirectory'>
<generateClasses>
    <element>IDItems</element>
</generateClasses>
</xsd>

Le tableau suivant affiche les attributs qui peuvent également être utilisés avec l'élément <xsd>.

Attribut	Description
sortie	Le nom d'un répertoire dans lequel le schéma généré ou le fichier de code sera placé.
nologo	Supprime la bannière. A la valeur `true` ou `false`.
help	Affiche la syntaxe et les options de commande de l'outil. A la valeur `true` ou `false`.

Exemples

La commande suivante génère un schéma XML à partir de myFile.xdr et l'enregistre dans le répertoire actif.

xsd myFile.xdr

La commande suivante génère un schéma XML à partir de myFile.xml et l'enregistre dans le répertoire spécifié.

xsd myFile.xml /outputdir:myOutputDir

La commande suivante génère un groupe de données qui correspond au schéma spécifié dans le langage C# et le sauvegarde comme XSDSchemaFile.cs dans le répertoire actif.

xsd /dataset /language:CS XSDSchemaFile.xsd

La commande suivante génère des schémas XML pour tous les types de l'assembly myAssembly.dll et les enregistre sous schema0.xsd dans le répertoire actif.

xsd myAssembly.dll