DatenvertragsäquivalenzData Contract Equivalence

Damit ein Client erfolgreich Daten eines bestimmten Typs an einen Dienst sendet oder ein Dienst erfolgreich Daten an einen Client sendet, muss der gesendete Typ nicht unbedingt an der Empfängerseite vorhanden sein.For a client to successfully send data of a certain type to a service, or a service to successfully send data to a client, the sent type does not necessarily have to exist on the receiving end. Die einzige Anforderung ist, dass die Datenverträge beider Typen äquivalent sind.The only requirement is that the data contracts of both types be equivalent. (Manchmal strenger Äquivalenz ist nicht erforderlich, wie in beschrieben Datenvertragsversionsverwaltung.)(Sometimes, strict equivalence is not required, as discussed in Data Contract Versioning.)

Die Äquivalenz von Datenverträgen wird durch denselben Namespace und Namen gewährleistet.For data contracts to be equivalent, they must have the same namespace and name. Darüber hinaus muss jeder Datenmember auf einer Seite über einen entsprechenden Datenmember auf der anderen Seite verfügen.Additionally, each data member on one side must have an equivalent data member on the other side.

Die Äquivalenz von Datenmembern wird durch denselben Namen gewährleistet.For data members to be equivalent, they must have the same name. Darüber hinaus müssen sie denselben Datentyp aufweisen; das heißt, ihre Datenverträge müssen äquivalent sein.Additionally, they must represent the same type of data; that is, their data contracts must be equivalent.

Hinweis

Bei Datenvertragsnamen und Namespaces sowie Datenmembernamen ist Groß-/Kleinschreibung zu beachten.Note that data contract names and namespaces, as well as data member names, are case-sensitive.

Weitere Informationen finden Sie unterFor more information aboutDatenvertragsnamen und Namespaces sowie Datenmembernamen finden Sie unter Datenvertragsnamen. data contract names and namespaces, as well as data member names, see Data Contract Names.

Sind zwei Typen auf derselben Seite vorhanden (Absender oder Empfänger) und sind die Datenverträge nicht äquivalent (wenn sie beispielsweise unterschiedliche Datenmember besitzen), sollten sie nicht denselben Name und denselben Namespace erhalten.If two types exist on the same side (sender or receiver) and their data contracts are not equivalent (for example, they have different data members), you should not give them the same name and namespace. Falls Sie doch denselben Namen bzw. Namespace zuweisen, werden möglicherweise Ausnahmen ausgelöst.Doing so may cause exceptions to be thrown.

Die Datenverträge für die folgenden Typen sind äquivalent:The data contracts for the following types are equivalent:

[DataContract]
public class Customer
{
    [DataMember]
    public string fullName;

    [DataMember]
    public string telephoneNumber;
}

[DataContract(Name = "Customer")]
public class Person
{
    [DataMember(Name = "fullName")]
    private string nameOfPerson;

    private string address;

    [DataMember(Name = "telephoneNumber")]
    private string phoneNumber;
}
<DataContract()> _
Public Class Customer

    <DataMember()> _
    Public fullName As String

    <DataMember()> _
    Public telephoneNumber As String
End Class

<DataContract(Name:="Customer")> _
    Public Class Person

    <DataMember(Name:="fullName")> _
    Private nameOfPerson As String

    Private address As String

    <DataMember(Name:="telephoneNumber")> _
    Private phoneNumber As String
End Class

Datenmemberreihenfolge und DatenvertragsäquivalenzData Member Order and Data Contract equivalence

Die Verwendung der Order-Eigenschaft der DataMemberAttribute-Klasse wirkt sich unter Umständen auf die Äquivalenz des Datenvertrags aus.Using the Order property of the DataMemberAttribute class may affect data contract equivalence. Die Datenverträge sind nur äquivalent, wenn sie über Member verfügen, die in der gleichen Reihenfolge angezeigt werden.The data contracts must have members that appear in the same order to be equivalent. Die Standardreihenfolge ist alphabetisch.The default order is alphabetical. Weitere Informationen finden Sie unterFor more information, seeDatenmemberreihenfolge. Data Member Order.

Zum Beispiel führt der folgende Code zu äquivalenten Datenverträgen.For example, the following code results in equivalent data contracts.

[DataContract(Name = "Coordinates")]
public class Coords1
{
    [DataMember]
    public int X;
    [DataMember]
    public int Y;
    // Order is alphabetical (X,Y).
}

[DataContract(Name = "Coordinates")]
public class Coords2
{
    [DataMember]
    public int Y;
    [DataMember]
    public int X;
    // Order is alphabetical (X,Y), equivalent 
    // to the preceding code.
}

[DataContract(Name = "Coordinates")]
public class Coords3
{
    [DataMember(Order = 2)]
    public int Y;
    [DataMember(Order = 1)]
    public int X;
    // Order is according to the Order property (X,Y), 
    // equivalent to the preceding code.
}
<DataContract(Name := "Coordinates")> _
Public Class Coords1
    <DataMember()> _
    Public X As Integer
    <DataMember()> _
    Public Y As Integer
    ' Order is alphabetical (X,Y).
End Class

<DataContract(Name := "Coordinates")> _
Public Class Coords2

    <DataMember()> _
    Public Y As Integer
    <DataMember()> _
    Public X As Integer
    ' Order is alphabetical (X,Y), equivalent 
    ' to the preceding code.
End Class

<DataContract(Name := "Coordinates")> _
Public Class Coords3
    <DataMember(Order := 2)> _
    Public Y As Integer
    <DataMember(Order := 1)> _
    Public X As Integer
    ' Order is according to the Order property (X,Y), 
    ' equivalent to the preceding code.
End Class

Folgendes führt jedoch nicht zu einem äquivalenten Datenvertrag.However, the following does not result in an equivalent data contract.

[DataContract(Name = "Coordinates")]
public class Coords4
{
    [DataMember(Order = 1)]
    public int Y;
    [DataMember(Order = 2)]
    public int X;
    // Order is according to the Order property (Y,X), 
    // different from the preceding code.
}
<DataContract(Name := "Coordinates")> _
Public Class Coords4

    <DataMember(Order := 1)> _
    Public Y As Integer
    <DataMember(Order := 2)> _
    Public X As Integer
    ' Order is according to the Order property (Y,X), 
    ' different from the preceding code.
End Class

Vererbung, Schnittstellen und DatenvertragsäquivalenzInheritance, Interfaces, and Data Contract Equivalence

Beim Bestimmen der Äquivalenz wird ein Datenvertrag, der von einem anderen Datenvertrag erbt, so behandelt, als ob es sich nur um einen Datenvertrag mit allen Datenmembern vom Basistyp handelt.When determining equivalence, a data contract that inherits from another data contract is treated as if it is just one data contract that includes all of the data members from the base type. Die Reihenfolge der Datenmember muss übereinstimmen, und die Basistypmember müssen in der Reihenfolge vor den abgeleiteten Typmembern stehen.Keep in mind that the order of the data members must match and that base type members precede derived type members in the order. Verfügen zwei Datenmember – wie im folgenden Codesbeispiel – über denselben Reihenfolgenwert, werden diese Datenmember darüber hinaus alphabetisch sortiert.Furthermore, if, as in the following code example, two data members have the same order value, the ordering for those data members is alphabetical. Weitere Informationen finden Sie unterFor more information, seeDatenmemberreihenfolge. Data Member Order.

Im folgenden Beispiel entspricht der Datenvertrag für den Typ Employee dem Datenvertrag für den Typ Worker.In the following example, the data contract for type Employee is equivalent to the data contract for the type Worker.

[DataContract]
public class Person
{
    [DataMember]
    public string name;
}
[DataContract]
public class Employee : Person
{
    [DataMember]
    public int department;
    [DataMember]
    public string title;
    [DataMember]
    public int salary;
}
// Order is "name", "department", "salary", "title" 
// (base class first, then alphabetical).

[DataContract(Name = "Employee")]
public class Worker
{
    [DataMember(Order = 1)]
    public string name;
    [DataMember(Order = 2)]
    public int department;
    [DataMember(Order = 2)]
    public string title;
    [DataMember(Order = 2)]
    public int salary;
}
// Order is "name", "department", "salary", "title" 
// (Order=1 first, then Order=2 in alphabetical order), 
// which is equivalent to the Employee order}.
<DataContract()> _
Public Class Person
    <DataMember()> Public name As String
End Class

<DataContract()> _
Public Class Employee
    Inherits Person
    <DataMember()> Public department As Integer
    <DataMember()> Public title As String
    <DataMember()> Public salary As Integer
End class 

' Order is "name", "department", "salary", "title" 
' (base class first, then alphabetical).

<DataContract(Name:="Employee")> _
Public Class Worker

    <DataMember(Order := 1)> _
    Public name As String
    <DataMember(Order := 2)> _
    Public department As Integer
    <DataMember(Order := 2)> _
    Public title As String
    <DataMember(Order := 2)> _
    Public salary As Integer
End Class
' Order is "name", "department", "salary", "title" 
' (Order=1 first, then Order=2 in alphabetical order), 
' which is equivalent to the Employee order}.

Beim Übergeben von Parametern und der Rückgabe von Werten zwischen einem Client und einem Dienst kann ein Datenvertrag von einer Basisklasse nicht gesendet werden, wenn der empfangende Endpunkt einen Datenvertrag von einer abgeleiteten Klasse erwartet.When passing parameters and return values between a client and a service, a data contract from a base class cannot be sent when the receiving endpoint expects a data contract from a derived class. Dies stimmt mit objektorientierten Programmierungsgrundsätzen überein.This is in accordance with object-oriented programming tenets. Im vorherigen Beispiel, ein Objekt des Typs Person kann nicht gesendet werden, wenn ein Employee wird erwartet.In the previous example, an object of type Person cannot be sent when an Employee is expected.

Ein Datenvertrag von einer abgeleiteten Klasse kann gesendet werden, wenn ein Datenvertrag von einer Basisklasse erwartet wird. Dies ist jedoch nur möglich, falls der empfangende Endpunkt unter Verwendung von KnownTypeAttribute über den abgeleiteten Typen "informiert" ist.A data contract from a derived class can be sent when a data contract from a base class is expected, but only if the receiving endpoint "knows" of the derived type using the KnownTypeAttribute. Weitere Informationen finden Sie unterFor more information, seeBekannte Typen in Datenverträgen. Data Contract Known Types. Im vorangegangenen Beispiel kann ein Objekt vom Typ Employee gesendet werden, wenn eine Person erwartet wird. Dies ist jedoch nur möglich, falls der Empfängercode KnownTypeAttribute verwendet, um es in die Liste der bekannten Typen aufzunehmen.In the previous example, an object of type Employee can be sent when a Person is expected, but only if the receiver code employs the KnownTypeAttribute to include it in the list of known types.

Beim Übergeben von Parametern und Rückgabewerten zwischen Anwendungen entspricht der erwartete Typ (sofern es sich dabei um eine Schnittstelle handelt) dem erwarteten Typ Object.When passing parameters and return values between applications, if the expected type is an interface, it is equivalent to the expected type being of type Object. Da jeder Typ letztlich von Object abgeleitet wird, wird jeder Datenvertrag letztlich vom Datenvertrag für Object abgeleitet.Because every type ultimately derives from Object, every data contract ultimately derives from the data contract for Object. So kann jeder Datenvertragstyp übergeben werden, wenn eine Schnittstelle erwartet wird.Thus, any data contract type can be passed when an interface is expected. Zusätzliche Schritte sind erforderlich, um erfolgreich arbeiten mit Schnittstellen; Weitere Informationen finden Sie unter Datenvertragstypen bezeichnet.Additional steps are required to successfully work with interfaces; for more information, see Data Contract Known Types.

Siehe auchSee Also

DataContractAttribute
DataMemberAttribute
DatenmemberreihenfolgeData Member Order
Bekannte Typen in DatenverträgenData Contract Known Types
DatenvertragsnamenData Contract Names