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

Article
02/27/2011

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

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 Tool (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. La valeur est par défaut.

Informations générales

L'espace de noms du schéma est décrit dans le schéma XML (page pouvant être en anglais) 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é.
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

Sommaire	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 la version 1 finale de WCF, DataContractSerializer ignore la présence de attributeGroup à l'intérieur de xs:complexType.
anyAttribute	Interdit.
(vide)	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

Sommaire	Schéma
element	Chaque instance mappe à un membre de données.
group	Interdit.
choice	Interdit.
sequence	Interdit.
any	Interdit.
(vide)	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 un <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, form et 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 un <xs:schema> (déclaration d'élément globale)

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

Sommaire	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

Sommaire	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 sujet suivant le mappage de type primitif, consultez la section 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

Sommaire	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

Sommaire	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.
(vide)	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="https://schemas.microsoft.com/2003/10/Serialization/">
     3
    </EnumerationValue>
   </xs:appinfo>
  </xs:annotation>
 </xs:enumeration>
 <xs:enumeration value="second">
  <xs:annotation>
   <xs:appinfo>
    <EnumerationValue 
     xmlns="https://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

Sommaire	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,
  AuthPassport = 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="https://schemas.microsoft.com/2003/10/Se
rialization/">16</EnumerationValue>
              </xs:appinfo>
            </xs:annotation>
          </xs:enumeration>
          <xs:enumeration value="AuthPassport">
            <xs:annotation>
              <xs:appinfo>
                <EnumerationValue xmlns="https://schemas.microsoft.com/2003/10/Se
rialization/">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

Sommaire	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	Objets DateTime 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	Tableau Byte.
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 le .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 y a de nombreux types .NET Framework qui implémentent ISerializable et qui peuvent être passés entre des 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, 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 le sujet suivant les types connus, consultez Types connus de contrats 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 :

https://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 = 
    "https://schemas.microsoft.com/2003/10/Serialization/" 
   xmlns:xs="http://www.w3.org/2001/XMLSchema"      
   xmlns:tns="https://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:b="http://www.w3.org/2001/XMLSchema">2008-08-28T08:00:00  
  </DateTime> 
  <OffsetMinutes i:type="b:short"  
   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:elementname="OffsetMinutes" type="xs:short"
         minOccurs="1" maxOccurs="1" />
      </xs:sequence>
   </xs:complexType>
</xs:schema>

Voir aussi

Référence

DataContractSerializer
DataContractAttribute
DataMemberAttribute
XsdDataContractImporter

Concepts

Utilisation de contrats de données

Partager via

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 un <xs:sequence> (collections)

<xs:element> dans un <xs:schema> (déclaration d'élément globale)

<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

Référence

Concepts

Ressources supplémentaires