Partager via

Prise en charge de la liaison de l'élément Element

  • Article

Cette rubrique est spécifique à une technologie existante. Les services Web XML et les clients du service Web XML doivent à présent être créés à l'aide de Windows Communication Foundation.

Le .NET Framework prend en charge la liaison pour l'élément <element>.

Explication

La spécification de schéma XML indique qu'un élément peut être déclaré localement, dans une définition de type complexe, ou globalement, comme enfant de l'élément racine <schema>. Si l'élément est déclaré globalement, il peut être référencé dans une ou plusieurs définitions de type complexe via l'attribut ref.

L'exemple de code suivant indique un élément déclaré localement.

<xsd:complexType name="UnitType">
  <xsd:sequence>
   <xsd:element name="name" type="xsd:string"/>
  </xsd:sequence>
</xsd:complexType>

L'exemple de code suivant indique le même élément déclaré globalement, puis référencé.

<xsd:element name="name" type="xsd:string"/>
<xsd:complexType name="UnitType">
  <xsd:sequence>
    <xsd:element ref="name"/>
  </xsd:sequence>
</xsd:complexType>

Lors de la génération d'un type .NET Framework à partir d'un type complexe de schéma XML, Xsd.exe ne fait pas la différence entre un élément localement déclaré et une référence à un élément globalement déclaré, à moins que l'élément global soit déclaré dans un espace de noms autre que l'espace de noms cible du schéma.

Référence dans le même espace de noms

Dans la mesure où Xsd.exe ne fait pas de distinction dans le même espace de noms, une traduction aller-retour d'un schéma XML en classes et vice-versa crée des éléments locaux qui remplacent toutes références aux éléments globaux.

Si le type de données de l'élément global référencé a déjà une liaison automatique à un type .NET Framework, Xsd.exe ne génère pas de nouveau type correspondant au type de données. Par conséquent, la déclaration de l'élément global n'est plus référencée dans le schéma XML généré lors de la traduction aller-retour et n'apparaît plus dans celui-ci.

awac9czf.note(fr-fr,VS.100).gifRemarque :
Tous les types de données de schéma XML intégrés ont des liaisons automatiques aux types .NET Framework. De plus, les types simples définis par schéma, à une exception près, créent une liaison avec les types .NET Framework plutôt qu'avec les types personnalisés. La seule exception implique l'énumération de types de liaison de chaîne ; cette exception est expliquée plus en détail dans la documentation sur l'élément <enumeration>.

awac9czf.note(fr-fr,VS.100).gifRemarque :
Pour plus d'informations sur le sujet suivant la prise en charge des types simples définis par schéma, consultez l'élément <restriction> ou tout autre élément représentant des facettes de restriction.

Référence à un autre espace de noms

Si une déclaration globale référencée appartient à un espace de noms différent, Xsd.exe spécifie l'espace de noms à l'aide de la propriété Namespace d'un attribut XmlElementAttribute qui s'applique au champ généré. Pour cet élément spécifique, l'espace de noms spécifié à l'aide de la propriété Namespace substitue l'espace de noms spécifié au niveau de la classe à l'aide de l'attribut XmlTypeAttribute et, éventuellement, de l'attribut XmlRootAttribute, comme indiqué dans l'exemple suivant.

[System.Xml.Serialization.XmlElementAttribute(Namespace="http://example.org/elem")]
public string Text;

Des espaces de noms supplémentaires sont importés dans une définition de schéma XML à l'aide de l'élément <import>.

Création de déclarations d'élément globales

Lors de la génération d'un document de schéma XML à partir d'un ensemble de classes dans un assembly, Xsd.exe crée une déclaration <element>< globale pour chaque définition >complexType< ou >simpleType qu'il génère à partir d'un type défini dans l'assembly.

Ce premier exemple indique comment Xsd.exe traite un élément global lorsqu'il est défini dans un espace de noms cible qui contient une référence à cet élément.

Document de schéma XML d'entrée.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
      xmlns="http://example.org/" targetNamespace="http://example.org/" elementFormDefault="qualified">
  <xsd:element name="Text" type="xsd:normalizedString"/>
  <xsd:complexType name="Branch">
    <xsd:sequence>
      <xsd:element name="children" type="xsd:token" minOccurs="0" maxOccurs="unbounded" />
      <xsd:element ref="Text" />
    </xsd:sequence>
    <xsd:attribute name="key" type="xsd:token"/>
  </xsd:complexType>
  <xsd:element name="branch" type="Branch"/>
</xsd:schema>

Classe C# générée à partir du document de schéma XML précédent.

[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("branch", Namespace="http://example.org/", IsNullable=false)]
public class Branch {
        
    [System.Xml.Serialization.XmlElementAttribute("children", DataType="token")]
    public string[] children;
        
    [System.Xml.Serialization.XmlElementAttribute(DataType="normalizedString")]
    public string Text;
        
    [System.Xml.Serialization.XmlAttributeAttribute(DataType="token")]
    public string key;
}

Document de schéma XML généré à partir d'un assembly compilé depuis la source C# précédente.

<xs:schema xmlns:tns="http://example.org/" elementFormDefault="qualified" targetNamespace="http://example.org/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="branch" type="tns:Branch" />
  <xs:complexType name="Branch">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" name="children" type="xs:token" />
      <xs:element minOccurs="0" maxOccurs="1" name="Text" type="xs:normalizedString" />
    </xs:sequence>
    <xs:attribute name="key" type="xs:token" />
  </xs:complexType>
</xs:schema>

Dans le schéma XML généré précédemment, l'élément Text, déclaré globalement à l'origine, est devenu un élément local.

Ce deuxième exemple indique comment Xsd.exe traite une référence à un élément global lorsque cet élément est défini dans un espace de noms séparé. Cet exemple utilise l'élément <import> pour importer un deuxième espace de noms situé dans un fichier XSD séparé. (L'attribut schemaLocation de l'élément <import> n'est pas utilisé pour spécifier l'emplacement du fichier .xsd importé. À la place, le fichier est spécifié comme un argument de ligne de commande supplémentaire pour Xsd.exe.)

Document de schéma XML de niveau supérieur utilisé comme entrée.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified"
      xmlns="http://example.org/" targetNamespace="http://example.org/" xmlns:elem="http://example.org/elem">
  <xsd:import  namespace="http://example.org/elem" />
  <xsd:complexType name="Branch">
    <xsd:sequence>
      <xsd:element name="children" type="xsd:token" minOccurs="0" maxOccurs="unbounded" />
      <xsd:element ref="elem:Text" />
    </xsd:sequence>
    <xsd:attribute name="key" type="xsd:token"/>
  </xsd:complexType>
  <xsd:element name="branch" type="Branch"/>
</xsd:schema>

Document de schéma XML importé utilisé comme entrée.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" 
      xmlns="http://example.org/elem" targetNamespace="http://example.org/elem">
  <xsd:element name="Text" type="xsd:normalizedString"/>
</xsd:schema>

Classe C# générée à partir des deux documents de schéma XML précédents.

[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("branch", Namespace="http://example.org/", IsNullable=false)]
public class Branch {
        
    [System.Xml.Serialization.XmlElementAttribute("children", DataType="token")]
    public string[] children;
        
    [System.Xml.Serialization.XmlElementAttribute(Namespace="http://example.org/elem", DataType="normalizedString")]
    public string Text;
        
    [System.Xml.Serialization.XmlAttributeAttribute(DataType="token")]
    public string key;
}

Document de schéma XML de niveau supérieur généré à partir d'un assembly compilé depuis la source C# précédente.

<xs:schema xmlns:tns="http://example.org/" elementFormDefault="qualified" targetNamespace="http://example.org/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import namespace="http://example.org/elem" />
  <xs:element name="branch" type="tns:Branch" />
  <xs:complexType name="Branch">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="unbounded" name="children" type="xs:token" />
      <xs:element minOccurs="0" maxOccurs="1" xmlns:q1="http://example.org/elem" ref="q1:Text" />
    </xs:sequence>
    <xs:attribute name="key" type="xs:token" />
  </xs:complexType>
</xs:schema>

Document de schéma XML importé généré à partir d'un assembly compilé depuis la source C# précédente.

<xs:schema xmlns:tns="http://example.org/elem" elementFormDefault="qualified" targetNamespace="http://example.org/elem" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="Text" type="xs:normalizedString" />
</xs:schema>

Attribut Abstract

Une déclaration d'élément globale peut avoir un attribut abstract, contrairement à un élément local.

Déclarez un élément abstrait (abstract="true") pour forcer sa substitution via un groupe de substitution ; si l'élément n'est pas abstrait, la substitution est facultative.

L'élément global qui est substitué est appelé l'élément head. Chaque fois qu'une déclaration d'élément locale fait référence à l'élément head via l'attribut ref, vous pouvez utiliser tout élément de substitution global à la place. Pour plus d'informations, consultez l'attribut substitutionGroup.

Si les éléments de substitution appartiennent aux types de données dérivés et si l'élément head lui-même est déclaré abstrait (plutôt que la définition <complexType> dont le type est déclaré abstrait), vous pouvez utiliser le type de base à un autre endroit dans une instance de document XML, même si vous ne pouvez pas l'utiliser à l'emplacement de la substitution.

Lors de la génération du code source à partir d'un document de schéma XML, Xsd.exe crée un type qui correspond au type de données de l'élément head. Le type inclut un champ nommé Item. Xsd.exe applique à ce champ un XmlElementAttribute pour chacun des substituts. Chaque attribut identifie le nom et, si l'élément de substitution a un type de données dérivé, le type. Si les éléments de substitution utilisent le même type de données que l'élément head, un XmlChoiceIdentifierAttribute doit également être appliqué. Pour plus d'informations, consultez l'élément <choice>.

L'exemple de code suivant montre un exemple de champ, Item, généré à partir d'une référence à un élément head abstrait.

[System.Xml.Serialization.XmlElementAttribute("derivedAInstance", typeof(DerivedTypeA))]
[System.Xml.Serialization.XmlElementAttribute("derivedBInstance", typeof(DerivedTypeB))]
public MyBaseType Item;

Si vous utilisez des éléments de substitution qui appartiennent aux types de données dérivés, la sérialisation XML fonctionne uniquement lorsqu'une instance de l'un des types dérivés a été assignée au champ. La classe XmlSerializer échoue si une instance du type de base correspondant à l'élément head a été assignée.

Lors d'une traduction inverse, Xsd.exe crée un élément <choice> contenant un élément <element> pour chacun des éléments de substitution, et aucun <element> représentant l'élément head. Les éléments sont définis indépendamment dans la définition de type complexe ; aucune référence ref n'est utilisée.

awac9czf.note(fr-fr,VS.100).gifRemarque :
Dans une déclaration <element> locale contenant un attribut ref qui spécifie un élément head abstrait, Xsd.exe ignore l'attribut maxOccurs.

awac9czf.note(fr-fr,VS.100).gifRemarque :
Considérez la déclaration suivante à un élément head de type MyBaseType. 

<xsd:element ref="baseInstance" minOccurs="0" maxOccurs="unbounded" />
awac9czf.note(fr-fr,VS.100).gifRemarque :
Pour la déclaration précédente, Xsd.exe crée encore le champ suivant (les attributs sont omis). 

public MyBaseType Item;
awac9czf.note(fr-fr,VS.100).gifRemarque :
Xsd.exe ne parvient pas à générer des classes si tous les éléments déclarés globalement dans le schéma XML d'entrée sont abstraits.

Exemple : attribut Abstract

Document de schéma XML d'entrée.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
      targetNamespace="http://example.org/" xmlns="http://example.org/" elementFormDefault="qualified">
  <xsd:element name="baseInstance" type="MyBaseType" abstract="true"/>

  <xsd:complexType name="MyBaseType">
    <xsd:sequence>
      <xsd:element name="Field1" type="xsd:string"/>
      <xsd:element name="Field2" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:element name="derivedAInstance" type="DerivedTypeA" substitutionGroup="baseInstance" />
  <xsd:complexType name="DerivedTypeA">
    <xsd:complexContent>
      <xsd:extension base="MyBaseType">
         <xsd:attribute name="ExtraInfoForA" type="xsd:string"/>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="derivedBInstance" type="DerivedTypeB" substitutionGroup="baseInstance" />
  <xsd:complexType name="DerivedTypeB">
    <xsd:complexContent>
      <xsd:extension base="MyBaseType">
         <xsd:attribute name="ExtraInfoForB" type="xsd:string"/>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="myThings" type="MyThingsType" />
  <xsd:complexType name="MyThingsType">
    <xsd:sequence>
      <xsd:element ref="baseInstance" />
    </xsd:sequence>
  </xsd:complexType>
</xsd:schema>

Classes C# générées à partir du document de schéma XML précédent.

[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("derivedAInstance", Namespace="http://example.org/", IsNullable=false)]
public class DerivedTypeA : MyBaseType {
        
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string ExtraInfoForA;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlIncludeAttribute(typeof(DerivedTypeA))]
[System.Xml.Serialization.XmlIncludeAttribute(typeof(DerivedTypeB))]
public class MyBaseType {
    public string Field1;
        
    public string Field2;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("derivedBInstance", Namespace="http://example.org/", IsNullable=false)]
public class DerivedTypeB : MyBaseType {
        
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string ExtraInfoForB;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("myThings", Namespace="http://example.org/", IsNullable=false)]
public class MyThingsType {       
    [System.Xml.Serialization.XmlElementAttribute("derivedAInstance", typeof(DerivedTypeA))]
    [System.Xml.Serialization.XmlElementAttribute("derivedBInstance", typeof(DerivedTypeB))]
    public MyBaseType Item;
}

Document de schéma XML généré à partir d'un assembly compilé depuis la source C# précédente.

<xs:schema xmlns:tns="http://example.org/" elementFormDefault="qualified" targetNamespace="http://example.org/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:complexType name="MyBaseType">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="1" name="Field1" type="xs:string" />
      <xs:element minOccurs="0" maxOccurs="1" name="Field2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="DerivedTypeA">
    <xs:complexContent mixed="false">
      <xs:extension base="tns:MyBaseType">
        <xs:attribute name="ExtraInfoForA" type="xs:string" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="DerivedTypeB">
    <xs:complexContent mixed="false">
      <xs:extension base="tns:MyBaseType">
        <xs:attribute name="ExtraInfoForB" type="xs:string" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="derivedAInstance" type="tns:DerivedTypeA" />
  <xs:element name="derivedBInstance" type="tns:DerivedTypeB" />
  <xs:element name="myThings" type="tns:MyThingsType" />
  <xs:complexType name="MyThingsType">
    <xs:sequence>
      <xs:choice minOccurs="1" maxOccurs="1">
        <xs:element minOccurs="0" maxOccurs="1" name="derivedAInstance" type="tns:DerivedTypeA" />
        <xs:element minOccurs="0" maxOccurs="1" name="derivedBInstance" type="tns:DerivedTypeB" />
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
</xs:schema>

Attribut SubstitutionGroup

L'outil Xsd.exe reconnaît les groupes de substitution uniquement si l'élément substitué est déclaré abstrait. (Consultez la section Abstract Attribute précédente.) Ensuite, lors d'une traduction inverse, Xsd.exe crée un élément <choice> contenant un élément <element> pour chacun des substituts.

Attribut SubstitutionGroup : contexte

L'attribut substitutionGroup peut apparaître avec un élément globalement déclaré pour lui permettre de prendre la place d'un autre élément globalement déclaré dans une instance de document XML. La valeur de l'attribut correspond au nom de l'élément substitué, appelé élément head. La substitution réelle peut avoir lieu dans un élément <element> dans une définition de type complexe, où l'élément head est référencé via l'attribut ref. Tous les éléments déclarés avec l'attribut substitutionGroup doivent appartenir au même type de données que l'élément head ou à un type dérivé.

Un groupe de substitution autorise l'affichage d'éléments avec des noms différents et éventuellement des types différents, mais le même type de base, dans une position spécifiée dans une instance de document.

Les groupes de substitution imbriqués ne sont pas pris en charge. Autrement dit, si un élément agit comme l'élément head dans un groupe de substitution, il ne peut pas être l'élément substitué dans un autre groupe de substitution. Par exemple :

<xs:element name="Animal" abstract="true"/>
<xs:element name="Mammal" abstract="true" 
    substitutionGroup="tns:Animal"/>
<xs:element name="Dog" type="xs:string" 
    substitutionGroup="tns:Mammal"/>

Celui-ci n'est pas pris en charge, car Mammal agit à la fois comme élément head (pour Dog) et comme élément substitué (pour Animal). Si vous rencontrez un schéma de ce type, Xsd.exe ne génère pas de XmlElementAttribute pour Mammal, et Dog ne se trouve pas où l'élément Animal est prévu. Toutefois, vous pouvez l'ajouter manuellement pour que ce scénario aboutisse, comme indiqué dans l'exemple suivant.

public class PetShop 
{
    private object Animal;
    
    // Apply the XmlElementAttribute to the generated property.
    [System.Xml.Serialization.XmlElementAttribute("Mammal"), 
     System.Xml.Serialization.XmlElementAttribute("Dog")]
    public object Animal {
        get {
            return this.Animal;
        }
        set {
            this.Animal = value;
        }
    }
}

Attribut SubstitutionGroup : élément head concret

Si l'élément head n'est pas abstrait, Xsd.exe utilise chaque référence ref à l'élément head et crée un champ du type correspondant au type de données XML de l'élément head (ou un tableau de ce type, selon la valeur de l'attribut maxOccurs de l'élément contenant la référence). Toute référence au groupe de substitution est perdue.

Alors qu'un objet de type dérivé peut être assigné à ce champ et que la classe XmlSerializer sérialise cet objet, ce comportement a lieu en dehors de la substitution avec les types dérivés. Aucun nom d'élément de substitution n'est utilisé.

Attribut SubstitutionGroup : élément head abstrait

Si l'élément head est abstrait, Xsd.exe crée un champ d'un type correspondant au type de données de l'élément head. Ce champ est appelé Item. Xsd.exe applique à ce champ un XmlElementAttribute pour chacun des substituts. Chaque attribut identifie le nom et, si l'élément de substitution a un type de données dérivé, le type. Si les éléments de substitution utilisent le même type de données que l'élément head, un XmlChoiceIdentifierAttribute doit également être appliqué. Consultez l'élément <choice>.

Voici un exemple de champ généré à partir d'une référence à un élément head abstrait.

[System.Xml.Serialization.XmlElementAttribute("derivedAInstance", typeof(DerivedTypeA))]
[System.Xml.Serialization.XmlElementAttribute("derivedBInstance", typeof(DerivedTypeB))]
public MyBaseType Item;

Si les types dérivés sont utilisés, la sérialisation XML fonctionne uniquement lorsqu'une instance de l'un des types dérivés a été assignée au champ. XmlSerializer échoue si une instance du type de base correspondant à l'élément head a été assignée.

Lors d'une traduction inverse, Xsd.exe crée un élément <choice> contenant un élément <element> pour chacun des éléments de substitution, mais pas pour l'élément head. Les éléments sont définis indépendamment dans la définition de type complexe ; aucune référence ref n'est utilisée.

maxOccurs attribute. Dans une déclaration <element> locale contenant un attribut ref qui spécifie un élément head abstrait, Xsd.exe ignore l'attribut maxOccurs.

Considérez la déclaration suivante qui fait référence à un élément head de type MyBaseType.

<xsd:element ref="baseInstance" minOccurs="0" maxOccurs="unbounded" />

Pour la déclaration précédente, Xsd.exe crée encore le champ suivant (les attributs sont omis).

public MyBaseType Item;

Exemple : attribut SubstitutionGroup

Document de schéma XML d'entrée.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
      targetNamespace="http://example.org/" xmlns="http://example.org/" elementFormDefault="qualified">
  <xsd:element name="baseInstance" type="MyBaseType" abstract="true"/>

  <xsd:complexType name="MyBaseType">
    <xsd:sequence>
      <xsd:element name="Field1" type="xsd:string"/>
      <xsd:element name="Field2" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:element name="derivedAInstance" type="DerivedTypeA" substitutionGroup="baseInstance" />
  <xsd:complexType name="DerivedTypeA">
    <xsd:complexContent>
      <xsd:extension base="MyBaseType">
         <xsd:attribute name="ExtraInfoForA" type="xsd:string"/>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="derivedBInstance" type="DerivedTypeB" substitutionGroup="baseInstance" />
  <xsd:complexType name="DerivedTypeB">
    <xsd:complexContent>
      <xsd:extension base="MyBaseType">
         <xsd:attribute name="ExtraInfoForB" type="xsd:string"/>
      </xsd:extension>
    </xsd:complexContent>
  </xsd:complexType>

  <xsd:element name="myThings" type="MyThingsType" />
  <xsd:complexType name="MyThingsType">
    <xsd:sequence>
      <xsd:element ref="baseInstance" />
    </xsd:sequence>
  </xsd:complexType>
</xsd:schema>

Classes C# générées à partir du document de schéma XML précédent.

[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("derivedAInstance", Namespace="http://example.org/", IsNullable=false)]
public class DerivedTypeA : MyBaseType {
        
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string ExtraInfoForA;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlIncludeAttribute(typeof(DerivedTypeA))]
[System.Xml.Serialization.XmlIncludeAttribute(typeof(DerivedTypeB))]
public class MyBaseType {
    public string Field1;
        
    public string Field2;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("derivedBInstance", Namespace="http://example.org/", IsNullable=false)]
public class DerivedTypeB : MyBaseType {
        
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string ExtraInfoForB;
}
    
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://example.org/")]
[System.Xml.Serialization.XmlRootAttribute("myThings", Namespace="http://example.org/", IsNullable=false)]
public class MyThingsType {       
    [System.Xml.Serialization.XmlElementAttribute("derivedAInstance", typeof(DerivedTypeA))]
    [System.Xml.Serialization.XmlElementAttribute("derivedBInstance", typeof(DerivedTypeB))]
    public MyBaseType Item;
}

Document de schéma XML généré à partir d'un assembly compilé depuis la source C# précédente.

<xs:schema xmlns:tns="http://example.org/" elementFormDefault="qualified" targetNamespace="http://example.org/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:complexType name="MyBaseType">
    <xs:sequence>
      <xs:element minOccurs="0" maxOccurs="1" name="Field1" type="xs:string" />
      <xs:element minOccurs="0" maxOccurs="1" name="Field2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="DerivedTypeA">
    <xs:complexContent mixed="false">
      <xs:extension base="tns:MyBaseType">
        <xs:attribute name="ExtraInfoForA" type="xs:string" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="DerivedTypeB">
    <xs:complexContent mixed="false">
      <xs:extension base="tns:MyBaseType">
        <xs:attribute name="ExtraInfoForB" type="xs:string" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="derivedAInstance" type="tns:DerivedTypeA" />
  <xs:element name="derivedBInstance" type="tns:DerivedTypeB" />
  <xs:element name="myThings" type="tns:MyThingsType" />
  <xs:complexType name="MyThingsType">
    <xs:sequence>
      <xs:choice minOccurs="1" maxOccurs="1">
        <xs:element minOccurs="0" maxOccurs="1" name="derivedAInstance" type="tns:DerivedTypeA" />
        <xs:element minOccurs="0" maxOccurs="1" name="derivedBInstance" type="tns:DerivedTypeB" />
      </xs:choice>
    </xs:sequence>
  </xs:complexType>
</xs:schema>

Attributs possibles Prise en charge de la liaison

abstract

L'utilitaire Xsd.exe lie les groupes de substitution à l'aide des déclarations <element>abstraites, mais crée des éléments <choice> lors d'une traduction inverse.

Consultez la section Attribut Abstract précédente.

block

L'attribut block permet d'empêcher l'utilisation des déclarations d'élément comme éléments head de groupe de substitution (les éléments substitués par les membres de groupes).

L'outil Xsd.exe ignore l'attribut block, ainsi que l'attribut blockDefault de l'élément Prise en charge de la liaison de l'élément Schema.

default

L'attribut default fournit une valeur par défaut à utiliser si l'élément est vide dans une instance de document. Si l'élément n'apparaît pas du tout, il n'est pas rempli.

Lors de la génération du code source à partir d'un document de schéma XML, l'outil Xsd.exe prend chaque champ correspondant à un élément avec une valeur par défaut et applique un System.ComponentModel.DefaultValueAttribute, en passant la valeur par défaut comme un argument. De plus, Xsd.exe initialise statiquement le champ avec la valeur par défaut, comme dans l'exemple suivant.

[System.ComponentModel.DefaultValueAttribute(-1)]
public int age = -1;

Lors de la génération d'un élément <element> à partir d'un membre de classe possédant un type valeur .NET Framework, Xsd.exe utilise l'attribut DefaultValue comme une entrée pour définir l'attribut minOccurs. Si Xsd.exe rencontre un attribut DefaultValue appliqué à ce membre, il génère la valeur 0 pour l'attribut minOccurs de l'élément. Cela indique que l'élément n'a pas besoin d'apparaître dans une instance de document XML valide.

L'attribut par défaut est ignoré sur les tableaux (éléments avec maxOccurs supérieur à 1.)

Consultez l'attribut Prise en charge de la liaison de l'attribut par défaut.

final

L'attribut final permet d'empêcher l'utilisation des déclarations d'élément comme éléments head de groupe de substitution (les éléments substitués par les membres de groupes).

L'outil Xsd.exe ignore l'attribut final, ainsi que l'attribut finalDefault de l'élément <schema>.

fixed

L'attribut fixed fournit une valeur fixe pour l'élément dans une instance de document. Lors de la génération du code source à partir d'un document de Schéma XML, Xsd.exe prend chaque champ correspondant à un élément avec une valeur fixe et génère un initialiseur statique pour le champ, comme dans l'exemple suivant.

public int age = -1;

L'attribut fixed est ignoré sur les tableaux (éléments avec maxOccurs supérieur à 1).

form

L'outil Xsd.exe assimile l'attribut XML form de l'élément <element> avec la propriété Form de XmlElementAttribute. L'infrastructure de sérialisation XML du .NET Framework reconnaît une valeur par défaut différente, qualified.

Si une déclaration <element> dans un schéma XML spécifie form="unqualified", Xsd.exe génère un attribut XmlElement pour le champ correspondant et passe un paramètre Form=XmlSchemaForm.Unqualified à l'attribut.

Consultez l'attribut form.

id

L'utilitaire Xsd.exe ignore l'attribut id qui a pour but de fournir un identificateur unique. À la place, Xsd.exe reconnaît l'attribut name.

maxOccurs

Lors de la génération de classes à partir d'un document XSD, Xsd.exe interprète l'attribut maxOccurs dans l'élément <element> d'après les valeurs possibles suivantes :

  • 1 : Xsd.exe génère un champ de type correspondant au type de données de l'élément.

  • 0 : Xsd.exe ne parvient pas à traiter la valeur 0 et traite cette valeur comme s'il s'agissait de la valeur par défaut 1.

  • unbounded : Xsd.exe génère un champ qui est un tableau de type correspondant au type de données de l'élément.

  • Tout entier supérieur à 1 : comme avec une valeur unbounded, Xsd.exe génère un champ qui est un tableau de type correspondant au type de données de l'élément. Vous pouvez appliquer une valeur supérieure à 1 en validant un document XML avec la classe XmlValidatingReader par rapport à un document de schéma XML représenté par le modèle d'objet de schéma.

Lors de la génération d'un document de schéma XML à partir d'un ensemble de classes dans un assembly, Xsd.exe inverse les conversions précédentes, en générant une valeur maxOccurs de 1 à partir d'une seule instance et une valeur maxOccurs de unbounded à partir d'un tableau.

Alors que Xsd.exe lie une valeur maxOccurs de unbounded à un tableau, il lie une valeur maxOccurs de 1 à l'élément parent désigné d'un tableau, le cas échéant. Consultez l'attribut Prise en charge de la liaison de l'attribut MaxOccurs pour plus d'informations sur le traitement de l'élément maxOccurs concernant les liaisons de tableau, notamment la désignation d'un élément parent supplémentaire.

minOccurs

Pour l'élément <element>, Xsd.exe vérifie la valeur de l'attribut minOccurs uniquement si la valeur de l'attribut Prise en charge de la liaison de l'attribut MaxOccurs n'impose pas de champ de tableau. Ensuite, la valeur est interprétée (ou générée) selon différents facteurs, le premier consistant à déterminer si le champ correspondant a un type référence ou un type valeur.

Consultez l'attribut Prise en charge de la liaison de l'attribut MinOccurs.

name

Pour la génération du code source à partir d'un document XSD, la valeur de l'attribut name fournit le nom du champ de classe public qui représente cet élément. Si l'élément <element> contient une définition <complexType> anonyme, le nom devient le nom de classe qui correspond au type complexe.

Aucune tentative de modification de la casse pour respecter les conventions de codage n'est effectuée. Par exemple, si l'attribut name d'un élément <element> contenant une définition de type complexe anonyme a la valeur testInfo, la classe résultante est nommée testInfo, plutôt que TestInfo en majuscules. Si un nom est en conflit avec un mot clé réservé, le nom résultant est précédé du symbole @.

Lorsque Xsd.exe génère une déclaration <element> à partir d'un champ de classe public, il utilise le nom de champ pour la valeur de l'attribut name. Un autre nom (valeur de l'attribut name) peut être fourni à l'aide des propriétés d'attribut suivantes :

Consultez l'attribut Prise en charge de la liaison de l'attribut Name.

nillable

L'outil Xsd.exe assimile l'attribut nillable à la propriété IsNullable de certains attributs de sérialisation XML appliqués aux types référence. Pour les types valeur, une valeur nillable de true entraîne la génération de types Nullable.

Consultez l'attribut nillable. L'attribut nillable s'affiche uniquement dans l'élément <element>.

ref

Lors de la génération d'un type .NET Framework à partir d'un type complexe de schéma XML, Xsd.exe ne fait pas la différence entre un élément localement déclaré et une référence à un élément globalement déclaré, à moins que l'élément global soit déclaré dans un espace de noms autre que l'espace de noms cible du schéma.

Consultez les sections Référence dans le même espace de noms et Référence à un autre espace de noms.

substitutionGroup

L'outil Xsd.exe reconnaît les groupes de substitution uniquement si l'élément substitué est déclaré abstrait. Ensuite, lors d'une traduction inverse, Xsd.exe crée un élément <choice> contenant un élément <element> pour chacun des substituts.

Consultez la section Attribut SubstitutionGroup précédente.

type

L'outil Xsd.exe associe les types de données référencés à l'attribut type des déclarations <element> et <attribute> aux types .NET Framework.

Xsd.exe ne génère pas de type .NET Framework pour un type de données de schéma XML, à moins que le type de données permette de remonter jusqu'à une déclaration d'élément globale faisant référence à un type de données (éventuellement un autre) via l'attribut type.

Éléments parents possibles :  <all>, <choice>, <schema>, <sequence>

Éléments enfants possibles :  <annotation>, <complexType>, <key>, <keyref>, <simpleType>, <unique>

Voir aussi

Référence

XmlSchemaElement