DatenvertragsnamenData Contract Names

Zuweilen verfügen Client und Dienst nicht über dieselben Typen.Sometimes a client and a service do not share the same types. Sie können jedoch Daten austauschen, wenn die Datenverträge auf beiden Seiten gleich sind.They can still pass data to each other as long as the data contracts are equivalent on both sides. Datenvertragsäquivalenz basiert auf Datenvertrag und Datenmembernamen und aus diesem Grund wird ein Mechanismus bereitgestellt, um die Typen und Member dieser Namen zuordnen.Data Contract Equivalence is based on data contract and data member names, and therefore a mechanism is provided to map types and members to those names. In diesem Thema erläutert die Regeln für die Benennung von Datenverträgen sowie das Standardverhalten der Windows Communication Foundation (WCF)-Infrastruktur, beim Erstellen von Namen.This topic explains the rules for naming data contracts as well as the default behavior of the Windows Communication Foundation (WCF) infrastructure when creating names.

GrundregelnBasic Rules

Zu den Grundregeln bei der Namensvergabe von Datenverträgen gehören:Basic rules regarding naming data contracts include:

  • Ein vollständig qualifizierter Datenvertragsname besteht aus einem Namespace und einem Namen.A fully-qualified data contract name consists of a namespace and a name.

  • Datenelemente verfügen nur über Namen, aber nicht über Namespaces.Data members have only names, but no namespaces.

  • Bei der Verarbeitung von Datenverträgen ist die WCF-Infrastruktur Groß-/Kleinschreibung beachtet, die Namespaces und die Namen der Datenverträge und Datenmember.When processing data contracts, the WCF infrastructure is case-sensitive to both the namespaces and the names of data contracts and data members.

DatenvertragsnamespacesData Contract Namespaces

Ein Datenvertragsnamespace nimmt die Form eines URI (Uniform Resource Identifiers) an.A data contract namespace takes the form of a Uniform Resource Identifier (URI). Der URI kann entweder absolut oder relativ sein.The URI can be either absolute or relative. Standardmäßig wird Datenverträgen eines bestimmten Typs ein Namespace zugeordnet, der aus dem Namespace der CLR (Common Language Runtime) desselben Typs resultiert.By default, data contracts for a particular type are assigned a namespace that comes from the common language runtime (CLR) namespace of that type.

Standardmäßig wird jeder beliebige CLR-Namespace (im Format Clr.Namespace) zugeordnet ist, auf den Namespace "http://schemas.datacontract.org/2004/07/Clr.Namespace".By default, any given CLR namespace (in the format Clr.Namespace) is mapped to the namespace "http://schemas.datacontract.org/2004/07/Clr.Namespace". Um diesen Standard zu überschreiben, übernehmen Sie das ContractNamespaceAttribute-Attribut für das ganze Modul oder die Assembly.To override this default, apply the ContractNamespaceAttribute attribute to the entire module or assembly. Alternativ können Sie den Datenvertragsnamespace für jeden Typ kontrollieren, indem Sie die Namespace-Eigenschaft des DataContractAttribute festlegen.Alternatively, to control the data contract namespace for each type, set the Namespace property of the DataContractAttribute.

Hinweis

Die "http://schemas.microsoft.com/2003/10/Serialization"Namespace ist reserviert und kann nicht als datenvertragsnamespace verwendet werden.The "http://schemas.microsoft.com/2003/10/Serialization"namespace is reserved and cannot be used as a data contract namespace.

Hinweis

Sie können den Standardnamespace nicht in Datenvertragstypen überschreiben, die delegate-Deklarationen enthalten.You cannot override the default namespace in data contract types that contain delegate declarations.

DatenvertragsnamenData Contract Names

Der Standardname eines Datenvertrags für einen gegebenen Typ ist der Name des Typs.The default name of a data contract for a given type is the name of that type. Um diesen Standard zu überschreiben, legen Sie die Name-Eigenschaft auf dem DataContractAttribute auf einen alternativen Namen fest.To override the default, set the Name property of the DataContractAttribute to an alternative name. Besondere Regeln für generische Typen werden weiter unten in diesem Thema unter "Datenvertragsnamen für generische Typen" beschrieben.Special rules for generic types are described in "Data Contract Names for Generic Types" later in this topic.

DatenelementnamenData Member Names

Der Standardname eines Datenelements für ein gegebenes Feld oder eine gegebene Eigenschaft ist der Name des Felds oder der Eigenschaft.The default name of a data member for a given field or property is the name of that field or property. Um diesen Standard zu überschreiben, legen Sie die Name-Eigenschaft des DataMemberAttribute auf einen alternativen Wert fest.To override the default, set the Name property of the DataMemberAttribute to an alternative value.

BeispieleExamples

Das folgende Beispiel zeigt, wie Sie das Standardbenennungsverhalten für Datenverträge und Datenelemente überschreiben können.The following example shows how you can override the default naming behavior of data contracts and data members.

// This overrides the standard namespace mapping for all contracts 
// in Contoso.CRM. 
[assembly: ContractNamespace("http://schemas.example.com/crm",
   ClrNamespace = "Contoso.CRM")]
namespace Contoso.CRM
{
    // The namespace is overridden to become: 
    // http://schemas.example.com/crm.
    // But the name is the default "Customer".
    [DataContract]
    public class Customer
    {
        // Code not shown.
    }
}
namespace Contoso.OrderProc
{
    [DataContract]
    public class PurchaseOrder
    {
        // This data member is named "Amount" by default.
        [DataMember]
        public double Amount;

        // The default is overridden to become "Address".
        [DataMember(Name = "Address")]
        public string Ship_to;
    }
    // The namespace is the default value:
    // http://schemas.datacontract.org/2004/07/Contoso.OrderProc
    // The name is "PurchaseOrder" instead of "MyInvoice".
    [DataContract(Name = "PurchaseOrder")]
    public class MyInvoice
    {
        // Code not shown.
    }

    // The contract name is "Payment" instead of "MyPayment" 
    // and the Namespace is "http://schemas.example.com" instead
    // of the default.
    [DataContract(Name = "Payment",
        Namespace = "http://schemas.example.com")]
    public class MyPayment
    {
        // Code not shown.
    }
}
' This overrides the standard namespace mapping for all contracts 
' in Contoso.CRM. 
<Assembly: ContractNamespace("http://schemas.example.com/crm", _
ClrNamespace:="Contoso.CRM")> 
Namespace Contoso.CRM
    ' The namespace is overridden to become: 
    ' http://schemas.example.com/crm.
    ' But the name is the default "Customer".
    <DataContract()> _
    Public Class Customer
        ' Code not shown.
    End Class
End Namespace

Namespace Contoso.OrderProc
    <DataContract()> _
    Public Class PurchaseOrder
        ' This data member is named "Amount" by default.
        <DataMember()> _
        Public Amount As Double

        ' The default is overridden to become "Address".
        <DataMember(Name:="Address")> _
        Public Ship_to As String
    End Class

    ' The namespace is the default value:
    ' http://schemas.datacontract.org/2004/07/Contoso.OrderProc
    ' The name is "PurchaseOrder" instead of "MyInvoice".
    <DataContract(Name:="PurchaseOrder")> _
    Public Class MyInvoice
        ' Code not shown.
    End Class

    ' The contract name is "Payment" instead of "MyPayment" 
    ' and the Namespace is "http://schemas.example.com" instead
    ' of the default.
    <DataContract(Name:="Payment", [Namespace]:="http://schemas.example.com")> _
    Public Class MyPayment
        ' Code not shown.
    End Class
End Namespace

Datenvertragsnamen für generische TypenData Contract Names for Generic Types

Für die Bestimmung von Datenvertragsnamen für generische Typen existieren besondere Regeln.Special rules exist for determining data contract names for generic types. Diese Regeln helfen, Übereinstimmungen von Datenvertragsnamen zwischen zwei geschlossenen Generika des gleichen generischen Typs zu vermeiden.These rules help avoid data contract name collisions between two closed generics of the same generic type.

Wird standardmäßig der Datenvertragsname für ein generischer Typ den Namen des Typs, gefolgt von der Zeichenfolge "Of" wird gefolgt von den Datenvertragsnamen der generischen Parameter, gefolgt von einem Hash mithilfe der datenvertragsnamespaces der berechnet der generische Parameter.By default, the data contract name for a generic type is the name of the type, followed by the string "Of", followed by the data contract names of the generic parameters, followed by a hash computed using the data contract namespaces of the generic parameters. Ein Hash ist das Ergebnis einer mathematischen Funktion, die als "Fingerabdruck" fungiert, der Daten eindeutig identifiziert.A hash is the result of a mathematical function that acts as a "fingerprint" that uniquely identifies a piece of data. Wenn es sich bei allen generischen Parametern um primitive Typen handelt, wird der Hash weggelassen.When all of the generic parameters are primitive types, the hash is omitted.

Betrachten Sie beispielsweise die Typen im folgenden Beispiel:For example, see the types in the following example.

[DataContract]
public class Drawing<Shape, Brush>
{
    // Code not shown.
}

[DataContract(Namespace = "urn:shapes")]
public class Square
{
    // Code not shown.
}

[DataContract(Name = "RedBrush", Namespace = "urn:default")]
public class RegularRedBrush
{
    // Code not shown.
}

[DataContract(Name = "RedBrush", Namespace = "urn:special")]
public class SpecialRedBrush
{
    // Code not shown.
}
<DataContract()> _
Public Class Drawing(Of Shape, Brush)

    <DataContract([Namespace]:="urn:shapes")> _
    Public Class Square
        ' Code not shown.
    End Class


    <DataContract(Name:="RedBrush", [Namespace]:="urn:default")> _
    Public Class RegularRedBrush
        ' Code not shown.
    End Class

    <DataContract(Name:="RedBrush", [Namespace]:="urn:special")> _
    Public Class SpecialRedBrush
        ' Code not shown.
    End Class
End Class

In diesem Beispiel hat der Typ Drawing<Square,RegularRedBrush> den Datenvertragsnamen "DrawingOfSquareRedBrush5HWGAU6h", wobei "5HWGAU6h" ein Hash der Namespaces "urn:shapes" und "urn:default" ist.In this example, the type Drawing<Square,RegularRedBrush> has the data contract name "DrawingOfSquareRedBrush5HWGAU6h", where "5HWGAU6h" is a hash of the "urn:shapes" and "urn:default" namespaces. Der Typ Drawing<Square,SpecialRedBrush> hat den Datenvertragsnamen "DrawingOfSquareRedBrushjpB5LgQ_S", wobei "jpB5LgQ_S" ein Hash der Namespaces "urn:shapes" und "urn:special" ist.The type Drawing<Square,SpecialRedBrush> has the data contract name "DrawingOfSquareRedBrushjpB5LgQ_S", where "jpB5LgQ_S" is a hash of the "urn:shapes" and the "urn:special" namespaces. Beachten Sie, dass die beiden Namen bei Nichtverwendung des Hashes identisch sind und daher ein Namenskonflikt auftritt.Note that if the hash is not used, the two names are identical, and thus a name collision occurs.

Anpassen von Datenvertragsnamen für generische TypenCustomizing Data Contract Names for Generic Types

Zuweilen sind die für generische Typen erstellten Datenvertragsnamen, wie zuvor beschrieben, nicht akzeptabel.Sometimes, the data contract names generated for generic types, as described previously, are unacceptable. Beispielsweise können Sie von vornherein wissen, dass eine Übereinstimmung der Namen ausgeschlossen ist, und möchten daher den Hash entfernen.For example, you may know in advance that you will not run into name collisions and may want to remove the hash. In diesem Fall können Sie die Name-Eigenschaft des DataContractAttribute-Attributs nutzen, um eine andere Art der Erstellung der Namen festzulegen.In this case, you can use the Name property of the DataContractAttribute attribute to specify a different way to generate names. Sie können Zahlen in geschweiften Klammern innerhalb der Name-Eigenschaft nutzen, um auf Datenvertragsnamen von generischen Parametern zu verweisen.You can use numbers in curly braces inside of the Name property to refer to data contract names of the generic parameters. (0 (null) verweist auf den ersten Parameter, 1 verweist auf den zweiten usw.) Um auf den Hash zu verweisen, können Sie ein Rautezeichen (#) in geschweiften Klammern verwenden.(0 refers to the first parameter, 1 refers to the second, and so on.) You can use a number (#) sign inside curly braces to refer to the hash. Sie können jeden dieser Verweise mehrmals oder gar nicht verwenden.You can use each of these references multiple times or not at all.

Beispielsweise könnte der vorangehende allgemeine Drawing-Typ deklariert worden sein, wie im folgenden Beispiel gezeigt:For example, the preceding generic Drawing type could have been declared as shown in the following example.

[DataContract(Name = "Drawing_using_{1}_brush_and_{0}_shape")]
public class Drawing<Shape, Brush>
{
    // Code not shown.
}
<DataContract(Name:="Drawing_using_{1}_brush_and_{0}_shape")> _
Public Class Drawing(Of Shape, Brush)
    ' Code not shown.
End Class

In diesem Fall hat der Typ Drawing<Square,RegularRedBrush> den Datenvertragsnamen "Drawing_using_RedBrush_brush_and_Square_shape".In this case, the type Drawing<Square,RegularRedBrush> has the data contract name "Drawing_using_RedBrush_brush_and_Square_shape". Beachten Sie, dass der Hash aufgrund des "{#}" in der Name-Eigenschaft nicht Teil des Namens ist und der Typ somit einer Benennungsübereinstimmung unterliegen kann. Beispielsweise hätte der Typ Drawing<Square,SpecialRedBrush> den gleichen Datenvertragsnamen.Note that because there is a "{#}" in the Name property, the hash is not a part of the name, and thus the type is susceptible to naming collisions; for example, the type Drawing<Square,SpecialRedBrush> would have exactly the same data contract name.

Siehe auchSee Also

DataContractAttribute
DataMemberAttribute
ContractNamespaceAttribute
Verwenden von DatenverträgenUsing Data Contracts
DatenvertragsäquivalenzData Contract Equivalence
DatenvertragsnamenData Contract Names
Datenvertrags-VersionsverwaltungData Contract Versioning