Référence des schémas de contrats de données

Article
05/10/2023

Cette rubrique décrit le sous-ensemble du schéma XML (XSD) utilisé par DataContractSerializer pour décrire les types CLR (Common Language Run-time) pour la sérialisation XML.

Mappages DataContractSerializer

Le DataContractSerializer mappe des types CLR à XSD lorsque les métadonnées sont exportées d’un service Windows Communication Foundation (WCF) à l’aide d’un point de terminaison de métadonnées ou à l’aide de l’Outil Service Model Metadata Utility (Svcutil.exe). Pour plus d’informations, consultez Sérialiseur de contrat de données.

DataContractSerializer mappe également XSD aux types CLR lorsque Svcutil.exe est utilisé pour accéder à Web Services Description Language (WSDL) ou aux documents XSD et génère des contrats de données pour les services ou les clients.

Uniquement les instances de schéma XML conformes aux spécifications déclarées dans ce document peuvent être mappées aux types CLR à l'aide de DataContractSerializer.

Niveaux pris en charge

DataContractSerializer fournit les niveaux de prise en charge suivants pour une fonctionnalité de schéma XML donnée :

Pris en charge. Il y a mappage explicite de cette fonctionnalité aux types ou aux attributs CLR (ou les deux à la fois) via DataContractSerializer.
Ignoré. La fonctionnalité est autorisée dans les schémas importés par DataContractSerializer, mais n'a aucun effet sur la génération du code.
Interdit. DataContractSerializer ne prend pas en charge l'importation d'un schéma à l'aide de la fonctionnalité. Par exemple, Svcutil.exe, lors de l'accès à un WSDL avec un schéma qui utilise une telle fonctionnalité, revient à la place à l'utilisation de XmlSerializer . Il s’agit du comportement par défaut.

Informations générales

L’espace de noms du schéma est décrit sur la page XML Schema(Schéma XML). Le préfixe "xs" est utilisé dans ce document.
Les attributs avec un espace de noms qui n'est pas un schéma sont ignorés.
Les annotations (sauf celles décrites dans ce document) sont ignorées.

<xs:schema> : attributs

Attribut	DataContract
`attributeFormDefault`	Ignoré.
`blockDefault`	Ignoré.
`elementFormDefault`	Doit être qualifié. Tous les éléments doivent être qualifiés pour qu'un schéma soit pris en charge par `DataContractSerializer`. Cela peut être accompli soit en définissant le paramètre xs:schema/@elementFormDefault sur "qualified", soit en définissant xs:element/@form sur "qualified" sur chaque déclaration d'élément individuelle.
`finalDefault`	Ignoré.
`Id`	Ignoré.
`targetNamespace`	Pris en charge et mappé à l'espace de noms du contrat de données. Si cet attribut n'est pas spécifié, l'espace de noms vierge est utilisé. Ne peut pas être l’espace de noms réservé `http://schemas.microsoft.com/2003/10/Serialization/`.
`version`	Ignoré.

<xs:schema> : contenu

Contenu	schéma
`include`	Pris en charge. `DataContractSerializer` prend en charge xs:include et xs:import. Toutefois, Svcutil.exe restreint le suivi des références `xs:include/@schemaLocation` et `xs:import/@location` lorsque les métadonnées sont chargées à partir d'un fichier local. La liste des fichiers de schéma doit passer par un mécanisme hors bande et non par `include` dans ce cas ; les documents de schéma `include`sont ignorés.
`redefine`	Interdit. L'utilisation de `xs:redefine` est interdite par `DataContractSerializer` pour des raisons de sécurité : `x:redefine` requiert que `schemaLocation` soit suivi. Dans certaines circonstances, Svcutil.exe restreint l'utilisation de `schemaLocation`à l'aide de DataContract.
`import`	Pris en charge. `DataContractSerializer` prend en charge `xs:include` et `xs:import`. Toutefois, Svcutil.exe restreint le suivi des références `xs:include/@schemaLocation` et `xs:import/@location` lorsque les métadonnées sont chargées à partir d'un fichier local. La liste des fichiers de schéma doit passer par un mécanisme hors bande et non par `include` dans ce cas ; les documents de schéma `include`sont ignorés.
`simpleType`	Pris en charge. Consultez la section `xs:simpleType` .
`complexType`	Pris en charge, mappe aux contrats de données. Consultez la section `xs:complexType` .
`group`	Ignoré. `DataContractSerializer` ne prend pas en charge l'utilisation de `xs:group`, `xs:attributeGroup`et `xs:attribute`. Ces déclarations sont ignorées en tant qu'enfants de `xs:schema`, mais ne peuvent pas être référencées à partir de `complexType` ou d'autres constructions prises en charge.
`attributeGroup`	Ignoré. `DataContractSerializer` ne prend pas en charge l'utilisation de `xs:group`, `xs:attributeGroup`et `xs:attribute`. Ces déclarations sont ignorées en tant qu'enfants de `xs:schema`, mais ne peuvent pas être référencées à partir de `complexType` ou d'autres constructions prises en charge.
`element`	Pris en charge. Consultez la déclaration d'élément globale (GED).
`attribute`	Ignoré. `DataContractSerializer` ne prend pas en charge l'utilisation de `xs:group`, `xs:attributeGroup`et `xs:attribute`. Ces déclarations sont ignorées en tant qu'enfants de `xs:schema`, mais ne peuvent pas être référencées à partir de `complexType` ou d'autres constructions prises en charge.
`notation`	Ignoré.

Types complexes – <xs:complexType>

Informations générales

Chaque type complexe <xs:complexType> mappe à un contrat de données.

<xs:complexType> : attributs

Attribut	schéma
`abstract`	Doit être faux (valeur par défaut).
`block`	Interdit.
`final`	Ignoré.
`id`	Ignoré.
`mixed`	Doit être faux (valeur par défaut).
`name`	Pris en charge et mappé au nom du contrat de données. Si le nom inclut des points, une tentative est faite pour mapper le type à un type interne. Par exemple, un type complexe nommé `A.B` mappe à un type de contrat de données qui est un type interne d'un type portant le nom du contrat de données `A`, mais uniquement si un tel type de contrat de données existe. Plusieurs niveaux d'imbrication sont possibles : par exemple, `A.B.C` peut être un type interne, mais uniquement si à la fois `A` et `A.B` existent.

<xs:complexType> : contenu

Contenu	schéma
`simpleContent`	Les extensions sont interdites. La restriction est autorisée uniquement depuis `anySimpleType`.
`complexContent`	Pris en charge. Consultez « Héritage ».
`group`	Interdit.
`all`	Interdit.
`choice`	Interdit
`sequence`	Pris en charge, mappe aux membres de données d'un contrat de données.
`attribute`	Interdit, même si l'utilisation = "prohibited" (avec une exception). Uniquement les attributs facultatifs de l'espace de noms du schéma de sérialisation standard sont pris en charge. Ils ne mappent pas aux membres de données dans le modèle de programmation du contrat de données. Actuellement, un seul de ces attributs est significatif et est discuté dans la section ISerializable. Tous les autres sont ignorés.
`attributeGroup`	Interdit. Dans le WCF version 1, `DataContractSerializer` ignore la présence de `attributeGroup` à l’intérieur de `xs:complexType`.
`anyAttribute`	Interdit.
(empty)	Mappe à un contrat de données sans membres de données.

<xs:sequence> dans un type complexe : attributs

Attribut	schéma
`id`	Ignoré.
`maxOccurs`	Doit être 1 (valeur par défaut).
`minOccurs`	Doit être 1 (valeur par défaut).

<xs:sequence> dans un type complexe : contenu

Contenu	schéma
`element`	Chaque instance mappe à un membre de données.
`group`	Interdit.
`choice`	Interdit.
`sequence`	Interdit.
`any`	Interdit.
(empty)	Mappe à un contrat de données sans membres de données.

Éléments – <xs:element>

Informations générales

<xs:element> peut se produire dans les contextes suivants :

Il peut se produire dans un <xs:sequence>, qui décrit un membre de données d'un contrat de données normal (qui n'est pas une collection). Dans ce cas, l'attribut maxOccurs doit avoir la valeur 1. (Une valeur de 0 n'est pas autorisée).
Il peut se produire dans un <xs:sequence>, qui décrit un membre de données d'un contrat de données de collection. Dans ce cas, l'attribut maxOccurs doit être supérieur à 1 ou « unbounded ».
Il peut se produire dans un <xs:schema> en tant que déclaration d'élément globale (GED).

<xs:element> avec maxOccurs=1 dans un <xs:sequence> (membres de données)

Attribut	schéma
`ref`	Interdit.
`name`	Pris en charge, mappe au nom du membre de données.
`type`	Pris en charge, mappe au type du membre de données. Pour plus d'informations, consultez le mappage de type/primitif. Si non spécifié (et l'élément ne contient pas de type anonyme), `xs:anyType` est pris en compte.
`block`	Ignoré.
`default`	Interdit.
`fixed`	Interdit.
`form`	Doit être qualifié. Cet attribut peut également être défini via `elementFormDefault` sur `xs:schema`.
`id`	Ignoré.
`maxOccurs`	1
`minOccurs`	Mappe à la propriété IsRequired d'un membre de données (`IsRequired` a la valeur true lorsque `minOccurs` a la valeur 1).
`nillable`	Affecte le mappage de type. Consultez le mappage de type/primitif.

<xs:element> avec maxOccurs>1 dans une <xs:sequence> (Collections)

Mappe à un CollectionDataContractAttribute.
Dans les types collection, un seul xs:element est autorisé dans un xs:sequence.

Les collections peuvent appartenir aux types suivants :

Collections normales (par exemple, tableaux).
Collections de dictionnaires (mappage d'une valeur à une autre; par exemple, un Hashtable).
La seule différence entre un dictionnaire et un tableau pour un type de paire clé/valeur réside dans le modèle de programmation généré. Il existe un mécanisme d'annotation de schéma qui peut être utilisé pour indiquer qu'un type donné est une collection de dictionnaires.

Les règles appliquées aux attributs ref, block, default, fixed, formet id sont les mêmes que pour le type qui n'est pas une collection. Les autres attributs sont inclus dans le tableau suivant.

Attribut	schéma
`name`	Pris en charge, mappe à la propriété ItemName dans l'attribut `CollectionDataContractAttribute` .
`type`	Pris en charge, mappe au type stocké dans la collection.
`maxOccurs`	Supérieur à 1 ou "unbounded". Le schéma DC doit utiliser "unbounded".
`minOccurs`	Ignoré.
`nillable`	Affecte le mappage de type. Cet attribut est ignoré pour les collections de dictionnaires.

<xs:element> dans une déclaration d’élément globale <xs:schema>

Une déclaration d'élément globale (GED) qui a les mêmes nom et espace de noms qu'un type dans le schéma, ou qui définit un type anonyme à l'intérieur d'elle-même, est considérée comme associée au type.
Exportation de schéma : les GED associées sont générées pour chaque type généré, simple et complexe.
Désérialisation/sérialisation : les GED associées sont utilisées comme éléments racine pour le type.
Importation de schéma : les GED associées ne sont pas requises et sont ignorées si elles suivent les règles suivantes (à moins qu'elles définissent des types).

Attribut	schéma
`abstract`	Doit être faux pour les GED associées.
`block`	Interdit dans les GED associées.
`default`	Interdit dans les GED associées.
`final`	Doit être faux pour les GED associées.
`fixed`	Interdit dans les GED associées.
`id`	Ignoré.
`name`	Pris en charge. Consultez la définition des GED associées.
`nillable`	Doit être vrai pour les GED associées.
`substitutionGroup`	Interdit dans les GED associées.
`type`	Pris en charge, doit correspondre au type associé pour les GED associées (à moins que l'élément contienne un type anonyme).

<xs:element> : contenu

Contenu	schéma
`simpleType`	Pris en charge.*
`complexType`	Pris en charge.*
`unique`	Ignoré.
`key`	Ignoré.
`keyref`	Ignoré.
(vide)	Pris en charge.

* L’utilisation des mappages simpleType et complexType, pour les types anonymes est la même que pour les types non anonymes, à l’exception qu’il n’y a pas de contrats de données anonymes, ainsi, un contrat de données nommé est créé, avec un nom généré dérivé du nom d’élément. Les règles pour les types anonymes sont les suivantes :

Détail de l’implémentation WCF : si le nom xs:element ne contient pas de points, le type anonyme mappe à un type interne du type externe de contrat de données. Si le nom contient des points, le type de contrat de données résultant est indépendant (n'est pas un type interne).
Le nom de contrat de données généré du type interne est le nom de contrat de données du type externe suivi par un point, le nom de l'élément et la chaîne "Type".
Si un contrat de données avec un tel nom existe déjà, le nom est rendu unique en ajoutant "1", "2", "3" et ainsi de suite jusqu'à ce qu'un nom unique soit créé.

Types simples - <xs:simpleType>

<xs:simpleType> : attributs

Attribut	schéma
`final`	Ignoré.
`id`	Ignoré.
`name`	Pris en charge, mappe au nom du contrat de données.

<xs:simpleType> : contenu

Contenu	schéma
`restriction`	Pris en charge. Mappe aux contrats de données d'énumération. Cet attribut est ignoré s'il ne correspond pas au modèle d'énumération. Consultez la section des restrictions `xs:simpleType` .
`list`	Pris en charge. Mappe aux contrats de données d'énumération d'indicateur. Consultez la section répertoriant `xs:simpleType` .
`union`	Interdit.

<xs:restriction>

Les restrictions de type complexe sont prises en charge uniquement pour la base = "xs:anyType".
Les restrictions de type simple de xs:string qui n'ont pas de facettes de restriction autres que xs:enumeration sont mappées aux contrats de données d'énumération.
Toutes les autres restrictions de type simple sont mappées aux types qu'elles restreignent. Par exemple, une restriction de xs:int mappe à un entier, tout comme xs:int lui-même. Pour plus d’informations sur le mappage de type primitif, consultez Mappage de type/primitif.

<xs:restriction> : attributs

Attribut	schéma
`base`	Doit être un type simple pris en charge ou `xs:anyType`.
`id`	Ignoré.

<xs:restriction> pour tous les autres cas : contenu

Contenu	schéma
`simpleType`	Si présent, doit être dérivé d'un type primitif pris en charge.
`minExclusive`	Ignoré.
`minInclusive`	Ignoré.
`maxExclusive`	Ignoré.
`maxInclusive`	Ignoré.
`totalDigits`	Ignoré.
`fractionDigits`	Ignoré.
`length`	Ignoré.
`minLength`	Ignoré.
`maxLength`	Ignoré.
`enumeration`	Ignoré.
`whiteSpace`	Ignoré.
`pattern`	Ignoré.
(vide)	Pris en charge.

Énumération

<xs:restriction> pour les énumérations : attributs

Attribut	schéma
`base`	Si présent, doit être `xs:string`.
`id`	Ignoré.

<xs:restriction> pour les énumérations : contenu

Contenu	schéma
`simpleType`	Si présent, doit être une restriction d'énumération prise en charge par le contrat de données (cette section).
`minExclusive`	Ignoré.
`minInclusive`	Ignoré.
`maxExclusive`	Ignoré.
`maxInclusive`	Ignoré.
`totalDigits`	Ignoré.
`fractionDigits`	Ignoré.
`length`	Interdit.
`minLength`	Interdit.
`maxLength`	Interdit.
`enumeration`	Pris en charge. Le "id" d'énumération est ignoré, et "value" mappe au nom de la valeur dans le contrat de données d'énumération.
`whiteSpace`	Interdit.
`pattern`	Interdit.
(empty)	Pris en charge, mappe au type énumération vide.

Le code suivant montre une classe d'énumération C#.

public enum MyEnum
{
  first = 3,
  second = 4,
  third =5
}

Cette classe mappe au schéma suivant par DataContractSerializer. Si les valeurs d'énumération démarrent à partir de 1, les blocs xs:annotation ne sont pas générés.

<xs:simpleType name="MyEnum">
  <xs:restriction base="xs:string">
    <xs:enumeration value="first">
      <xs:annotation>
        <xs:appinfo>
          <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">
          3
          </EnumerationValue>
        </xs:appinfo>
      </xs:annotation>
    </xs:enumeration>
    <xs:enumeration value="second">
      <xs:annotation>
        <xs:appinfo>
          <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">
          4
          </EnumerationValue>
        </xs:appinfo>
      </xs:annotation>
    </xs:enumeration>
  </xs:restriction>
</xs:simpleType>

<xs:list>

DataContractSerializer mappe des types énumération marqués avec System.FlagsAttribute à xs:list dérivé de xs:string. Aucune autre variation xs:list n'est prise en charge.

<xs:list> : attributs

Attribut	schéma
`itemType`	Interdit.
`id`	Ignoré.

<xs:list> : contenu

Contenu	schéma
`simpleType`	Doit être une restriction de `xs:string` utilisant la facette `xs:enumeration` .

Si la valeur d'énumération ne suit pas une progression de puissance de 2 (valeur par défaut pour les indicateurs), la valeur est stockée dans l'élément xs:annotation/xs:appInfo/ser:EnumerationValue .

Par exemple, le code suivant marque un type énumération.

[Flags]
public enum AuthFlags
{
  AuthAnonymous = 1,
  AuthBasic = 2,
  AuthNTLM = 4,
  AuthMD5 = 16,
  AuthWindowsLiveID = 64,
}

Ce type mappe au schéma suivant.

<xs:simpleType name="AuthFlags">
    <xs:list>
      <xs:simpleType>
        <xs:restriction base="xs:string">
          <xs:enumeration value="AuthAnonymous" />
          <xs:enumeration value="AuthBasic" />
          <xs:enumeration value="AuthNTLM" />
          <xs:enumeration value="AuthMD5">
            <xs:annotation>
              <xs:appinfo>
                <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">16</EnumerationValue>
              </xs:appinfo>
            </xs:annotation>
          </xs:enumeration>
          <xs:enumeration value="AuthWindowsLiveID">
            <xs:annotation>
              <xs:appinfo>
                <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">64</EnumerationValue>
              </xs:appinfo>
            </xs:annotation>
          </xs:enumeration>
        </xs:restriction>
      </xs:simpleType>
    </xs:list>
  </xs:simpleType>

Héritage

Règles Générales

Un contrat de données peut hériter d'un autre contrat de données. De tels contrats de données mappent à une base et sont dérivés des types d'extension à l'aide de la construction de schéma XML <xs:extension> .

Un contrat de données ne peut pas hériter d'un contrat de données de collection.

Le code ci-dessous montre un exemple de contrat de données.

[DataContract]
public class Person
{
  [DataMember]
  public string Name;
}
[DataContract]
public class Employee : Person
{
  [DataMember]
  public int ID;
}

Ce contrat de données mappe à la déclaration de type de schéma XML suivante.

<xs:complexType name="Employee">
 <xs:complexContent mixed="false">
  <xs:extension base="tns:Person">
   <xs:sequence>
    <xs:element minOccurs="0" name="ID" type="xs:int"/>
   </xs:sequence>
  </xs:extension>
 </xs:complexContent>
</xs:complexType>
<xs:complexType name="Person">
 <xs:sequence>
  <xs:element minOccurs="0" name="Name"
    nillable="true" type="xs:string"/>
 </xs:sequence>
</xs:complexType>

<xs:complexContent> : attributs

Attribut	schéma
`id`	Ignoré.
`mixed`	Doit être faux.

<xs:complexContent> : contenu

Contenu	schéma
`restriction`	Interdit, sauf lorsque la base = "`xs:anyType`". Ce qui précède équivaut à placer directement le contenu de `xs:restriction` sous le conteneur de `xs:complexContent`.
`extension`	Pris en charge. Mappe à l'héritage de contrat de données.

<xs:extension> dans <xs:complexContent> : attributs

Attribut	schéma
`id`	Ignoré.
`base`	Pris en charge. Mappe au type de contrat de données de base de qui ce type hérite.

<xs:extension> dans <xs:complexContent> : contenu

Les règles sont les mêmes que pour le contenu <xs:complexType> .

Si un <xs:sequence> est fourni, ses éléments membres mappent aux membres de données supplémentaires qui sont présents dans le contrat de données dérivé.

Si un type dérivé contient un élément portant le même nom qu'un élément dans un type de base, la déclaration d'élément en double mappe à un membre de données avec un nom généré pour être unique. Des entiers positifs sont ajoutés au nom du membre de données ("member1", "member2" et ainsi de suite) jusqu'à ce qu'un nom unique soit trouvé. Inversement :

Si un contrat de données dérivé a un membre de données portant le même nom et type qu'un membre de données dans un contrat de données de base, DataContractSerializer génère cet élément correspondant dans le type dérivé.
Si un contrat de données dérivé a un membre de données portant le même nom qu'un membre de données dans un contrat de données de base mais ayant un type différent, DataContractSerializer importe un schéma avec un élément de type xs:anyType à la fois dans le type de base et dans les déclarations de type dérivé. Le nom du type d'origine est conservé dans xs:annotations/xs:appInfo/ser:ActualType/@Name.

Les deux variations peuvent aboutir à schéma ayant un modèle de contenu ambigu, qui dépend de l'ordre des membres de données respectifs.

Mappage de type/primitif

DataContractSerializer utilise le mappage suivant pour les types primitifs de schéma XML.

Type XSD	Type .NET
`anyType`	Object.
`anySimpleType`	String.
`duration`	TimeSpan.
`dateTime`	DateTime.
`dateTimeOffset`	ObjetsDateTime et TimeSpan pour l'offset. Consultez Sérialisation DateTimeOffset ci-dessous.
`time`	String.
`date`	String.
`gYearMonth`	String.
`gYear`	String.
`gMonthDay`	String.
`gDay`	String.
`gMonth`	String.
`boolean`	Boolean
`base64Binary`	TableauByte .
`hexBinary`	String.
`float`	Single.
`double`	Double.
`anyURI`	Uri.
`QName`	XmlQualifiedName.
`string`	String.
`normalizedString`	String.
`token`	String.
`language`	String.
`Name`	String.
`NCName`	String.
`ID`	String.
`IDREF`	String.
`IDREFS`	String.
`ENTITY`	String.
`ENTITIES`	String.
`NMTOKEN`	String.
`NMTOKENS`	String.
`decimal`	Decimal.
`integer`	Int64.
`nonPositiveInteger`	Int64.
`negativeInteger`	Int64.
`long`	Int64.
`int`	Int32.
`short`	Int16.
`Byte`	SByte.
`nonNegativeInteger`	Int64.
`unsignedLong`	UInt64.
`unsignedInt`	UInt32.
`unsignedShort`	UInt16.
`unsignedByte`	Byte.
`positiveInteger`	Int64.

Mappage de types ISerializable

Dans .NET Framework version 1.0, ISerializable a été introduit comme mécanisme général pour sérialiser des objets pour la persistance ou le transfert de données. Il existe de nombreux types .NET Framework qui implémentent ISerializable et qui peuvent être passés entre les applications. DataContractSerializer fournit naturellement le support pour les classes ISerializable . DataContractSerializer mappe des types de schéma d'implémentation ISerializable qui diffèrent uniquement par le QName (nom qualifié) du type et sont des collections de propriétés. Par exemple, le DataContractSerializer mappe Exception au type XSD suivant dans l’espace de noms http://schemas.datacontract.org/2004/07/System.

<xs:complexType name="Exception">
 <xs:sequence>
  <xs:any minOccurs="0" maxOccurs="unbounded"
      namespace="##local" processContents="skip"/>
 </xs:sequence>
 <xs:attribute ref="ser:FactoryType"/>
</xs:complexType>

L'attribut facultatif ser:FactoryType déclaré dans le schéma de sérialisation du contrat de données référence une classe de fabrique qui peut désérialiser le type. La classe de fabrique doit faire partie de la collection de types connus de l'instance DataContractSerializer qui est utilisée. Pour plus d’informations sur les types connus, consultez Types connus de contrat de données.

Schéma de sérialisation DataContract

Plusieurs schémas exportés par DataContractSerializer , utilisent des types, des éléments et des attributs d'un espace de noms spécial de la sérialisation du contrat de données :

http://schemas.microsoft.com/2003/10/Serialization

Voici une déclaration de schéma de sérialisation du contrat de données complète.

<xs:schema attributeFormDefault="qualified"
   elementFormDefault="qualified"
   targetNamespace =
    "http://schemas.microsoft.com/2003/10/Serialization/"
   xmlns:xs="http://www.w3.org/2001/XMLSchema"
   xmlns:tns="http://schemas.microsoft.com/2003/10/Serialization/">

 <!-- Top-level elements for primitive types. -->
 <xs:element name="anyType" nillable="true" type="xs:anyType"/>
 <xs:element name="anyURI" nillable="true" type="xs:anyURI"/>
 <xs:element name="base64Binary"
       nillable="true" type="xs:base64Binary"/>
 <xs:element name="boolean" nillable="true" type="xs:boolean"/>
 <xs:element name="byte" nillable="true" type="xs:byte"/>
 <xs:element name="dateTime" nillable="true" type="xs:dateTime"/>
 <xs:element name="decimal" nillable="true" type="xs:decimal"/>
 <xs:element name="double" nillable="true" type="xs:double"/>
 <xs:element name="float" nillable="true" type="xs:float"/>
 <xs:element name="int" nillable="true" type="xs:int"/>
 <xs:element name="long" nillable="true" type="xs:long"/>
 <xs:element name="QName" nillable="true" type="xs:QName"/>
 <xs:element name="short" nillable="true" type="xs:short"/>
 <xs:element name="string" nillable="true" type="xs:string"/>
 <xs:element name="unsignedByte"
       nillable="true" type="xs:unsignedByte"/>
 <xs:element name="unsignedInt"
       nillable="true" type="xs:unsignedInt"/>
 <xs:element name="unsignedLong"
       nillable="true" type="xs:unsignedLong"/>
 <xs:element name="unsignedShort"
       nillable="true" type="xs:unsignedShort"/>

 <!-- Primitive types introduced for certain .NET simple types. -->
 <xs:element name="char" nillable="true" type="tns:char"/>
 <xs:simpleType name="char">
  <xs:restriction base="xs:int"/>
 </xs:simpleType>

 <!-- xs:duration is restricted to an ordered value space,
    to map to System.TimeSpan -->
 <xs:element name="duration" nillable="true" type="tns:duration"/>
 <xs:simpleType name="duration">
  <xs:restriction base="xs:duration">
   <xs:pattern
     value="\-?P(\d*D)?(T(\d*H)?(\d*M)?(\d*(\.\d*)?S)?)?"/>
   <xs:minInclusive value="-P10675199DT2H48M5.4775808S"/>
   <xs:maxInclusive value="P10675199DT2H48M5.4775807S"/>
  </xs:restriction>
 </xs:simpleType>

 <xs:element name="guid" nillable="true" type="tns:guid"/>
 <xs:simpleType name="guid">
  <xs:restriction base="xs:string">
   <xs:pattern value="[\da-fA-F]{8}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{12}"/>
  </xs:restriction>
 </xs:simpleType>

 <!-- This is used for schemas exported from ISerializable type. -->
 <xs:attribute name="FactoryType" type="xs:QName"/>
</xs:schema>

Il convient de remarquer les points suivants :

ser:char est introduit pour représenter des caractères Unicode de type Char.
Le valuespace de xs:duration est réduit à un jeu ordonné afin qu'il puisse être mappé à un TimeSpan.
FactoryType est utilisé dans les schémas exportés des types dérivés de ISerializable.

Importation de schémas qui ne sont pas DataContract

DataContractSerializer dispose de l'option ImportXmlTypes pour autoriser l'importation des schémas non conformes au profil XSD DataContractSerializer (consultez la propriété Options ). Affecter à cette option la valeur true active l'acceptation des types de schémas non conformes et les mappe à l'implémentation suivante, IXmlSerializable qui encapsule un tableau de XmlNode (seul le nom de la classe diffère).

[GeneratedCodeAttribute("System.Runtime.Serialization", "3.0.0.0")]
[System.Xml.Serialization.XmlSchemaProviderAttribute("ExportSchema")]
[System.Xml.Serialization.XmlRootAttribute(IsNullable=false)]
public partial class Person : object, IXmlSerializable
{
  private XmlNode[] nodesField;
  private static XmlQualifiedName typeName =
new XmlQualifiedName("Person","http://Microsoft.ServiceModel.Samples");
  public XmlNode[] Nodes
  {
    get {return this.nodesField;}
    set {this.nodesField = value;}
  }
  public void ReadXml(XmlReader reader)
  {
    this.nodesField = XmlSerializableServices.ReadNodes(reader);
  }
  public void WriteXml(XmlWriter writer)
  {
    XmlSerializableServices.WriteNodes(writer, this.Nodes);
  }
  public System.Xml.Schema.XmlSchema GetSchema()
  {
    return null;
  }
  public static XmlQualifiedName ExportSchema(XmlSchemaSet schemas)
  {
    XmlSerializableServices.AddDefaultSchema(schemas, typeName);
    return typeName;
  }
}

Sérialisation DateTimeOffset

DateTimeOffset n'est pas traité comme un type primitif. À la place, il est sérialisé comme un élément complexe comportant deux parties. La première partie représente la date et l'heure et la deuxième partie représente l'offset de la date et de l'heure. Un exemple d'une valeur DateTimeOffset sérialisée est illustré dans le code suivant.

<OffSet xmlns:a="http://schemas.datacontract.org/2004/07/System">
  <DateTime i:type="b:dateTime" xmlns=""
    xmlns:b="http://www.w3.org/2001/XMLSchema">2008-08-28T08:00:00
  </DateTime>
  <OffsetMinutes i:type="b:short" xmlns=""
   xmlns:b="http://www.w3.org/2001/XMLSchema">-480
   </OffsetMinutes>
</OffSet>

Le schéma se présente comme suit :

<xs:schema targetNamespace="http://schemas.datacontract.org/2004/07/System">
   <xs:complexType name="DateTimeOffset">
      <xs:sequence minOccurs="1" maxOccurs="1">
         <xs:element name="DateTime" type="xs:dateTime"
         minOccurs="1" maxOccurs="1" />
         <xs:element name="OffsetMinutes" type="xs:short"
         minOccurs="1" maxOccurs="1" />
      </xs:sequence>
   </xs:complexType>
</xs:schema>

Référence des schémas de contrats de données

Mappages DataContractSerializer

Niveaux pris en charge

Informations générales

<xs:schema> : attributs

<xs:schema> : contenu

Types complexes – <xs:complexType>

Informations générales

<xs:complexType> : attributs

<xs:complexType> : contenu

<xs:sequence> dans un type complexe : attributs

<xs:sequence> dans un type complexe : contenu

Éléments – <xs:element>

Informations générales

<xs:element> avec maxOccurs=1 dans un <xs:sequence> (membres de données)

<xs:element> avec maxOccurs>1 dans une <xs:sequence> (Collections)

<xs:element> dans une déclaration d’élément globale <xs:schema>

<xs:element> : contenu

Types simples - <xs:simpleType>

<xs:simpleType> : attributs

<xs:simpleType> : contenu

<xs:restriction>

<xs:restriction> : attributs

<xs:restriction> pour tous les autres cas : contenu

Énumération

<xs:restriction> pour les énumérations : attributs

<xs:restriction> pour les énumérations : contenu

<xs:list>

<xs:list> : attributs

<xs:list> : contenu

Héritage

Règles Générales

<xs:complexContent> : attributs

<xs:complexContent> : contenu

<xs:extension> dans <xs:complexContent> : attributs

<xs:extension> dans <xs:complexContent> : contenu

Mappage de type/primitif

Mappage de types ISerializable

Schéma de sérialisation DataContract

Importation de schémas qui ne sont pas DataContract

Sérialisation DateTimeOffset

Voir aussi

Ressources supplémentaires