Référence des schémas de contrats de données
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 |
|
anySimpleType |
|
duration |
|
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 |
|
base64Binary |
Tableau Byte. |
hexBinary |
String. |
float |
|
double |
|
anyURI |
Uri. |
QName |
|
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 |
|
integer |
|
nonPositiveInteger |
Int64. |
negativeInteger |
Int64. |
long |
Int64. |
int |
|
short |
|
Byte |
|
nonNegativeInteger |
Int64. |
unsignedLong |
|
unsignedInt |
|
unsignedShort |
|
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