Outil de définition de schéma XML (Xsd.exe)

2025-06-22

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

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

Syntaxe

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

Pour que les outils .NET Framework fonctionnent correctement, vous devez définir correctement vos variables d’environnement et Lib vos Pathvariables Included’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.

Raisonnement

Raisonnement Descriptif

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, .dllou .exe.

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

Si vous spécifiez un fichier XML (extension.xml), Xsd.exe déduit un schéma à partir des données du fichier et produit un schéma XSD. Le fichier de sortie porte le même nom que le fichier XML, mais avec l’extension .xsd.

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

Si vous spécifiez un fichier d’assembly runtime (.exe ou extension .dll), Xsd.exe génère des schémas pour un ou plusieurs types dans 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 produit plusieurs schémas uniquement si les types donnés spécifient un espace de noms à l’aide de l’attribut XMLRoot personnalisé.

Raisonnement	Descriptif
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, .dllou .exe. Si vous spécifiez un fichier de schéma XDR (extension.xdr), Xsd.exe convertit le schéma XDR en schéma XSD. Le fichier de sortie porte le même nom que le schéma XDR, mais avec l’extension .xsd. Si vous spécifiez un fichier XML (extension.xml), Xsd.exe déduit un schéma à partir des données du fichier et produit un schéma XSD. Le fichier de sortie porte le même nom que le fichier XML, mais avec l’extension .xsd. Si vous spécifiez un fichier de schéma XML (extension.xsd), Xsd.exe génère du code source pour les objets runtime qui correspondent au schéma XML. Si vous spécifiez un fichier d’assembly runtime (.exe ou extension .dll), Xsd.exe génère des schémas pour un ou plusieurs types dans 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 produit plusieurs schémas uniquement si les types donnés spécifient un espace de noms à l’aide de l’attribut `XMLRoot` personnalisé.

Options générales

Choix	Descriptif
/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 apparaître qu’une seule fois. 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 courte est `/p:`. Pour plus d’informations, consultez la section Remarques.

Options de fichier XSD

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

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

Vous pouvez également spécifier l’une des options suivantes pour les fichiers .xsd.

Choix	Descriptif
/e[lement] :element	Spécifie l’élément dans le schéma pour lequel générer du code. Par défaut, tous les éléments sont typés. Vous pouvez spécifier cet argument plusieurs fois.
/enableDataBinding	Implémente l’interface sur tous les types générés pour activer la INotifyPropertyChanged liaison de données. La forme courte est `/edb`.
/enableLinqDataSet	(Forme courte : `/eld`.) Spécifie que le DataSet 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 la vue d’ensemble de LINQ to DataSet et l’interrogation des jeux de données typés. Pour obtenir des informations générales 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. Choisissez parmi `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 complet pour une classe implémentant System.CodeDom.Compiler.CodeDomProvider
/n[amespace] :namespace	Spécifie l’espace de noms runtime pour les types générés. L’espace de noms par défaut est `Schemas`.
/nologo	Supprime la bannière.
/commande	Génère des identificateurs d’ordre explicites sur tous les membres de particules.
/o[ut] :directoryName	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 pour les éléments du schéma pour générant du code. Cet URI, le cas échéant, s’applique à tous les éléments spécifiés avec l’option `/element` .

Options de fichier DLL et EXE

Choix Descriptif

/t[ype] :typename Spécifie le nom du type pour lequel créer un schéma. Vous pouvez spécifier plusieurs arguments de type. Si typename ne spécifie pas d’espace de noms, Xsd.exe correspond à tous les types de l’assembly avec le type spécifié. Si typename spécifie un espace de noms, seul ce type est mis en correspondance. 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 des schémas pour tous les types de l’assembly.

Choix	Descriptif
/t[ype] :typename	Spécifie le nom du type pour lequel créer un schéma. Vous pouvez spécifier plusieurs arguments de type. Si typename ne spécifie pas d’espace de noms, Xsd.exe correspond à tous les types de l’assembly avec le type spécifié. Si typename spécifie un espace de noms, seul ce type est mis en correspondance. 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 des schémas pour tous les types de l’assembly.

Remarques

Le tableau suivant montre les opérations effectuées par Xsd.exe.

Opération	Descriptif
XDR vers XSD	Génère un schéma XML à partir d’un fichier de schéma xmlData-Reduced. XDR est un format de schéma XML précoce.
XML vers XSD	Génère un schéma XML à partir d’un fichier XML.
XSD vers DataSet	Génère des classes Common Language Runtime DataSet à partir d’un fichier de schéma XSD. Les classes générées fournissent un modèle objet enrichi pour les données XML régulières.
XSD vers les classes	Génère des classes runtime à partir d’un fichier de schéma XSD. Les classes générées peuvent être utilisées conjointement avec System.Xml.Serialization.XmlSerializer la lecture et l’écriture de code XML qui suit le schéma.
Classes en XSD	Génère un schéma XML à partir d’un type ou de types dans un fichier d’assembly runtime. Le schéma généré définit le format XML utilisé par le XmlSerializer.

Xsd.exe vous permet uniquement de manipuler des schémas XML qui suivent le langage XSD (XML Schema Definition) proposé par le World Wide Web Consortium (W3C). 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 /parameters commutateur, vous pouvez spécifier un fichier XML unique qui définit différentes options. Les options que vous pouvez définir dépendent de la façon dont vous utilisez 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 DataSet fonctionnalités. Par exemple, vous pouvez définir l’élément <assembly> sur le nom d’un fichier exécutable (.exe) ou de 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 montre comment utiliser l’élément <generateSchemas> avec un 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 type unique 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>

Toutefois, 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 est nommé GenerateSchemaFromType.xml) :

xsd /p:GenerateSchemaFromType.xml ConsoleApplication1.exe

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

Élément	Descriptif
<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 qui 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> sont les suivantes.

Élément	Descriptif
<é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 SchemaImporterExtension classe.
<schéma>	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 montre les attributs qui peuvent également être utilisés avec l’élément <generateClasses> .

Caractéristique	Descriptif
Langue	Spécifie le langage de programmation à utiliser. Choisissez parmi `CS` (C#, valeur par défaut), `VB` (Visual Basic), `JS` (JScript) ou `VJS` (Visual J#). Vous pouvez également spécifier un nom complet pour une classe qui implémente CodeDomProvider.
Namespace	Spécifie l’espace de noms pour le code généré. L’espace de noms doit être conforme aux normes CLR (par exemple, pas d’espaces ou de barres obliques inverses).
Options	Une des valeurs suivantes : `none`, `properties` (génère des propriétés au lieu des champs publics), `order`ou `enableDataBinding` (voir les `/order` commutateurs et `/enableDataBinding` les commutateurs dans la section Options de fichier XSD précédentes.

Vous pouvez également contrôler la façon dont DataSet le code 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 classe) pour créer du DataTable code Visual Basic pour un élément spécifié. Les structures DataSet générées prennent 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> sont les suivantes.

Élément	Descriptif
<schéma>	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 montre les attributs qui peuvent être utilisés avec l’élément <generateDataSet> .

Caractéristique	Descriptif
enableLinqDataSet	Spécifie que le DataSet généré peut être interrogé à l’aide de LINQ to DataSet. La valeur par défaut est false.
Langue	Spécifie le langage de programmation à utiliser. Choisissez parmi `CS` (C#, valeur par défaut), `VB` (Visual Basic), `JS` (JScript) ou `VJS` (Visual J#). Vous pouvez également spécifier un nom complet pour une classe qui implémente CodeDomProvider.
Namespace	Spécifie l’espace de noms pour le code généré. L’espace de noms doit être conforme aux normes CLR (par exemple, pas d’espaces ou de barres obliques inverses).

Il existe des attributs que vous pouvez définir sur l’élément de niveau <xsd> supérieur. Ces options peuvent être utilisées avec l’un des éléments enfants (<generateSchemas><generateClasses>ou <generateDataSet>). Le code XML suivant génère du 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 montre les attributs qui peuvent également être utilisés avec l’élément <xsd> .

Caractéristique	Descriptif
résultat	Nom d’un répertoire dans lequel le schéma ou le fichier de code généré sera placé.
nologo	Supprime la bannière. Définissez `true` sur `false`.
aide	Affiche la syntaxe et les options de commande de l'outil. Définissez `true` sur `false`.

Exemples

La commande suivante génère un schéma XML à partir duquel myFile.xdr il est enregistré dans le répertoire actif.

xsd myFile.xdr

La commande suivante génère un schéma XML à partir duquel myFile.xml il est enregistré dans le répertoire spécifié.

xsd myFile.xml /outputdir:myOutputDir

La commande suivante génère un jeu de données qui correspond au schéma spécifié dans le langage C# et l’enregistre 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 comme schema0.xsd dans le répertoire actif.

xsd myAssembly.dll