Importation et exportation de schémas

Article
02/27/2011

Windows Communication Foundation (WCF) comprend un nouveau moteur de sérialisation, le DataContractSerializer. Le moteur de sérialisation DataContractSerializer traduit des objets .NET Framework en langage XML et inversement. Outre le sérialiseur lui-même, WCF intègre un système lui permettant d'importer et d'exporter les schémas afférents. Un schéma est une description formelle et précise dans un format de type XML, générée par le sérialiseur et accessible au désérialiseur. Cette description peut en outre être lue par un ordinateur. Pour créer ses schémas, WCF utilise le langage de définition de schéma XSD, inspiré du langage XML et défini par le consortium World Wide Web Consortium (W3C). Ce format est compatible avec de nombreuses plateformes tierces.

L'importateur de schémas, XsdDataContractImporter, utilise un document de schéma XSD pour générer des classes .NET Framework (il s'agit en principe de classes de contrat de données) et faire correspondre les formes sérialisées générées au schéma donné.

Par exemple, le fragment de schéma suivant :

<xs:complexType name="Vehicle">
  <xs:sequence>
    <xs:element name="year" type="xs:int" />
    <xs:element name="color" type="xs:string" />
  </xs:sequence>
</xs:complexType>

génère le type suivant (légèrement simplifié pour permettre une meilleure compréhension).

Partial Class Vehicle
    Implements IExtensibleDataObject

    Private yearField As Integer
    Private colorField As String
    
    <DataMember()>  _
    Public Property year() As Integer 
        Get
            Return Me.yearField
        End Get
        Set
            Me.yearField = value
        End Set
    End Property
    
    <DataMember()>  _
    Public Property color() As String 
        Get
            Return Me.colorField
        End Get
        Set
            Me.colorField = value
        End Set
    End Property 
    Private extensionDataField As ExtensionDataObject
    
    Public Property ExtensionData() As ExtensionDataObject _
        Implements IExtensibleDataObject.ExtensionData
        Get
            Return Me.extensionDataField
        End Get
        Set (ByVal value As ExtensionDataObject)
            Me.extensionDataField = value
        End Set
    End Property
End Class

[DataContract]
public partial class Vehicle : IExtensibleDataObject
{
    private int yearField;
    private string colorField;

    [DataMember] public int year {
        get {return this.yearField;}
        set {this.yearField=value;}
    }
[DataMember] public string color{
        get {return this.colorField;}
        set {this.colorField=value;}
    }
    
    private ExtensionDataObject extensionDataField;
    public ExtensionDataObject ExtensionData {
        get {return this.extensionDataField;}
        set {this.extensionDataField=value;}
    }
}

Remarque : le type est généré conformément à plusieurs meilleures pratiques en matière de contrat de données. Pour plus d'informations sur ces meilleures pratiques, consultez Meilleures pratiques : contrôle de version des contrats de données.

Ce type implémente l'interface IExtensibleDataObject. Pour plus d'informations, consultez Contrats de données à compatibilité ascendante.
Les membres de données sont implémentés sous forme de propriétés publiques qui encapsulent des champs privés.
La classe est une classe partielle et des éléments peuvent y être ajoutés sans modifier le code généré.

L'exportateur XsdDataContractExporter vous permet d'effectuer l'opération inverse, c'est-à-dire de prendre des types pouvant être sérialisés à l'aide de DataContractSerializer, puis de générer un document de schéma XSD.

Fidélité non garantie

Lors de la conversion, puis reconversion des schémas ou types, la stricte fidélité des informations converties n'est pas garantie. Ce type de processus est désigné par le terme de boucle. Il consiste à importer un schéma afin de créer un ensemble de classes, puis d'exporter le résultat pour recréer le schéma. Il se peut que le schéma ainsi recréé ne soit pas exactement identique au schéma d'origine. Effectuer à nouveau le processus dans le sens inverse ne garantit pas en effet la fidélité aux informations d'origine. (Exportez un type pour générer son schéma, puis réimportez le type. Il est improbable que le même type soit retourné.)

Types pris en charge

Le modèle de contrat de données prend uniquement en charge un sous-ensemble limité de schémas WC3. Tout schéma ne se conformant pas à ce sous-ensemble provoquera la levée d'une exception lors de l'importation. Par exemple, il n'est pas possible d'indiquer qu'un membre de données d'un contrat de données doit être sérialisé sous forme d'attribut XML. Les schémas nécessitant l'utilisation d'attributs XML ne sont donc pas pris en charge et provoqueront la levée d'exceptions lors de l'importation, le contrat de données ne pouvant être généré à l'aide des attributs XML appropriés.

Par exemple, il est impossible d'importer le fragment de schéma suivant à l'aide des paramètres d'importation par défaut.

<xs:complexType name="Vehicle">
  <xs:sequence>
    <xs:element name="year" type="xs:int" />
    <xs:element name="color" type="xs:string" />
  </xs:sequence>
  <xs:attribute name="engineHorsePower" type="xs:int" />
</xs:complexType>

Pour plus d'informations, consultez Référence des schémas de contrats de données. Lorsqu'un schéma ne se conforme pas aux règles des contrats de données, utilisez un autre moteur de sérialisation. Le moteur de sérialisation XmlSerializer utilise, par exemple, son propre mécanisme d'importation de schéma. Il existe également un mode d'importation spécial qui prend en charge un plus large éventail de schémas. Pour plus d'informations, consultez la section sur la génération des types IXmlSerializable dans Importation du schéma pour générer des classes.

L'exportateur XsdDataContractExporter prend en charge tous les types .NET Framework qui peuvent être sérialisés à l'aide du moteur de sérialisation DataContractSerializer. Pour plus d'informations, consultez Types pris en charge par le sérialiseur de contrat de données. Remarque : le schéma généré à l'aide de XsdDataContractExporter contient en principe des données utilisables par l'importateur XsdDataContractImporter, sauf si XmlSchemaProviderAttribute est utilisé afin de personnaliser ce schéma).

Pour plus d'informations sur le sujet suivant l'utilisation de l'importateur XsdDataContractImporter, consultez Importation du schéma pour générer des classes.

Pour plus d'informations sur le sujet suivant l'utilisation de l'exportateur XsdDataContractExporter, consultez Exportation de schémas à partir de classes.

Voir aussi

Référence

DataContractSerializer
XsdDataContractImporter
XsdDataContractExporter

Concepts

Importation du schéma pour générer des classes
Exportation de schémas à partir de classes

Partager via