Partager via

Importation et exportation de schéma

Windows Communication Foundation (WCF) inclut un nouveau moteur de sérialisation, le DataContractSerializer. Traduit DataContractSerializer entre les objets .NET Framework et XML (dans les deux sens). Outre le sérialiseur lui-même, WCF inclut les mécanismes d’importation de schéma et d’exportation de schéma associés. Le schéma est une description formelle, précise et lisible par l’ordinateur de la forme XML que le sérialiseur produit ou que le désérialiseur peut accéder. WCF utilise le langage XSD (World Wide Web Consortium) XML Schema Definition Language (XSD) comme représentation de schéma, qui est largement interopérable avec de nombreuses plateformes tierces.

Le composant d’importation de schéma, XsdDataContractImporterprend un document de schéma XSD et génère des classes .NET Framework (normalement des classes de contrat de données) de sorte que les formulaires sérialisés correspondent au schéma donné.

Par exemple, le fragment de schéma suivant :

XsdDataContractImporter importer = new XsdDataContractImporter();
importer.Options.Namespaces.Add(new KeyValuePair<string, string>("http://schemas.contoso.com/carSchema", "Contoso.Cars"));

Dim importer As New XsdDataContractImporter
importer.Options.Namespaces.Add(New KeyValuePair(Of String, String)("http://schemas.contoso.com/carSchema", "Contoso.Cars"))

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

[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; }
    }
}

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

Notez que le type généré suit plusieurs bonnes pratiques de contrat de données (décrites dans Best Practices : Data Contract Versioning) :

  • Le type implémente l’interface IExtensibleDataObject . Pour plus d’informations, consultez Forward-Compatible Contrats de données.

  • Les membres de données sont implémentés en tant que propriétés publiques qui encapsulent les champs privés.

  • La classe est une classe partielle et des ajouts peuvent être effectués sans modifier le code généré.

Il XsdDataContractExporter vous permet d’effectuer l’inverse : prenez des types sérialisables avec le DataContractSerializer document de schéma XSD et générez un document de schéma XSD.

La fidélité n’est pas garantie

Il n’est pas garanti que le schéma ou les types effectuent un aller-retour avec fidélité totale. (Un aller-retour signifie importer un schéma pour créer un ensemble de classes et exporter le résultat pour créer à nouveau un schéma.) Le même schéma peut ne pas être retourné. L’inversion du processus n’est pas non plus garantie pour préserver la fidélité. (Exportez un type pour générer son schéma, puis importez le type. Il est peu probable que le même type soit retourné.)

Types pris en charge

Le modèle de contrat de données ne prend en charge qu’un sous-ensemble limité du schéma WC3. Tout schéma qui n’est pas conforme à ce sous-ensemble entraîne une exception pendant le processus d’importation. Par exemple, il n’existe aucun moyen de spécifier qu’un membre de données d’un contrat de données doit être sérialisé en tant qu’attribut XML. Ainsi, les schémas qui nécessitent l’utilisation d’attributs XML ne sont pas pris en charge et entraînent des exceptions pendant l’importation, car il est impossible de générer un contrat de données avec la projection XML correcte.

Par exemple, le fragment de schéma suivant ne peut pas être importé à 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. Si un schéma n’est pas conforme aux règles de contrat de données, utilisez un autre moteur de sérialisation. Par exemple, il XmlSerializer utilise son propre mécanisme d’importation de schéma distinct. En outre, il existe un mode d’importation spécial dans lequel la plage de schémas pris en charge est développée. Pour plus d’informations, consultez la section sur la génération de IXmlSerializable types dans Importing Schema to Generate Classes.

Prend XsdDataContractExporter en charge tous les types .NET Framework qui peuvent être sérialisés avec le DataContractSerializer. Pour plus d’informations, consultez Types pris en charge par le sérialiseur de contrat de données. Notez que le schéma généré à l’aide des XsdDataContractExporter données est normalement valide que le XsdDataContractImporter schéma peut utiliser (sauf si celui-ci XmlSchemaProviderAttribute est utilisé pour personnaliser le schéma).

Pour plus d’informations sur l’utilisation du XsdDataContractImporterschéma, consultez Importation de schéma pour générer des classes.

Pour plus d’informations sur l’utilisation des XsdDataContractExporterschémas, consultez Exportation de schémas à partir de classes.

Voir aussi

  • Last updated on