Delen via

Gegevenscontracten gebruiken

  • Artikel

Een gegevenscontract is een formele overeenkomst tussen een service en een klant die de gegevens die moeten worden uitgewisseld abstract beschrijft. Dat wil gezegd, om te communiceren, hoeven de client en de service niet dezelfde typen te delen, alleen dezelfde gegevenscontracten. Een gegevenscontract definieert nauwkeurig voor elke parameter of elk retourtype welke gegevens worden geserialiseerd (omgezet in XML) die moeten worden uitgewisseld.

Basisbeginselen van gegevenscontract

Windows Communication Foundation (WCF) gebruikt standaard een serialisatie-engine met de naam Data Contract Serializer om gegevens te serialiseren en deserialiseren (converteer deze naar en van XML). Alle primitieve .NET Framework-typen, zoals gehele getallen en tekenreeksen, evenals bepaalde typen die worden behandeld als primitieven, zoals DateTime en XmlElement, kunnen worden geserialiseerd zonder andere voorbereiding en worden beschouwd als standaardgegevenscontracten. Veel .NET Framework-typen hebben ook bestaande gegevenscontracten. Zie Typen die worden ondersteund door de Serializer van het gegevenscontract voor een volledige lijst met serialiseerbare typen.

Nieuwe complexe typen die u maakt, moeten een gegevenscontract hebben gedefinieerd om ze te serializeerbaar te maken. DataContractSerializer Standaard wordt het gegevenscontract afgeleid en worden alle openbaar zichtbare typen geserialiseerd. Alle openbare eigenschappen voor lezen/schrijven en velden van het type worden geserialiseerd. U kunt leden afmelden voor serialisatie met behulp van de IgnoreDataMemberAttribute. U kunt ook expliciet een gegevenscontract maken met behulp van DataContractAttribute en DataMemberAttribute kenmerken. Dit wordt normaal gesproken gedaan door het DataContractAttribute kenmerk toe te passen op het type. Dit kenmerk kan worden toegepast op klassen, structuren en opsommingen. Het DataMemberAttribute kenmerk moet vervolgens worden toegepast op elk lid van het gegevenscontracttype om aan te geven dat het een gegevenslid is, dat wil zeggen dat het moet worden geserialiseerd. Zie Serializable Types voor meer informatie.

Opmerking

In het volgende voorbeeld ziet u een servicecontract (een interface) waarop de ServiceContractAttribute en OperationContractAttribute kenmerken expliciet zijn toegepast. In het voorbeeld ziet u dat primitieve typen geen gegevenscontract vereisen, terwijl een complex type dat wel doet.

[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

In het volgende voorbeeld ziet u hoe een gegevenscontract voor het MyTypes.PurchaseOrder type wordt gemaakt door de DataContractAttribute en DataMemberAttribute kenmerken toe te passen op de klasse en de bijbehorende leden.

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

Opmerkingen

De volgende opmerkingen bevatten items waarmee u rekening moet houden bij het maken van gegevenscontracten:

  • Het IgnoreDataMemberAttribute kenmerk wordt alleen gehonoreerd wanneer het wordt gebruikt met niet-gemarkeerde typen. Dit omvat typen die niet zijn gemarkeerd met een van de DataContractAttribute, SerializableAttributeof CollectionDataContractAttributeEnumMemberAttribute kenmerken, of gemarkeerd als serialiseerbaar op een andere manier (zoals IXmlSerializable).

  • U kunt het DataMemberAttribute kenmerk toepassen op velden en eigenschappen.

  • Toegankelijkheidsniveaus van leden (intern, privé, beveiligd of openbaar) hebben geen invloed op het gegevenscontract.

  • Het DataMemberAttribute kenmerk wordt genegeerd als het wordt toegepast op statische leden.

  • Tijdens de serialisatie wordt code voor eigenschapsgegevens aangeroepen om de waarde op te halen van de eigenschappen die moeten worden geserialiseerd.

  • Tijdens de deserialisatie wordt eerst een niet-geïnitialiseerd object gemaakt, zonder constructors op het type aan te roepen. Vervolgens worden alle gegevensleden gedeserialiseerd.

  • Tijdens de deserialisatie wordt code van de eigenschapsset aangeroepen voor eigenschapsgegevensleden om de eigenschappen in te stellen op de waarde die wordt gedeserialiseerd.

  • Als een gegevenscontract geldig is, moet het mogelijk zijn om alle gegevensleden te serialiseren. Zie Typen die worden ondersteund door de Serializer van het gegevenscontract voor een volledige lijst met serialiseerbare typen.

    Algemene typen worden op exact dezelfde manier verwerkt als niet-algemene typen. Er zijn geen speciale vereisten voor algemene parameters. Denk bijvoorbeeld aan het volgende type.

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

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

Dit type kan worden serialiseerbaar, ongeacht of het type dat wordt gebruikt voor de algemene typeparameter (T) serialiseerbaar is of niet. Omdat het mogelijk moet zijn om alle gegevensleden te serialiseren, kan het volgende type alleen worden geserialiseerd als de algemene typeparameter ook serialiseerbaar is, zoals wordt weergegeven in de volgende code.

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

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

Zie het voorbeeld van een basisgegevenscontract voor een volledig codevoorbeeld van een WCF-service waarmee een gegevenscontract wordt gedefinieerd.

Zie ook