Partager via

Utilisation de contrats de données

Un contrat de données est un accord formel entre un service et un client qui décrit abstraitement les données à échanger. Autrement dit, pour communiquer, le client et le service n’ont pas à partager les mêmes types, seuls les mêmes contrats de données. Un contrat de données définit précisément, pour chaque paramètre ou type de retour, les données sérialisées (transformées en XML) à échanger.

Notions de base du contrat de données

Windows Communication Foundation (WCF) utilise un moteur de sérialisation appelé sérialiseur de contrat de données par défaut pour sérialiser et désérialiser des données (convertir en et à partir de XML). Tous les types primitifs .NET Framework, tels que les entiers et les chaînes, ainsi que certains types traités comme des primitives, tels que DateTime et XmlElement, peuvent être sérialisés sans autre préparation et sont considérés comme ayant des contrats de données par défaut. De nombreux types .NET Framework ont également des contrats de données existants. Pour obtenir la liste complète des types sérialisables, consultez Types pris en charge par le sérialiseur de contrat de données.

Les nouveaux types complexes que vous créez doivent avoir un contrat de données défini pour qu’ils soient sérialisables. Par défaut, le DataContractSerializer déduit le contrat de données et sérialise tous les types visibles publiquement. Toutes les propriétés et champs de lecture/écriture publics du type sont sérialisés. Vous pouvez exclure des membres de la sérialisation à l’aide du IgnoreDataMemberAttribute. Vous pouvez également créer explicitement un contrat de données à l’aide des attributs DataContractAttribute et DataMemberAttribute. Cela est normalement effectué en appliquant l’attribut DataContractAttribute au type. Cet attribut peut être appliqué aux classes, structures et énumérations. L’attribut DataMemberAttribute doit ensuite être appliqué à chaque membre du type de contrat de données pour indiquer qu’il s’agit d’un membre de données, autrement dit, il doit être sérialisé. Pour plus d’informations, consultez Types sérialisables.

Exemple :

L'exemple suivant montre un contrat de service (une interface) auquel les attributs ServiceContractAttribute et OperationContractAttribute ont été appliqués explicitement. L’exemple montre que les types primitifs ne nécessitent pas de contrat de données, tandis qu’un type complexe le fait.

[ServiceContract]
public interface ISampleInterface
{
    // No data contract is required since both the parameter
    // and return types are primitive types.
    [OperationContract]
    double SquareRoot(int root);

    // No Data Contract required because both parameter and return
    // types are marked with the SerializableAttribute attribute.
    [OperationContract]
    System.Drawing.Bitmap GetPicture(System.Uri pictureUri);

    // The MyTypes.PurchaseOrder is a complex type, and thus
    // requires a data contract.
    [OperationContract]
    bool ApprovePurchaseOrder(MyTypes.PurchaseOrder po);
}

<ServiceContract()> _
Public Interface ISampleInterface
    ' No data contract is required since both the parameter and return 
    ' types are both primitive types.
    <OperationContract()> _
    Function SquareRoot(ByVal root As Integer) As Double

    ' No Data Contract required because both parameter and return 
    ' types are marked with the SerializableAttribute attribute.
    <OperationContract()> _
    Function GetPicture(ByVal pictureUri As System.Uri) As System.Drawing.Bitmap

    ' The MyTypes.PurchaseOrder is a complex type, and thus 
    ' requires a data contract.
    <OperationContract()> _
    Function ApprovePurchaseOrder(ByVal po As MyTypes.PurchaseOrder) As Boolean
End Interface

L’exemple suivant montre comment un contrat de données pour le type MyTypes.PurchaseOrder est créé en appliquant les attributs DataContractAttribute et DataMemberAttribute à la classe et à ses membres.

namespace MyTypes
{
    [DataContract]
    public class PurchaseOrder
    {
        private int poId_value;

        // Apply the DataMemberAttribute to the property.
        [DataMember]
        public int PurchaseOrderId
        {

            get { return poId_value; }
            set { poId_value = value; }
        }
    }
}

Namespace MyTypes
    <System.Runtime.Serialization.DataContractAttribute()> _
    Public Class PurchaseOrder
        Private poId_value As Integer

        ' Apply the DataMemberAttribute to the property.

        <DataMember()> _
        Public Property PurchaseOrderId() As Integer

            Get
                Return poId_value
            End Get
            Set
                poId_value = value
            End Set
        End Property
    End Class
End Namespace

Remarques

Les notes suivantes fournissent des éléments à prendre en compte lors de la création de contrats de données :

  • L’attribut IgnoreDataMemberAttribute est respecté uniquement lorsqu’il est utilisé avec des types non marqués. Cela inclut les types qui ne sont pas marqués avec l'un des attributs DataContractAttribute, SerializableAttribute, CollectionDataContractAttribute, ou EnumMemberAttribute, ou marqués comme sérialisables par d'autres moyens (par exemple IXmlSerializable).

  • Vous pouvez appliquer l’attribut DataMemberAttribute aux champs et aux propriétés.

  • Les niveaux d’accessibilité des membres (internes, privés, protégés ou publics) n’affectent pas le contrat de données d’une manière quelconque.

  • L’attribut DataMemberAttribute est ignoré s’il est appliqué aux membres statiques.

  • Pendant la sérialisation, le code de propriété get est appelé pour que les membres de données de propriété obtiennent la valeur des propriétés à sérialiser.

  • Lors de la désérialisation, un objet non initialisé est d'abord créé, sans appeler aucun constructeur du type. Puis, tous les membres de données sont désérialisés.

  • Pendant la désérialisation, le code de propriété set est appelé pour que les membres de données de propriété attribuent aux propriétés la valeur désérialisée.

  • Pour qu’un contrat de données soit valide, il doit être possible de sérialiser tous ses membres de données. Pour obtenir la liste complète des types sérialisables, consultez Types pris en charge par le sérialiseur de contrat de données.

    Les types génériques sont gérés exactement de la même façon que les types non génériques. Il n’existe aucune exigence particulière pour les paramètres génériques. Par exemple, considérez le type suivant.

[DataContract]
public class MyGenericType1<T>
{
    // Code not shown.
}

<DataContract()> _
Public Class MyGenericType1(Of T)
    ' Code not shown.
End Class

Ce type est sérialisable si le type utilisé pour le paramètre de type générique (T) est sérialisable ou non. Étant donné qu’il doit être possible de sérialiser tous les membres de données, le type suivant est sérialisable uniquement si le paramètre de type générique est également sérialisable, comme indiqué dans le code suivant.

[DataContract]
public class MyGenericType2<T>
{
    [DataMember]
    T theData;
}

<DataContract()> _
Public Class MyGenericType2(Of T)
    <DataMember()> _
    Dim theData As T
End Class

Pour obtenir un exemple de code complet d’un service WCF qui définit un contrat de données, consultez l’exemple Contrat de données de base .

Voir aussi

  • Last updated on