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

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 partielle pour l'élément <list>.

Le .NET Framework fournit des liaisons exactes pour les déclarations d'attribut XML avec les types list, mais pas pour les déclarations d'élément.

Explication

La construction <list> permet de définir un type simple dont les valeurs possibles sont une série de valeurs séparées par des espaces provenant d'un autre type simple. Les types qui servent de blocs de construction sont appelés types atomiques car qu'ils ne peuvent pas être divisés en sous-éléments explicites. Tout type simple, à l'exception d'un type list ou union, est atomique.

L'exemple suivant explique la création d'un type list dont les valeurs peuvent être des décimales séparées par des espaces :

<xsd:simpleType name="numbersList">
  <xsd:list itemType="xsd:Decimal"/>
</xsd:simpleType>

Le .NET Framework fournit des liaisons pour l'élément <list> lorsqu'il définit des types attribute, mais pas des types element.

Lors de la génération de code source à partir d'un document de schéma XML, si Xsd.exe rencontre un élément avec un type list, il génère un champ dont le type est le type .NET Framework correspondant au type constitutif de la liste, qui est la valeur de l'attribut itemTypeXmlAttributeAttribute. Pour les types basés sur une chaîne, cette traduction est techniquement correcte car une chaîne de chaînes est encore une chaîne. Pour les types list basés sur d'autres types simples, tels que le type basé sur les décimales dans l'exemple précédent, la traduction est erronée.

Si Xsd.exe rencontre un attribut avec un type list, il génère un champ dont le type est un tableau du type .NET Framework qui correspond à la valeur de l'attribut itemType. Le champ apparaît avec l'attribut. Voici un exemple de champ généré :

[System.Xml.Serialization.XmlAttributeAttribute()]
public System.Decimal[] numbers;

De même, lors de la génération d'un document de schéma XML à partir d'un ensemble de classes, Xsd.exe recherche les conditions suivantes dans un champ ou une propriété pour générer un type list :

• Le type de champ ou de propriété est un tableau d'un type qui peut être mappé à un type simple.

• Le champ ou la propriété apparaît avec un attribut XmlAttribute.

Cette combinaison peut être exprimée comme un type <list> uniquement, car un attribut XML doit avoir un type simple et dans le cas contraire, un tableau serait lié à un type complexe (avec un ensemble d'attributs maxOccurs ayant la valeur unbounded).

Exemple

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="alphabet" type="AlphabetType"/>

    <xsd:complexType name="AlphabetType">
        <xsd:sequence>
            <xsd:element name="language" type="xsd:string"/>
            <xsd:element name="count" type="xsd:decimal"/>
        </xsd:sequence>
        <xsd:attribute name="letters">
            <xsd:simpleType>
                <xsd:list itemType="Character"/>
            </xsd:simpleType>
        </xsd:attribute>
    </xsd:complexType>

    <xsd:simpleType name="Character">
        <xsd:restriction base="xsd:string">
            <xsd:length value="1"/>
        </xsd:restriction>
    </xsd:simpleType>
</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("alphabet", Namespace="http://example.org/", IsNullable=false)]
public class AlphabetType {
        
    public string language;
        
    public System.Decimal count;
        
    [System.Xml.Serialization.XmlAttributeAttribute()]
    public string[] letters;
}

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

<xs:complexType name="AlphabetType">
  <xs:sequence>
    <xs:element minOccurs="0" maxOccurs="1" name="language" type="xs:string" />
    <xs:element minOccurs="1" maxOccurs="1" name="count" type="xs:decimal" />
  </xs:sequence>
  <xs:attribute name="letters">
    <xs:simpleType>
      <xs:list itemType="xs:string" />
    </xs:simpleType>
  </xs:attribute>
</xs:complexType>

Éléments parents possibles : <simpleType>

Éléments enfants possibles : <annotation>, <simpleType>

Voir aussi

Référence

XmlSchemaSimpleTypeList