Sammlungstypen in DatenverträgenCollection Types in Data Contracts

Eine Sammlung ist eine Liste von Elementen eines bestimmten Typs.A collection is a list of items of a certain type. In .NET Framework.NET Frameworkkönnen solche Listen mithilfe von Arrays oder einer Vielzahl anderer Typen (generische Liste, generische BindingList<T>, StringCollectionoder ArrayList) dargestellt werden.In the .NET Framework.NET Framework, such lists can be represented using arrays or a variety of other types (Generic List, Generic BindingList<T>, StringCollection, or ArrayList). Eine Sammlung kann z. B. eine Liste von Adressen für einen bestimmten Kunden enthalten.For example, a collection may hold a list of Addresses for a given Customer. Solche Sammlungen werden – unabhängig von ihrem tatsächlichen Typ – als Listensammlungenbezeichnet.These collections are called list collections, regardless of their actual type.

Es gibt eine spezielle Sammlungsform, die eine Zuordnung zwischen einem Element (dem "Schlüssel") und einem anderen Element (dem "Wert") darstellt.A special form of collection exists that represents an association between one item (the "key") and another (the "value"). Im .NET Framework.NET Frameworkwerden diese Sammlungen durch Typen wie Hashtable und das generische Wörterbuch dargestellt.In the .NET Framework.NET Framework, these are represented by types such as Hashtable and the generic dictionary. Eine Zuordnungssammlung kann z. B. eine Stadt ("Schlüssel") der zugehörigen Bevölkerung ("Wert") zuordnen.For example, an association collection may map a city ("key") to its population ("value"). Solche Sammlungen werden – unabhängig von ihrem tatsächlichen Typ – als Wörterbuchsammlungenbezeichnet.These collections are called dictionary collections, regardless of their actual type.

Sammlungen werden im Datenvertragsmodell besonders behandelt.Collections receive special treatment in the data contract model.

Typen, die die IEnumerable -Schnittstelle einschließlich Arrays und generischen Sammlungen implementieren, werden als Sammlungen erkannt.Types that implement the IEnumerable interface, including arrays and generic collections, are recognized as collections. Davon sind die Typen, die die Schnittstellen für das IDictionary oder das generische IDictionary<TKey,TValue> implementieren, Wörterbuchsammlungen. Alle anderen sind Listensammlungen.Of those, types that implement the IDictionary or Generic IDictionary<TKey,TValue> interfaces are dictionary collections; all others are list collections.

Zusätzliche Anforderungen für Sammlungstypen, wie das Aufweisen einer Methode mit dem Namen Add und eines Standardkonstruktors, werden in den folgenden Abschnitten im Detail besprochen.Additional requirements on collection types, such as having a method called Add and a default constructor, are discussed in detail in the following sections. Dies stellt sicher, dass Sammlungstypen sowohl serialisiert als auch deserialisiert sein können.This ensures that collection types can be both serialized and deserialized. Das bedeutet, dass einige Sammlungen nicht direkt unterstützt werden, z. B. die generische ReadOnlyCollection<T> (da sie über keinen Standardkonstruktor verfügt).This means that some collections are not directly supported, such as the Generic ReadOnlyCollection<T> (because it has no default constructor). Informationen zum Umgehen dieser Einschränkungen finden Sie im Abschnitt "Verwenden von Sammlungsschnittstellentypen und schreibgeschützten Sammlungen" weiter unten in diesem Thema.However, for information about circumventing these restrictions, see the section "Using Collection Interface Types and Read-Only Collections" later in this topic.

Die in Sammlungen enthaltenen Typen müssen Datenvertragstypen oder anderweitig serialisierbar sein.The types contained in collections must be data contract types, or be otherwise serializable. Weitere Informationen finden Sie unterFor more information, seeVom Datenvertragsserialisierer unterstützte Typen. Types Supported by the Data Contract Serializer.

Weitere Informationen finden Sie unterFor more information about zu gültigen und ungültigen Sammlungen sowie Informationen zum Serialisieren von Sammlungen finden Sie in den Informationen zum Serialisieren von Sammlungen im Abschnitt "Erweiterte Sammlungsregeln" dieses Themas. what is and what is not considered a valid collection, as well as about how collections are serialized, see the information about serializing collections in the "Advanced Collection Rules" section of this topic.

Austauschbare SammlungenInterchangeable Collections

Bei allen Listensammlungen des gleichen Typs wird davon ausgegangen, dass sie den gleichen Datenvertrag haben (es sei denn, sie wurden mit dem CollectionDataContractAttribute -Attribut individuell angepasst, wie weiter unten in diesem Thema beschrieben).All list collections of the same type are considered to have the same data contract (unless they are customized using the CollectionDataContractAttribute attribute, as discussed later in this topic). Daher stimmen beispielsweise die folgenden Datenverträge überein:Thus, for example, the following data contracts are equivalent.

[DataContract(Name = "PurchaseOrder")]
public class PurchaseOrder1
{
    [DataMember]
    public string customerName;
    [DataMember]
    public Collection<Item> items;
    [DataMember]
    public string[] comments;
}

[DataContract(Name = "PurchaseOrder")]
public class PurchaseOrder2
{
    [DataMember]
    public string customerName;
    [DataMember]
    public List<Item> items;
    [DataMember]
    public BindingList<string> comments;
}
<DataContract(Name:="PurchaseOrder")> _
Public Class PurchaseOrder1

    <DataMember()> _
    Public customerName As String

    <DataMember()> _
    Public items As Collection(Of Item)

    <DataMember()> _
    Public comments() As String

End Class

<DataContract(Name:="PurchaseOrder")> _
Public Class PurchaseOrder2

    <DataMember()> _
    Public customerName As String

    <DataMember()> _
    Public items As List(Of Item)

    <DataMember()> _
    Public comments As BindingList(Of String)

End Class

Beide Datenverträge führen zu XML-Code, ähnlich dem folgenden Code:Both data contracts result in XML similar to the following code.

<PurchaseOrder>  
    <customerName>...</customerName>  
    <items>  
        <Item>...</Item>  
        <Item>...</Item>  
        <Item>...</Item>  
        ...  
    </items>  
    <comments>  
        <string>...</string>  
        <string>...</string>  
        <string>...</string>  
        ...  
    </comments>  
</PurchaseOrder>  

Die Austauschbarkeit von Sammlungen ermöglicht Ihnen beispielsweise die Verwendung eines für die Leistung auf dem Server optimierten Sammlungstyps sowie eines Sammlungstyps, der für die Bindung an Benutzerschnittstellenkomponenten auf dem Client entwickelt wurde.Collection interchangeability allows you to use, for example, a collection type optimized for performance on the server and a collection type designed to be bound to user interface components on the client.

Ähnlich wie bei den Listensammlungen haben alle Wörterbuchsammlungen, die die gleichen Schlüssel- und Werttypen aufweisen, den gleichen Datenvertrag (es sei denn, sie wurden mit dem CollectionDataContractAttribute -Attribut individuell angepasst).Similar to list collections, all dictionary collections that have the same key and value types are considered to have the same data contract (unless customized by the CollectionDataContractAttribute attribute).

Nur der Datenvertragstyp ist, was die Sammlungsäquivalenz betrifft, wichtig, nicht die .NET-Typen,Only the data contract type matters as far as collection equivalence is concerned, not .NET types. d. h. eine Sammlung vom Typ1 gilt als äquivalent zu einer Sammlung vom Typ2, wenn Typ1 und Typ2 die gleichen Datenverträge aufweisen.That is, a collection of Type1 is considered equivalent to a collection of Type2 if Type1 and Type2 have equivalent data contracts.

Bei nicht generischen Sammlungen wird davon ausgegangen, dass sie den gleichen Datenvertrag wie generische Sammlungen des Typs Objectaufweisen.Non-generic collections are considered to have the same data contract as generic collections of type Object. (Beispielsweise sind die Datenverträge für die ArrayList und die generische List<T> von Object gleich.)(For example, the data contracts for ArrayList and Generic List<T> of Object are the same.)

Verwenden von Sammlungsschnittstellentypen und schreibgeschützten SammlungenUsing Collection Interface Types and Read-Only Collections

Bei Sammlungsschnittstellentypen (IEnumerable, IDictionary, generische IDictionary<TKey,TValue>oder von diesen Schnittstellen abgeleiteten Schnittstellen) wird ebenfalls davon ausgegangen, dass sie die gleichen Sammlungsdatenverträge aufweisen wie die tatsächlichen Sammlungstypen.Collection interface types (IEnumerable, IDictionary, generic IDictionary<TKey,TValue>, or interfaces derived from these interfaces) are also considered as having collection data contracts, equivalent to collection data contracts for actual collection types. Daher ist es möglich, den serialisierten Typ als einen Sammlungsschnittstellentyp zu deklarieren. Die Ergebnisse sind die gleichen wie bei der Verwendung eines tatsächlichen Sammlungstyps.Thus, it is possible to declare the type being serialized as a collection interface type and the results are the same as if an actual collection type had been used. So stimmen beispielsweise die folgenden Datenverträge überein:For example, the following data contracts are equivalent.

[DataContract(Name="Customer")]
public class Customer1
{
    [DataMember]
    public string customerName;
    [DataMember]
    public Collection<Address> addresses;
}

[DataContract(Name="Customer")]
public class Customer2
{
    [DataMember]
    public string customerName;
    [DataMember]
    public ICollection<Address> addresses;
}
<DataContract(Name:="Customer")> _
Public Class Customer1

    <DataMember()> _
    Public customerName As String

    <DataMember()> _
    Public addresses As Collection(Of Address)

End Class

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

    <DataMember()> _
    Public customerName As String

    <DataMember()> _
    Public addresses As ICollection(Of Address)

End Class

Wenn der deklarierte Typ eine Schnittstelle ist, kann der derzeit verwendete Instanzentyp während der Serialisierung ein beliebiger Typ sein, der diese Schnittstelle implementiert.During serialization, when the declared type is an interface, the actual instance type used can be any type that implements that interface. Die oben erläuterten Einschränkungen (das Verfügen über einen Standardkonstruktor und eine Add-Methode) gelten nicht.Restrictions discussed previously (having a default constructor and an Add method) do not apply. Beispielsweise können Sie Adressen in Customer2 auf eine Instanz einer generischen ReadOnlyCollection<T> von "Adress" einstellen, auch wenn es Ihnen nicht möglich ist, einen Datenmember des Typs "Generische ReadOnlyCollection<T>" direkt zu deklarieren.For example, you can set addresses in Customer2 to an instance of Generic ReadOnlyCollection<T> of Address, even though you cannot directly declare a data member of type Generic ReadOnlyCollection<T>.

Wenn der deklarierte Typ eine Schnittstelle ist, wählt das Serialisierungsmodul während der Deserialisierung einen Typ, der die deklarierte Schnittstelle implementiert, und der Typ wird instanziiert.During deserialization, when the declared type is an interface, the serialization engine chooses a type that implements the declared interface, and the type is instantiated. Der Mechanismus der bekannten Typen (wie unter Data Contract Known Typesbeschrieben) ist hier nicht wirksam; die Typwahl ist in WCFWCF.The known types mechanism (described in Data Contract Known Types) has no effect here; the choice of type is built into WCFWCF.

Anpassen von SammlungstypenCustomizing Collection Types

Sie können Sammlungstypen anpassen, indem Sie das CollectionDataContractAttribute -Attribut verwenden, das auf verschiedene Weise genutzt werden kann.You can customize collection types by using the CollectionDataContractAttribute attribute, which has several uses.

Beachten Sie, dass das Anpassen von Sammlungstypen die Austauschbarkeit von Sammlungen beeinträchtigt. Daher wird empfohlen, das Anwenden dieses Attributs wenn möglich zu vermeiden.Note that customizing collection types compromises collection interchangeability, so it is generally recommended to avoid applying this attribute whenever possible. Weitere Informationen finden Sie unterFor more information about zu diesem Problem finden Sie weiter unten in diesem Thema im Abschnitt "Erweiterte Sammlungsregeln". this issue, see the "Advanced Collection Rules" section later in this topic.

Benennen von SammlungsdatenverträgenCollection Data Contract Naming

Die Regeln für das Benennen von Sammlungstypen ähneln den Regeln für das Benennen von Datenvertragstypen, wie unter Data Contract Namesbeschrieben. Es bestehen jedoch einige wichtige Unterschiede:The rules for naming collection types are similar to those for naming regular data contract types, as described in Data Contract Names, although some important differences exist:

  • Zum Anpassen des Namens wird das CollectionDataContractAttribute -Attribut verwendet und nicht das DataContractAttribute -Attribut.The CollectionDataContractAttribute attribute is used to customize the name, instead of the DataContractAttribute attribute. Das CollectionDataContractAttribute -Attribut weist außerdem Name - und Namespace -Eigenschaften auf.The CollectionDataContractAttribute attribute also has Name and Namespace properties.

  • Wenn das CollectionDataContractAttribute -Attribut nicht angewendet wird, hängen der Standardname und der Standardnamespace für Sammlungstypen von den Namen und Namespaces der Typen ab, die in der Sammlung enthalten sind.When the CollectionDataContractAttribute attribute is not applied, the default name and namespace for collection types depend on the names and namespaces of types contained within the collection. Sie werden nicht vom Namen und dem Namespace des Sammlungstyps selbst beeinflusst.They are not affected by the name and namespace of the collection type itself. Ein Beispiel finden Sie in den folgenden Typen:For an example, see the following types.

    public CustomerList1 : Collection<string> {}  
    public StringList1 : Collection<string> {}  
    

Die Datenvertragsnamen beider Typen lauten "ArrayOfstring" (und nicht "CustomerList1" oder "StringList1"),Both types’ data contract name is "ArrayOfstring" and not "CustomerList1" or "StringList1". d. h., dass sich durch die Serialisierung eines dieser Typen auf der Stammebene XML-Code ähnlich dem folgenden Code ergibt:This means that serializing any one of these types at the root level yields XML similar to the following code.

<ArrayOfstring>  
    <string>...</string>  
    <string>...</string>  
    <string>...</string>  
    ...  
</ArrayOfstring>  

Diese Benennungsregel wurde gewählt, um sicherzustellen, dass sämtliche nicht benutzerdefinierten Typen, die eine Liste von Zeichenfolgen darstellen, den gleichen Datenvertrag und die gleiche XML-Darstellung haben.This naming rule was chosen to ensure that any non-customized type that represents a list of strings has the same data contract and XML representation. Dies macht Sammlungsaustauschbarkeit möglich.This makes collection interchangeability possible. In diesem Beispiel sind "CustomerList1" und "StringList1" vollständig austauschbar.In this example, CustomerList1 and StringList1 are completely interchangeable.

Wenn jedoch das CollectionDataContractAttribute -Attribut angewendet wird, wird die Sammlung zu einem benutzerdefinierten Sammlungsdatenvertrag, auch wenn keine Eigenschaften für das Attribut festgelegt wurden.However, when the CollectionDataContractAttribute attribute is applied, the collection becomes a customized collection data contract, even if no properties are set on the attribute. Der Name und der Namespace des Sammlungsdatenvertrags hängen dann vom Sammlungstyp selbst ab.The name and namespace of the collection data contract then depend on the collection type itself. Ein Beispiel finden Sie im folgenden Typ:For an example, see the following type.

[CollectionDataContract] 
public class CustomerList2 : Collection<string> {}
<CollectionDataContract()> _
Public Class CustomerList2
    Inherits Collection(Of String)
End Class

Nach der Serialisierung ähneln die resultierenden XML-Daten Folgendem:When serialized, the resulting XML is similar to the following.

<CustomerList2>  
    <string>...</string>  
    <string>...</string>  
    <string>...</string>  
    ...  
</CustomerList2>  

Beachten Sie, dass dies nicht mehr der XML-Darstellung der nicht benutzerdefinierten Typen entspricht.Notice that this is no longer equivalent to the XML representation of the non-customized types.

  • Sie können die Name - und die Namespace -Eigenschaft verwenden, um die Benennung noch weiter anzupassen.You can use the Name and Namespace properties to further customize the naming. Siehe folgende Klasse.See the following class.

    [CollectionDataContract(Name="cust_list")]
    public class CustomerList3 : Collection<string> {}
    
    <CollectionDataContract(Name:="cust_list")> _
    Public Class CustomerList3
        Inherits Collection(Of String)
    End Class
    

Die resultierenden XML-Daten ähneln Folgendem:The resulting XML is similar to the following.

<cust_list>  
    <string>...</string>  
    <string>...</string>  
    <string>...</string>  
    ...  
</cust_list>  

Weitere Informationen finden Sie unterFor more information, see dem Abschnitt "Erweiterte Sammlungsregeln" weiter unten in diesem Thema. the "Advanced Collection Rules" section later in this topic.

Anpassen des sich wiederholenden Elementnamens in ListensammlungenCustomizing the Repeating Element Name in List Collections

Listensammlungen enthalten sich wiederholende Einträge.List collections contain repeating entries. In der Regel wird jeder sich wiederholende Eintrag als Element dargestellt, das gemäß dem Datenvertragsnamen des in der Sammlung enthaltenen Typs benannt ist.Normally, each repeating entry is represented as an element named according to the data contract name of the type contained in the collection.

In den CustomerList -Beispielen enthielten die Sammlungen Zeichenfolgen.In the CustomerList examples, the collections contained strings. Der Datenvertragsname des primitiven Zeichenfolgentyps ist "String", damit sich wiederholenden Elements wurde "<Zeichenfolge >".The data contract name for the string primitive type is "string", so the repeating element was "<string>".

Wenn jedoch die ItemName -Eigenschaft auf dem CollectionDataContractAttribute -Attribut verwendet wird, kann dieser sich wiederholende Elementname angepasst werden.However, using the ItemName property on the CollectionDataContractAttribute attribute, this repeating element name can be customized. Ein Beispiel finden Sie im folgenden Typ:For an example, see the following type.

[CollectionDataContract(ItemName="customer")]
public class CustomerList4 : Collection<string>  {}
<CollectionDataContract(ItemName:="customer")> _
Public Class CustomerList4
    Inherits Collection(Of String)
End Class

Die resultierenden XML-Daten ähneln Folgendem:The resulting XML is similar to the following.

<CustomerList4>  
    <customer>...</customer>  
    <customer>...</customer>  
    <customer>...</customer>  
    ...  
</CustomerList4>  

Der Namespace des sich wiederholenden Elements entspricht stets dem Namespace des Sammlungsdatenvertrags, der mithilfe der Namespace -Eigenschaft angepasst werden kann, wie zuvor beschrieben.The namespace of the repeating element is always the same as the namespace of the collection data contract, which can be customized using the Namespace property, as described previously.

Anpassen von WörterbuchsammlungenCustomizing Dictionary Collections

Wörterbuchsammlungen sind im Grunde Listen von Einträgen, bei denen jeder Eintrag über einen Schlüssel gefolgt von einem Wert verfügt.Dictionary collections are essentially lists of entries, where each entry has a key followed by a value. Genau wie bei normalen Listen können Sie den dem sich wiederholenden Element entsprechenden Elementnamen mit der ItemName -Eigenschaft ändern.Just as with regular lists, you can change the element name that corresponds to the repeating element by using the ItemName property.

Darüber hinaus können Sie die Elementnamen ändern, die für den Schlüssel und den Wert stehen, indem Sie die KeyName - und die ValueName -Eigenschaft verwenden.Additionally, you can change the element names that represent the key and the value by using the KeyName and ValueName properties. Die Namespaces für diese Elemente entsprechen dem Namespace des Sammlungsdatenvertrags.The namespaces for these elements are the same as the namespace of the collection data contract.

Ein Beispiel finden Sie im folgenden Typ:For an example, see the following type.

[CollectionDataContract
    (Name = "CountriesOrRegionsWithCapitals", 
    ItemName = "entry", 
    KeyName = "countryorregion", 
    ValueName = "capital")]
public class CountriesOrRegionsWithCapitals2 : Dictionary<string, string> { }
<CollectionDataContract(Name:="CountriesOrRegionsWithCapitals", _
                        ItemName:="entry", KeyName:="countryorregion", _
                        ValueName:="capital")> _
Public Class CountriesOrRegionsWithCapitals2
    Inherits Dictionary(Of String, String)
End Class

Nach der Serialisierung ähneln die resultierenden XML-Daten Folgendem:When serialized, the resulting XML is similar to the following.

<CountriesOrRegionsWithCapitals>  
    <entry>  
        <countryorregion>USA</countryorregion>  
        <capital>Washington</capital>  
    </entry>  
    <entry>  
        <countryorregion>France</countryorregion>  
        <capital>Paris</capital>  
    </entry>  
    ...  
</CountriesOrRegionsWithCapitals>  

Weitere Informationen finden Sie unterFor more information about zu Wörterbuchsammlungen finden Sie weiter unten in diesem Thema im Abschnitt "Erweiterte Sammlungsregeln". dictionary collections, see the "Advanced Collection Rules" section later in this topic.

Sammlungen und bekannte TypenCollections and Known Types

Sie müssen Sammlungstypen nicht bekannten Typen hinzufügen, wenn sie polymorph anstelle von anderen Sammlungen oder Sammlungsschnittstellen verwendet werden.You do not need to add collection types to known types when used polymorphically in place of other collections or collection interfaces. Wenn Sie beispielsweise einen Datenmember des Typs IEnumerable deklarieren und dazu verwenden, eine Instanz von ArrayListzu senden, müssen Sie ArrayList nicht bekannten Typen hinzufügen.For example, if you declare a data member of type IEnumerable and use it to send an instance of ArrayList, you do not need to add ArrayList to known types.

Wenn Sie anstelle von Typen polymorphe Sammlungen verwenden, bei denen es sich nicht um Sammlungstypen handelt, müssen sie bekannten Typen hinzugefügt werden.When you use collections polymorphically in place of non-collection types, they must be added to known types. Wenn Sie beispielsweise einen Datenmember des Typs Object deklarieren und dazu verwenden, eine Instanz von ArrayListzu senden, müssen Sie ArrayList bekannten Typen hinzufügen.For example, if you declare a data member of type Object and use it to send an instance of ArrayList, add ArrayList to known types.

Dies ermöglicht es Ihnen nicht, eine äquivalente Sammlung polymorph zu serialisieren.This does not allow you to serialize any equivalent collection polymorphically. Wenn Sie beispielsweise ArrayList der Liste bekannter Typen im vorherigen Beispiel hinzufügen, ist es Ihnen nicht möglich, die Array of Object -Klasse zuzuweisen, obwohl sie den gleichen Datenvertrag aufweist.For example, when you add ArrayList to the list of known types in the preceding example, this does not let you assign the Array of Object class, even though it has an equivalent data contract. Dieses Verhalten unterscheidet sich nicht vom regulären Verhalten bekannter Typen bei der Serialisierung für Typen, bei denen es sich nicht um Sammlungstypen handelt. Es ist jedoch besonders wichtig, sich im Falle von Sammlungen hierüber im Klaren zu sein, da Sammlungen sehr häufig äquivalent sind.This is no different from regular known types behavior on serialization for non-collection types, but it is especially important to understand in the case of collections because it is very common for collections to be equivalent.

Während der Serialisierung kann lediglich ein Typ in einem bestimmten Bereich für einen bestimmten Datenvertrag bekannt sein, und äquivalente Sammlungen besitzen alle die gleichen Datenverträge.During serialization, only one type can be known in any given scope for a given data contract, and equivalent collections all have the same data contracts. Das bedeutet, dass Sie im vorherigen Beispiel nicht beide Elemente ( ArrayList und Array of Object ) bekannten Typen im gleichen Bereich hinzufügen können.This means that, in the previous example, you cannot add both ArrayList and Array of Object to known types at the same scope. Dies entspricht erneut dem Verhalten bekannter Typen für Typen, bei denen es sich nicht um Sammlungstypen handelt. Es ist jedoch besonders wichtig, sich im Falle von Sammlungen hierüber im Klaren zu sein.Again, this is equivalent to known types behavior for non-collection types, but it is especially important to understand for collections.

Bekannte Typen sind möglicherweise auch für Inhalte von Sammlungen erforderlich.Known types may also be required for contents of collections. Wenn beispielsweise eine ArrayList wirklich Instanzen eines Type1 und eines Type2enthält, sollten beide Typen bekannten Typen hinzugefügt werden.For example, if an ArrayList actually contains instances of Type1 and Type2, both of these types should be added to known types.

Im folgenden Beispiel wird ein ordnungsgemäß erstelltes Objektdiagramm mit Sammlungen und bekannten Typen dargestellt.The following example shows a properly constructed object graph using collections and known types. (Das Beispiel ist frei erfunden, da Sie in einer echten Anwendung normalerweise die folgenden Datenmember nicht als Objectdefinieren und daher auch keine Probleme mit bekannten Typen/Polymorphie auftreten würden.)The example is somewhat contrived, because in an actual application you would normally not define the following data members as Object, and thus do not have any known type/polymorphism issues.

[DataContract]
public class Employee
{
    [DataMember]
    public string name = "John Doe";
    [DataMember]
    public Payroll payrollRecord;
    [DataMember]
    public Training trainingRecord;
}

[DataContract]
[KnownType(typeof(int[]))] //required because int[] is used polymorphically
[KnownType(typeof(ArrayList))] //required because ArrayList is used polymorphically
public class Payroll
{
    [DataMember]
    public object salaryPayments = new int[12];
    //float[] not needed in known types because polymorphic assignment is to another collection type
    [DataMember]
    public IEnumerable<float> stockAwards = new float[12];
    [DataMember]
    public object otherPayments = new ArrayList();
}

[DataContract]
[KnownType(typeof(List<object>))] 
//required because List<object> is used polymorphically
//does not conflict with ArrayList above because it's a different scope, 
//even though it's the same data contract
[KnownType(typeof(InHouseTraining))] //Required if InHouseTraining can be used in the collection
[KnownType(typeof(OutsideTraining))] //Required if OutsideTraining can be used in the collection
public class Training
{
    [DataMember]
    public object training = new List<object>();
}

[DataContract]
public class InHouseTraining
{
    //code omitted
}

[DataContract]
public class OutsideTraining
{
    //code omitted
}
<DataContract()> _
Public Class Employee

    <DataMember()> _
    Public name As String = "John Doe"

    <DataMember()> _
    Public payrollRecord As Payroll

    <DataMember()> _
    Public trainingRecord As Training

End Class

<DataContract(), KnownType(GetType(Integer())), KnownType(GetType(ArrayList))> _
Public Class Payroll

    <DataMember()> _
    Public salaryPayments As Object = New Integer(11) {}

    'float[] not needed in known types because polymorphic assignment is to another collection type
    <DataMember()> _
    Public stockAwards As IEnumerable(Of Single) = New Single(11) {}

    <DataMember()> _
    Public otherPayments As Object = New ArrayList()

End Class

'required because List<object> is used polymorphically
'does not conflict with ArrayList above because it's a different scope, 
'even though it's the same data contract
<DataContract(), KnownType(GetType(List(Of Object))), _
                 KnownType(GetType(InHouseTraining)), _
                 KnownType(GetType(OutsideTraining))> _
Public Class Training
    <DataMember()> _
    Public training As Object = New List(Of Object)()
End Class

<DataContract()> _
Public Class InHouseTraining
    'code omitted�
End Class

<DataContract()> _
Public Class OutsideTraining
    'code omitted�
End Class

Wenn der deklarierte Typ ein Sammlungstyp ist, wird der deklarierte Typ bei der Deserialisierung instanziiert, unabhängig vom Typ, der tatsächlich gesendet wurde.On deserialization, if the declared type is a collection type, the declared type is instantiated regardless of the type that was actually sent. Wenn der deklarierte Typ eine Sammlungsschnittstelle ist, wählt das Deserialisierungsprogramm einen zu instanziierenden Typ aus, unabhängig von bekannten Typen.If the declared type is a collection interface, the deserializer picks a type to be instantiated with no regard to known types.

Wenn der deklarierte Typ bei der Deserialisierung kein Sammlungstyp ist, jedoch ein Sammlungstyp gesendet wird, wird ein entsprechender Sammlungstyp aus der Liste der bekannten Typen ausgewählt.Also on deserialization, if the declared type is not a collection type but a collection type is being sent, a matching collection type is picked out of the known types list. Es ist möglich, bei der Deserialisierung der Liste bekannter Typen Sammlungsschnittstellentypen hinzuzufügen.It is possible to add collection interface types to the list of known types on deserialization. In diesem Fall wählt das Deserialisierungsmodul erneut einen Typ aus, der instanziiert werden soll.In this case, the deserialization engine again picks a type to be instantiated.

Sammlungen und die NetDataContractSerializer-KlasseCollections and the NetDataContractSerializer Class

Wenn die NetDataContractSerializer -Klasse verwendet wird, verlieren nicht benutzerdefinierte Sammlungstypen (ohne das CollectionDataContractAttribute -Attribut), bei denen es sich nicht um Arrays handelt, ihre spezielle Bedeutung.When the NetDataContractSerializer class is in use, non-customized collection types (without the CollectionDataContractAttribute attribute) that are not arrays lose their special meaning.

Nicht benutzerdefinierte Sammlungstypen, die mit dem SerializableAttribute -Attribut gekennzeichnet sind, können dennoch von der NetDataContractSerializer -Klasse gemäß den Regeln für das SerializableAttribute -Attribut oder die ISerializable -Schnittstelle serialisiert werden.Non-customized collection types marked with the SerializableAttribute attribute can still be serialized by the NetDataContractSerializer class according to the SerializableAttribute attribute or the ISerializable interface rules.

Benutzerdefinierte Sammlungstypen, Sammlungsschnittstellen und Arrays werden weiterhin als Sammlungen behandelt, selbst wenn die NetDataContractSerializer -Klasse verwendet wird.Customized collection types, collection interfaces, and arrays are still treated as collections, even when the NetDataContractSerializer class is in use.

Sammlungen und SchemaCollections and Schema

Alle äquivalenten Sammlungen verfügen über die gleiche Darstellung im XSD-Schema (XML Schema Definition Language).All equivalent collections have the same representation in XML Schema definition language (XSD) schema. Daher erhalten Sie im generierten Clientcode normalerweise nicht den gleichen Sammlungstyp wie auf dem Server.Because of this, you normally do not get the same collection type in the generated client code as the one on the server. Beispielsweise kann der Server einen Datenvertrag mit einer generischen List<T> für den Datenmember "Integer" verwenden, im generierten Clientcode kann der gleiche Datenmember jedoch ein Array von ganzen Zahlen werden.For example, the server may use a data contract with a Generic List<T> of Integer data member, but in the generated client code the same data member may become an array of integers.

Wörterbuchsammlungen sind mit einer WCFWCF-spezifischen Schemaanmerkung gekennzeichnet, die die Sammlungen als Wörterbücher ausweist; andernfalls könnte man sie von Listen, die Einträge mit einem Schlüssel und einem Wert enthalten, nicht unterscheiden.Dictionary collections are marked with a WCFWCF-specific schema annotation that indicate that they are dictionaries; otherwise, they are indistinguishable from simple lists that contain entries with a key and a value. Eine genaue Beschreibung, wie Sammlungen in einem Datenvertragsschema dargestellt werden, finden Sie unter Data Contract Schema Reference.For an exact description of how collections are represented in data contract schema, see Data Contract Schema Reference.

Standardmäßig werden Typen nicht für nicht benutzerdefinierte Sammlungen in importiertem Code generiert.By default, types are not generated for non-customized collections in imported code. Datenmember von Listensammlungstypen werden als Arrays importiert, und Datenmember von Wörterbuchsammlungstypen werden als generisches Wörterbuch importiert.Data members of list collection types are imported as arrays, and data members of dictionary collection types are imported as Generic Dictionary.

Für benutzerdefinierte Sammlungen werden jedoch separate Typen generiert, die mit dem CollectionDataContractAttribute -Attribut gekennzeichnet sind.However, for customized collections, separate types are generated, marked with the CollectionDataContractAttribute attribute. (Ein benutzerdefinierter Sammlungstyp im Schema ist ein Typ, der keinen standardmäßigen Namespace und keine standardmäßigen Namen, sich wiederholende Elementnamen oder Namen für Schlüssel-/Wertelemente verwendet.) Bei diesen Typen handelt es sich um leere Typen, die von der generischen List<T> für Listentypen und vom generischen Wörterbuch für Wörterbuchtypen abgeleitet werden.(A customized collection type in the schema is one that does not use the default namespace, name, repeating element name, or key/value element names.) These types are empty types that derive from Generic List<T> for list types and Generic Dictionary for dictionary types.

Es können z. B. folgende Typen auf dem Server vorliegen:For example, you may have the following types on the server.

[DataContract]
public class CountryOrRegion
{
    [DataMember]
    public Collection<string> officialLanguages;
    [DataMember]
    public List<DateTime> holidays;
    [DataMember]
    public CityList cities;
    [DataMember]
    public ArrayList otherInfo;
}

public class Person
{
    public Person(string fName, string lName)
    {
        this.firstName = fName;
        this.lastName = lName;
    }

    public string firstName;
    public string lastName;
}

public class PeopleEnum : IEnumerator
{
    public Person[] _people;

    // Enumerators are positioned before the first element
    // until the first MoveNext() call.
    int position = -1;

    public PeopleEnum(Person[] list)
    {
        _people = list;
    }

    public bool MoveNext()
    {
        position++;
        return (position < _people.Length);
    }

    public void Reset()
    {
        position = -1;
    }

    public object Current
    {
        get
        {
            try
            {
                return _people[position];
            }
            catch (IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }
}

[CollectionDataContract(Name = "Cities", ItemName = "city", KeyName = "cityName", ValueName = "population")]
public class CityList : IDictionary<string, int>, IEnumerable<System.Collections.Generic.KeyValuePair<string, int>>
{
    private Person[] _people = null;

    public bool ContainsKey(string s) { return true; }
    public bool Contains(string s) { return true; }
    public bool Contains(KeyValuePair<string, int> item) { return (true); }
    public void Add(string key, int value) { }
    public void Add(KeyValuePair<string, int> keykValue) { }
    public bool Remove(string s) { return true; }
    public bool TryGetValue(string d, out int i)
    {
        i = 0; return (true);
    }

    /*
    [TypeConverterAttribute(typeof(SynchronizationHandlesTypeConverter))]
    public ICollection<string> SynchronizationHandles {
        get { return (System.Collections.Generic.ICollection<string>) new Stack<string> (); }
        set { }
    }*/

    public ICollection<string> Keys
    {
        get
        {
            return (System.Collections.Generic.ICollection<string>)new Stack<string>();
        }
    }

    public int this[string s]
    {
        get
        {
            return 0;
        }
        set
        {
        }
    }

    public ICollection<int> Values
    {
        get
        {
            return (System.Collections.Generic.ICollection<int>)new Stack<string>();
        }
    }

    public void Clear() { }
    public void CopyTo(KeyValuePair<string, int>[] array, int index) { }
    public bool Remove(KeyValuePair<string, int> item) { return true; }
    public int Count { get { return 0; } }
    public bool IsReadOnly { get { return true; } }

    IEnumerator<KeyValuePair<string, int>>
        System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, int>>.GetEnumerator()
    {
        return (IEnumerator<KeyValuePair<string, int>>)new PeopleEnum(_people); ;
    }

    public IEnumerator GetEnumerator()
    {
        return new PeopleEnum(_people);
    }
}

<DataContract()> _
Public Class CountryOrRegion

    <DataMember()> _
    Public officialLanguages As Collection(Of String)

    <DataMember()> _
    Public holidays As List(Of DateTime)

    <DataMember()> _
    Public cities As CityList

    <DataMember()> _
    Public otherInfo As ArrayList

End Class

Public Class Person
    Public Sub New(ByVal fName As String, ByVal lName As String) 
        Me.firstName = fName
        Me.lastName = lName
    End Sub

    Public firstName As String
    Public lastName As String
End Class

Public Class PeopleEnum
    Implements IEnumerator

    Public _people() As Person
    ' Enumerators are positioned before the first element
    ' until the first MoveNext() call.
    Private position As Integer = -1

    Public Sub New(ByVal list() As Person)
        _people = list
    End Sub

    Public Function MoveNext() As Boolean Implements IEnumerator.MoveNext
        position += 1
        Return position < _people.Length
    End Function

    Public Sub Reset() Implements IEnumerator.Reset
        position = -1
    End Sub

    Public ReadOnly Property Current() As Object Implements IEnumerator.Current
        Get
            Try
                Return _people(position)
            Catch e1 As IndexOutOfRangeException
                Throw New InvalidOperationException()
            End Try
        End Get
    End Property
End Class

<CollectionDataContract(Name:="Cities", _
                        ItemName:="city", _
                        KeyName:="cityName", _
                        ValueName:="population")> _
Public Class CityList
    Implements IDictionary(Of String, Integer), IEnumerable(Of System.Collections.Generic.KeyValuePair(Of String, Integer))

    Private _people() As Person = Nothing

    Public Function ContainsKey(ByVal s As String) As Boolean Implements IDictionary(Of String, Integer).ContainsKey
        Return True
    End Function

    Public Function Contains(ByVal s As String) As Boolean
        Return True
    End Function

    Public Function Contains(ByVal item As KeyValuePair(Of String, Integer)) As Boolean Implements IDictionary(Of String, Integer).Contains
        Return (True)
    End Function

    Public Sub Add(ByVal key As String, _
                   ByVal value As Integer) Implements IDictionary(Of String, Integer).Add
    End Sub

    Public Sub Add(ByVal keykValue As KeyValuePair(Of String, Integer)) Implements IDictionary(Of String, Integer).Add
    End Sub

    Public Function Remove(ByVal s As String) As Boolean Implements IDictionary(Of String, Integer).Remove
        Return True
    End Function

    Public Function TryGetValue(ByVal d As String, _
                                <System.Runtime.InteropServices.Out()> ByRef i As Integer) _
                                As Boolean Implements IDictionary(Of String, Integer).TryGetValue
        i = 0
        Return (True)
    End Function

    Public ReadOnly Property Keys() As ICollection(Of String) Implements IDictionary(Of String, Integer).Keys
        Get
            Return CType(New Stack(Of String)(), System.Collections.Generic.ICollection(Of String))
        End Get
    End Property

    Default Public Property Item(ByVal s As String) As Integer Implements IDictionary(Of String, Integer).Item
        Get
            Return 0
        End Get
        Set(ByVal value As Integer)
        End Set
    End Property

    Public ReadOnly Property Values() As ICollection(Of Integer) Implements IDictionary(Of String, Integer).Values
        Get
            Return CType(New Stack(Of String)(), System.Collections.Generic.ICollection(Of Integer))
        End Get
    End Property

    Public Sub Clear() Implements IDictionary(Of String, Integer).Clear
    End Sub

    Public Sub CopyTo(ByVal array() As KeyValuePair(Of String, Integer), _
                      ByVal index As Integer) Implements IDictionary(Of String, Integer).CopyTo
    End Sub

    Public Function Remove(ByVal item As KeyValuePair(Of String, Integer)) As Boolean Implements IDictionary(Of String, Integer).Remove
        Return True
    End Function

    Public ReadOnly Property Count() As Integer Implements IDictionary(Of String, Integer).Count
        Get
            Return 0
        End Get
    End Property

    Public ReadOnly Property IsReadOnly() As Boolean Implements IDictionary(Of String, Integer).IsReadOnly
        Get
            Return True
        End Get
    End Property

    Private Function IEnumerable_GetEnumerator() As IEnumerator(Of KeyValuePair(Of String, Integer)) _
        Implements System.Collections.Generic.IEnumerable(Of System.Collections.Generic.KeyValuePair(Of String, Integer)).GetEnumerator

        Return CType(New PeopleEnum(_people), IEnumerator(Of KeyValuePair(Of String, Integer)))
    End Function

    Public Function GetEnumerator() As IEnumerator Implements System.Collections.IEnumerable.GetEnumerator

        Return New PeopleEnum(_people)

    End Function

End Class

Wenn das Schema exportiert und anschließend wieder importiert wird, ähnelt der generierte Clientcode dem folgenden Code (statt Eigenschaften werden zur Erleichterung des Lesens Felder angezeigt).When the schema is exported and imported back again, the generated client code is similar to the following (fields are shown instead of properties for ease of reading).

[DataContract]
public class CountryOrRegion2
{
    [DataMember]
    public string[] officialLanguages;
    [DataMember]
    public DateTime[] holidays;
    [DataMember]
    public Cities cities;
    [DataMember]
    public object[] otherInfo;
}

[CollectionDataContract(ItemName = "city", KeyName = "cityName", ValueName = "population")]
public class Cities : Dictionary<string, int> { }
<DataContract()> _
Public Class CountryOrRegion2
    <DataMember()> _
    Public officialLanguages() As String
    <DataMember()> _
    Public holidays() As DateTime
    <DataMember()> _
    Public cities As Cities
    <DataMember()> _
    Public otherInfo() As Object
End Class

<CollectionDataContract(ItemName:="city", KeyName:="cityName", ValueName:="population")> _
Public Class Cities
    Inherits Dictionary(Of String, Integer)
End Class

Möglicherweise möchten Sie andere Typen als die Standardtypen in generiertem Code verwenden.You may want to use different types in generated code than the default ones. Es könnte z. B. sein, dass Sie die generische BindingList<T> statt regulärer Arrays für Ihre Datenmember verwenden möchten, um sie leichter an Benutzerschnittstellenkomponenten binden zu können.For example, you may want to use Generic BindingList<T> instead of regular arrays for your data members to make it easier to bind them to user interface components.

Übergeben Sie zum Auswählen der zu generierenden Sammlungstypen eine Liste der Sammlungstypen, die Sie verwenden möchten, in die ReferencedCollectionTypes -Eigenschaft des ImportOptions -Objekts, wenn Sie das Schema importieren.To choose collection types to generate, pass a list of collection types you want to use into the ReferencedCollectionTypes property of the ImportOptions object when importing schema. Diese Typen werden als referenzierte Sammlungstypenbezeichnet.These types are called referenced collection types.

Wenn auf generische Typen verwiesen wird, müssen sie entweder vollständig offene oder vollständig geschlossene Generika sein.When generic types are being referenced, they must either be fully-open generics or fully-closed generics.

Hinweis

Wenn Sie das Tool „Svcutil.exe“ verwenden, kann dieser Verweis über den /collectionType -Befehlszeilenschalter (Kurzform: /ct) erreicht werden.When using the Svcutil.exe tool, this reference can be accomplished by using the /collectionType command-line switch (short form: /ct). Denken Sie daran, dass Sie auch die Assembly für die referenzierten Sammlungstypen über den /reference -Schalter (Kurzform: /r) angeben müssen.Keep in mind that you must also specify the assembly for the referenced collection types using the /reference switch (short form: /r). Bei generischen Typen folgt auf den Namen des Typs ein Graviszeichen und die Anzahl der generischen Parameter.If the type is generic, it must be followed by a back quote and the number of generic parameters. Verwechseln Sie das Graviszeichen (`) nicht mit dem einfachen Anführungszeichen (‘).The back quote (`) is not to be confused with the single quote (‘) character. Sie können mehrere referenzierte Sammlungstypen angeben, indem Sie den /collectionType -Schalter mehrmals verwenden.You can specify multiple referenced collection types by using the /collectionType switch more than once.

Beispielsweise, um zu bewirken, dass alle Listen als generische List<T>importiert werden.For example, to cause all lists to be imported as Generic List<T>.

svcutil.exe MyService.wsdl MyServiceSchema.xsd /r:C:\full_path_to_system_dll\System.dll /ct:System.Collections.Generic.List`1  

Beim Importieren einer beliebigen Sammlung wird die Liste der referenzierten Sammlungstypen gescannt, und die am besten passende Sammlung wird verwendet (sofern vorhanden) – entweder als Datenmembertyp (für nicht benutzerdefinierte Sammlungen) oder als Basistyp, von dem abgeleitet wird (für benutzerdefinierte Sammlungen).When importing any collection, this list of referenced collection types is scanned, and the best-matching collection is used if one is found, either as a data member type (for non-customized collections) or as a base type to derive from (for customized collections). Wörterbücher werden nur Wörterbüchern gegenübergestellt, während Listen Listen gegenübergestellt werden.Dictionaries are only matched against dictionaries, while lists are matched against lists.

Wenn Sie beispielsweise die generische BindingList<T> und Hashtable der Liste referenzierter Typen hinzufügen, ähnelt der generierte Clientcode für das vorangegangene Beispiel dem folgenden.For example, if you add the Generic BindingList<T> and Hashtable to the list of referenced types, the generated client code for the preceding example is similar to the following.

[DataContract]
public class CountryOrRegion3
{
    [DataMember]
    public BindingList<string> officialLanguages;
    [DataMember]
    public BindingList<DateTime> holidays;
    [DataMember]
    public Cities cities;
    [DataMember]
    public BindingList<object> otherInfo;
}

[CollectionDataContract(ItemName = "city", KeyName = "cityName", ValueName = "population")]
public class Cities3 : Hashtable { }
<DataContract()> _
Public Class CountryOrRegion3

    <DataMember()> _
    Public officialLanguages As BindingList(Of String)

    <DataMember()> _
    Public holidays As BindingList(Of DateTime)

    <DataMember()> _
    Public cities As Cities

    <DataMember()> _
    Public otherInfo As BindingList(Of Object)

End Class

<CollectionDataContract(ItemName:="city", _
                        KeyName:="cityName", _
                        ValueName:="population")> _
Public Class Cities3
    Inherits Hashtable
End Class

Sie können Sammlungsschnittstellentypen als Teil Ihrer referenzierten Sammlungstypen angeben, jedoch können Sie keine ungültigen Sammlungstypen angeben (wie diejenigen ohne Add -Methode oder öffentlichen Konstruktor).You can specify collection interface types as part of your referenced collection types, but you cannot specify invalid collection types (such as ones with no Add method or public constructor).

Ein geschlossener generischer Typ wird als beste Übereinstimmung betrachtet.A closed generic is considered to be the best match. (Nicht generische Typen werden als äquivalent zu geschlossenen Generika von Objectbetrachtet).(Non-generic types are considered equivalent to closed generics of Object). Wenn beispielsweise die Typen "Generische List<T> von DateTime", "Generische BindingList<T> " (offener generischer Typ) und " ArrayList " die referenzierten Sammlungstypen sind, wird Folgendes generiert:For example, if the types Generic List<T> of DateTime, Generic BindingList<T> (open generic), and ArrayList are the referenced collection types, the following is generated.

[DataContract]
public class CountryOrRegion4
{
    [DataMember]
    public string[] officialLanguages;
    [DataMember]
    public DateTime[] holidays;
    [DataMember]
    public Cities cities;
    [DataMember]
    public object[] otherInfo;
}

[CollectionDataContract(ItemName = "city", KeyName = "cityName", ValueName = "population")]
public class Cities4 : Dictionary<string, int> { }
<DataContract()> _
Public Class CountryOrRegion4

    <DataMember()> _
    Public officialLanguages() As String

    <DataMember()> _
    Public holidays() As DateTime

    <DataMember()> _
    Public cities As Cities

    <DataMember()> _
    Public otherInfo() As Object

End Class

<CollectionDataContract(ItemName:="city", _
                        KeyName:="cityName", _
                        ValueName:="population")> _
Public Class Cities4
    Inherits Dictionary(Of String, Integer)
End Class

Für Listensammlungen werden nur die Fälle aus der folgenden Tabelle unterstützt:For list collections, only the cases in the following table are supported.

Referenzierter TypReferenced type Vom referenzierten Typ implementierte SchnittstelleInterface implemented by referenced type BeispielExample Typ behandelt als:Type treated as:
Nicht generisch oder geschlossen generisch (beliebige Anzahl von Parametern)Non-generic or closed generic (any number of parameters) Nicht generischNon-generic MyType : IList

oderor

MyType<T> : IList

, wobei T= intwhere T= int
Geschlossen generisch von Object (z. B. IList<object>)Closed generic of Object (for example, IList<object>)
Nicht generisch oder geschlossen generisch (beliebige Anzahl von Parametern, die nicht notwendigerweise mit dem Sammlungstyp übereinstimmen)Non-generic or closed generic (any number of parameters that do not necessarily match the collection type) Geschlossen generischClosed generic MyType : IList<string>

oderor

MyType<T> : IList<string> , wobei T=intMyType<T> : IList<string> where T=int
Geschlossen generisch (z. B. IList<string>)Closed generic (for example, IList<string>)
Geschlossen generisch mit einer beliebigen Anzahl an ParameternClosed generic with any number of parameters Offen generisch mit einem beliebigen Parameter des TypsOpen generic using any one of the type’s parameters MyType<T,U,V> : IList<U>

, wobei T=int, U=string, V=boolwhere T=int, U=string, V=bool
Geschlossen generisch (z. B. IList<string>)Closed generic (for example, IList<string>)
Offen generisch mit einem ParameterOpen generic with one parameter Offen generisch mit dem Parameter des TypsOpen generic using the type’s parameter MyType<T> : IList<T>, T ist offenMyType<T> : IList<T>, T is open Offen generisch (z. B. IList<T>)Open generic (for example, IList<T>)

Wenn ein Typ mehr als eine Listensammlungsschnittstelle implementiert, gelten die folgenden Einschränkungen:If a type implements more than one list collection interface, the following restrictions apply:

  • Wenn der Typ das generische IEnumerable<T> (oder die davon abgeleiteten Schnittstellen) mehrfach für verschiedene Typen implementiert, gilt der Typ nicht als gültiger referenzierter Sammlungstyp und wird ignoriert.If the type implements Generic IEnumerable<T> (or its derived interfaces) multiple times for different types, the type is not considered a valid referenced collection type and is ignored. Dies gilt auch, wenn einige Implementierungen ungültig sind oder offene Generika verwenden.This is true even if some implementations are invalid or use open generics. Beispielsweise würde ein Typ, der das generische IEnumerable<T> von int und das generische IEnumerable<T> von T implementiert, niemals als referenzierte Sammlung von int oder eines anderen Typs verwendet werden, unabhängig davon, ob der Typ eine Add -Methode, die int akezptiert, oder eine Add -Methode, die einen Parameter vom Typ T akzeptiert, oder beides aufweist.For example, a type that implements Generic IEnumerable<T> of int and Generic IEnumerable<T> of T would never be used as a referenced collection of int or any other type, regardless of whether the type has an Add method accepting int or an Add method accepting a parameter of type T, or both.

  • Wenn der Typ eine generische Sammlungsschnittstelle sowie IListimplementiert, wird er niemals als referenzierter Sammlungstyp verwendet, es sei denn, die generische Sammlungsschnittstelle ist ein geschlossener generischer Typ vom Typ Object.If the type implements a generic collection interface as well as IList, the type is never used as a referenced collection type unless the generic collection interface is a closed generic of type Object.

Für Wörterbuchsammlungen werden nur die Fälle aus der folgenden Tabelle unterstützt:For dictionary collections, only the cases in the following table are supported.

Referenzierter TypReferenced type Vom referenzierten Typ implementierte SchnittstelleInterface implemented by referenced type BeispielExample Typ behandelt alsType treated as
Nicht generisch oder geschlossen generisch (beliebige Anzahl von Parametern)Non-generic or closed generic (any number of parameters) IDictionary MyType : IDictionary

oderor

MyType<T> : IDictionary , wobei T=intMyType<T> : IDictionary where T=int
Geschlossenes generisches IDictionary<object,object>Closed generic IDictionary<object,object>
Geschlossen generisch (beliebigen Anzahl an Parametern)Closed generic (any number of parameters) IDictionary<TKey,TValue>, geschlossenIDictionary<TKey,TValue>, closed MyType<T> : IDictionary<string, bool>wobei T =intMyType<T> : IDictionary<string, bool> where T=int Geschlossen generisch (z. B. IDIctionary<string,bool>)Closed generic (for example, IDIctionary<string,bool>)
Geschlossen generisch (beliebigen Anzahl an Parametern)Closed generic (any number of parameters) Generisches IDictionary<TKey,TValue>, entweder der Schlüssel oder der Wert ist geschlossen, das andere Element ist offen und verwendet einen Parameter des TypsGeneric IDictionary<TKey,TValue>, one of either key or value is closed, the other is open and uses one of type’s parameters MyType<T,U,V> : IDictionary<string,V>wobei T =int, U =float, V =boolMyType<T,U,V> : IDictionary<string,V> where T=int, U=float,V=bool

oderor

MyType<Z> : IDictionary<Z,bool>wobei Z =stringMyType<Z> : IDictionary<Z,bool> where Z=string
Geschlossen generisch (z. B. IDictionary<string,bool>)Closed generic (For example, IDictionary<string,bool>)
Geschlossen generisch (beliebigen Anzahl an Parametern)Closed generic (any number of parameters) Generisches IDictionary<TKey,TValue>, sowohl Schlüssel als auch Wert sind geöffnet und verwenden beide jeweils einen Parameter des TypsGeneric IDictionary<TKey,TValue>, both key and value are open and each uses one of the type’s parameters MyType<T,U,V> : IDictionary<V,U>, wobei T=int, U=bool, V=stringMyType<T,U,V> : IDictionary<V,U> where T=int, U=bool, V=string Geschlossen generisch (z. B. IDictionary<string,bool>)Closed generic (for example, IDictionary<string,bool>)
Offen generisch (zwei Parameter)Open generic (two parameters) Generisches IDictionary<TKey,TValue>, offen, verwendet beide generischen Parametern des Typs in der Reihenfolge, in der sie angezeigt werden.Generic IDictionary<TKey,TValue>, open, uses both of the type’s generic parameters in the order they appear MyType<K,V> : IDictionary<K,V>, K und V beide offenMyType<K,V> : IDictionary<K,V>, K and V both open Offen generisch (z. B. IDictionary<K,V>)Open generic (for example, IDictionary<K,V>)

Wenn der Typ sowohl das IDictionary als auch das generische IDictionary<TKey,TValue>implementiert, wird nur das generische IDictionary<TKey,TValue> betrachtet.If the type implements both IDictionary and Generic IDictionary<TKey,TValue>, only Generic IDictionary<TKey,TValue> is considered.

Das Verweisen auf teilweise generische Typen wird nicht unterstützt.Referencing partial generic types is not supported.

Duplikate sind nicht zulässig. Beispielsweise können Sie nicht sowohl die generische List<T> von Integer als auch die generische Sammlung von Integer ReferencedCollectionTypeshinzufügen, da anschließend nicht mehr festgestellt werden kann, was verwendet werden soll, wenn eine Liste mit ganzen Zahlen im Schema auftritt.Duplicates are not allowed, for example, you cannot add both the Generic List<T> of Integer and the Generic Collection of Integer to ReferencedCollectionTypes, because this makes it impossible to determine which one to use when a list of integers is found in the schema. Duplikate werden nur erkannt, wenn es einen Typ im Schema gibt, der das Duplikatproblem offenlegt.Duplicates are detected only if there is a type in the schema that exposes the duplicates problem. Wenn z. B. das importierte Schema keine Liste mit ganzen Zahlen enthält, kann es sowohl über die generische List<T> von Integer als auch über die generische Sammlung von Integer in den ReferencedCollectionTypesverfügen, doch nichts davon zeigt eine Wirkung.For example, if the schema being imported does not contain lists of integers, it is allowed to have both the Generic List<T> of Integer and the Generic Collection of Integer in the ReferencedCollectionTypes, but neither has any effect.

Erweiterte SammlungsregelnAdvanced Collection Rules

Serialisieren von SammlungenSerializing Collections

Im Folgenden finden Sie eine Liste mit Sammlungsregeln für die Serialisierung:The following is a list of collection rules for serialization:

  • Das Kombinieren von Sammlungstypen (das Erstellen von Sammlungen von Sammlungen) ist zulässig.Combining collection types (having collections of collections) is allowed. Verzweigte Arrays werden als Sammlungen von Sammlungen behandelt.Jagged arrays are treated as collections of collections. Arrays mit mehreren Dimensionen werden nicht unterstützt.Multidimensional arrays are not supported.

  • Byte- und XmlNode -Arrays sind besondere Arraytypen, die als Primitive und nicht als Sammlungen behandelt werden.Arrays of byte and arrays of XmlNode are special array types that are treated as primitives, not collections. Die Serialisierung eines Bytearrays führt zu einem einzelnen XML-Element, das statt eines separaten Elements für jedes Byte einen Abschnitt aus Base64-codierten Daten enthält.Serializing an array of byte results in a single XML element that contains a chunk of Base64-encoded data, instead of a separate element for each byte. Weitere Informationen finden Sie unterFor more information about zur Behandlung eines Arrays von XmlNode finden Sie unter XML and ADO.NET Types in Data Contracts. how an array of XmlNode is treated, see XML and ADO.NET Types in Data Contracts. Natürlich können diese besonderen Typen selbst Teil von Sammlungen sein: Ein Bytearray führt zu mehreren XML-Elementen, die jeweils einen Abschnitt aus Base64-codierten Daten enthalten.Of course, these special types can themselves participate in collections: an array of array of byte results in multiple XML elements, with each containing a chunk of Base64-encoded data.

  • Wenn das DataContractAttribute -Attribut auf einen Sammlungstyp angewendet wird, wird der Typ als regulärer Datenvertragstyp und nicht als Sammlung behandelt.If the DataContractAttribute attribute is applied to a collection type, the type is treated as a regular data contract type, not as a collection.

  • Wenn ein Sammlungstyp die IXmlSerializable -Schnittstelle implementiert, dann gelten die folgenden Regeln, wenn ein myType:IList<string>, IXmlSerializable-Typ vorliegt:If a collection type implements the IXmlSerializable interface, the following rules apply, given a type myType:IList<string>, IXmlSerializable:

    • Wird als Typ IList<string>deklariert, wird der Typ als Liste serialisiert.If the declared type is IList<string>, the type is serialized as a list.

    • Wird als Typ myTypedeklariert, wird der Typ als IXmlSerializableserialisiert.If the declared type is myType, it is serialized as IXmlSerializable.

    • Wenn der deklarierte Typ IXmlSerializablelautet, wird der Typ nur dann als IXmlSerializableserialisiert, wenn Sie myType der Liste bekannter Typen hinzufügen.If the declared type is IXmlSerializable, it is serialized as IXmlSerializable, but only if you add myType to the list of known types.

  • Sammlungen werden mit den Methoden aus der folgenden Tabelle serialisiert und deserialisiert:Collections are serialized and deserialized using the methods shown in the following table.

Sammlungstyp implementiertCollection type implements Bei der Serialisierung aufgerufene Methode(n)Method(s) called on serialization Bei der Deserialisierung aufgerufene Methode(n)Method(s) called on deserialization
Generisches IDictionary<TKey,TValue>Generic IDictionary<TKey,TValue> get_Keys, get_Valuesget_Keys, get_Values Generisches HinzufügenGeneric Add
IDictionary get_Keys, get_Valuesget_Keys, get_Values Add
Generisches IList<T>Generic IList<T> Generischer IList<T> -IndexerGeneric IList<T> indexer Generisches HinzufügenGeneric Add
Generisches ICollection<T>Generic ICollection<T> EnumeratorEnumerator Generisches HinzufügenGeneric Add
IList IList -IndexerIList Indexer Add
Generisches IEnumerable<T>Generic IEnumerable<T> GetEnumerator Eine nicht statische Methode mit dem Namen Add , die einen Parameter des entsprechenden Typs annimmt (den Typ des generischen Parameters oder einen der Basistypen).A non-static method called Add that takes one parameter of the appropriate type (the type of the generic parameter or one of its base types). Eine solche Methode ist erforderlich, damit das Serialisierungsprogramm einen Sammlungstyp sowohl während der Serialisierung als auch während der Deserialisierung als Sammlung behandelt.Such a method must exist for the serializer to treat a collection type as a collection during both serialization and deserialization.
IEnumerable (und daher ICollection, die sich daraus ableitet)IEnumerable (and thus ICollection, which derives from it) GetEnumerator Eine nicht statische Methode namens Add , die einen Parameter des Typs Objectannimmt.A non-static method called Add that takes one parameter of type Object. Eine solche Methode ist erforderlich, damit das Serialisierungsprogramm einen Sammlungstyp sowohl während der Serialisierung als auch während der Deserialisierung als Sammlung behandelt.Such a method must exist for the serializer to treat a collection type as a collection during both serialization and deserialization.

In der vorangehenden Tabelle werden in absteigender Reihenfolge Sammlungsschnittstellen aufgelistet.The preceding table lists collection interfaces in descending order of precedence. Das bedeutet beispielsweise, dass die Sammlung gemäß den IList -Regeln serialisiert und deserialisiert wird, wenn ein Typ sowohl die IEnumerable<T>als auch das generische IList implementiert:This means, for example, that if a type implements both IList and Generic IEnumerable<T>, the collection is serialized and deserialized according to the IList rules:

  • Bei der Deserialisierung werden alle Sammlungen deserialisiert, indem zunächst durch Aufrufen des Standardkonstruktors eine Instanz des Typs erstellt wird. Der Standardkonstruktor ist erforderlich, damit das Serialisierungsprogramm einen Sammlungstyp sowohl während der Serialisierung als auch während der Deserialisierung als Sammlung behandelt.At deserialization, all collections are deserialized by first creating an instance of the type by calling the default constructor, which must be present for the serializer to treat a collection type as a collection during both serialization and deserialization.

  • Wenn die gleiche generische Sammlungsschnittstelle mehrmals implementiert wird (z. B. wenn ein Typ sowohl die generische ICollection<T> von Integer als auch die generische ICollection<T> von Stringimplementiert) und keine Schnittstelle mit höherer Rangfolge gefunden wird, wird die Sammlung nicht als gültige Sammlung behandelt.If the same generic collection interface is implemented more than once (for example, if a type implements both Generic ICollection<T> of Integer and Generic ICollection<T> of String) and no higher-precedence interface is found, the collection is not treated as a valid collection.

  • Auf Sammlungstypen kann das SerializableAttribute -Attribut angewendet sein, und sie können die ISerializable -Schnittstelle implementieren.Collection types can have the SerializableAttribute attribute applied to them and can implement the ISerializable interface. Beide werden ignoriert.Both of these are ignored. Wenn jedoch der Typ die Sammlungstypanforderungen nicht vollständig erfüllt (z. B. wenn der Sammlungstyp und die Add -Methode fehlen), wird der Typ nicht als Sammlungstyp betrachtet. Daher werden das SerializableAttribute -Attribut und die ISerializable -Schnittstelle verwendet, um die Serialisierbarkeit des Typs zu bestimmen.However, if the type does not fully meet collection type requirements (for example, the Add method is missing), the type is not considered a collection type, and thus the SerializableAttribute attribute and the ISerializable interface are used to determine whether the type can be serialized.

  • Durch Anwenden des CollectionDataContractAttribute -Attributs auf eine Sammlung, um diese anzupassen, wird der oben genannte SerializableAttribute -Fallback-Mechanismus entfernt.Applying the CollectionDataContractAttribute attribute to a collection to customize it removes the SerializableAttribute preceding fallback mechanism. Stattdessen wird eine InvalidDataContractException -Ausnahme ausgelöst, wenn eine benutzerdefinierte Sammlung keine Sammlungstypanforderungen erfüllt,.Instead, if a customized collection does not meet collection type requirements, an InvalidDataContractException exception is thrown. Die Ausnahmezeichenfolge enthält oftmals Informationen, mit denen erläutert wird, warum ein angegebener Typ nicht als gültige Sammlung betrachtet wird (keine Add -Methode, kein Standardkonstruktor usw.), weshalb es oft hilfreich sein kann, das CollectionDataContractAttribute -Attribut zum Zwecke des Debuggings anzuwenden.The exception string often contains information that explains why a given type is not considered a valid collection (no Add method, no default constructor, and so on), so it is often useful to apply the CollectionDataContractAttribute attribute for debugging purposes.

SammlungsbenennungCollection Naming

Im Folgenden finden Sie eine Liste von Regeln für die Sammlungsbenennung:The following is a list of collection naming rules:

  • Der Standardnamespace für alle Datenverträge für Wörterbuchsammlungen sowie für Datenverträge für Listensammlungen, die primitive Typen enthalten, lautet http://schemas.microsoft.com/2003/10/Serialization/Arrays, es sei denn, er wurde von "Namespace" überschrieben.The default namespace for all dictionary collection data contracts, as well as for list collection data contracts that contain primitive types, is http://schemas.microsoft.com/2003/10/Serialization/Arrays unless overridden using Namespace. Typen, die integrierten XSD-Typen zugeordnet werden, sowie char-, Timespan- und Guid -Typen, gelten zu diesem Zweck als primitive Typen.Types that map to built-in XSD types, as well as char, Timespan, and Guid types, are considered primitives for this purpose.

  • Der Standardnamespace für Sammlungstypen, die nicht primitive Typen enthalten, ist der gleiche wie der Namespace für die Datenverträge des in der Sammlung enthaltenen Typs, sofern er nicht von "Namespace" überschrieben wurde.The default namespace for collection types that contain non-primitive types, unless it is overridden using Namespace, is the same as the data contract namespace of the type contained in the collection.

  • Der Standardname für Datenverträge für Sammlungstypen ist die Zeichenfolge "ArrayOf" in Kombination mit dem Datenvertragsnamen des in der Sammlung enthaltenen Typs, sofern er nicht von "Name" überschrieben wurde.The default name for list collection data contracts, unless overridden using Name, is the string "ArrayOf" combined with the data contract name of the type contained in the collection. Der Datenvertragsname einer generischen Liste von ganzen Zahlen lautet z. B. "ArrayOfint".For example, the data contract name for a Generic List of Integers is "ArrayOfint". Beachten Sie, dass der Datenvertragsname von Object "anyType" lautet, sodass der Datenvertragsname für nicht generische Listen wie ArrayList "ArrayOfanyType" lautet.Keep in mind that the data contract name of Object is "anyType", so the data contract name of non-generic lists like ArrayList is "ArrayOfanyType".

Der Standardname für Datenverträge für Wörterbuchsammlungen ist die Zeichenfolge "ArrayOfKeyValueOf" in Kombination mit dem Datenvertragsnamen für den Schlüsseltyp, gefolgt vom Datenvertragsnamen des Werttyps, sofern er nicht von Name überschrieben wurde.The default name for dictionary collection data contracts, unless overridden using Name, is the string "ArrayOfKeyValueOf" combined with the data contract name of the key type followed by the data contract name of the value type. Der Datenvertragsname für ein generisches Wörterbuch für Zeichenfolge und ganze Zahl lautet z. B. "ArrayOfKeyValueOfstringint".For example, the data contract name for a Generic Dictionary of String and Integer is "ArrayOfKeyValueOfstringint". Wenn darüber hinaus der Schlüssel- oder der Werttyp kein primitiver Typ ist, wird an den Namen ein Namespacehash der Datenvertragsnamespaces für den Schlüssel- und Werttyp angefügt.Additionally, if either the key or the value types are not primitive types, a namespace hash of the data contract namespaces of the key and value types is appended to the name. Weitere Informationen finden Sie unterFor more information about zu Namespacehashes finden Sie unter Data Contract Names. namespace hashes, see Data Contract Names.

Jeder Wörterbuchsammlungsdatenvertrag weist einen Begleitdatenvertrag auf, der einen Eintrag im Wörterbuch darstellt.Each dictionary collection data contract has a companion data contract that represents one entry in the dictionary. Der Name ist der gleiche wie der des Wörterbuchdatenvertrags, bis auf das Präfix "ArrayOf", und der Namespace ist ebenfalls der gleiche wie für den Wörterbuchdatenvertrag.Its name is the same as for the dictionary data contract, except for the "ArrayOf" prefix, and its namespace is the same as for the dictionary data contract. Beispielsweise kann für den "ArrayOfKeyValueOfstringint"-Wörterbuchdatenvertrag der "KeyValueofstringint"-Datenvertrag einen Eintrag im Wörterbuch darstellen.For example, for the "ArrayOfKeyValueOfstringint" dictionary data contract, the "KeyValueofstringint" data contract represents one entry in the dictionary. Sie können den Namen dieses Datenvertrags individuell anpassen, indem Sie die ItemName -Eigenschaft verwenden, wie im nächsten Abschnitt beschrieben.You can customize the name of this data contract by using the ItemName property, as described in the next section.

Benennungsregeln für generische Typen, wie unter Data Contract Namesbeschrieben, gelten vollständig für Sammlungstypen, d. h. Sie können geschweifte Klammern innerhalb von "Name" verwenden, um generische Parametertypen anzuzeigen.Generic type naming rules, as described in Data Contract Names, fully apply to collection types; that is, you can use curly braces within Name to indicate generic type parameters. Die Zahlen innerhalb der Klammern verweisen jedoch auf generische Parameter und nicht auf Typen, die in der Sammlung enthalten sind.However, numbers within the braces refer to generic parameters and not types contained within the collection.

SammlungsanpassungCollection Customization

Die folgenden Verwendungen des CollectionDataContractAttribute -Attributs sind unzulässig und führen zu einer InvalidDataContractException -Ausnahme:The following uses of the CollectionDataContractAttribute attribute are forbidden and result in an InvalidDataContractException exception:

PolymorphieregelnPolymorphism Rules

Wie bereits erwähnt, behindert das Anpassen von Sammlungen mit dem CollectionDataContractAttribute -Attribut möglicherweise die Austauschbarkeit der Sammlungen.As previously mentioned, customizing collections by using the CollectionDataContractAttribute attribute may interfere with collection interchangeability. Zwei benutzerdefinierte Sammlungstypen gelten nur als gleich, wenn ihre Namen, ihr Namespace, ihr Elementname und ihre Schlüssel- und Wertnamen (sofern es sich um Wörterbuchsammlungen handelt) übereinstimmen.Two customized collection types can only be considered equivalent if their name, namespace, item name, as well as key and value names (if these are dictionary collections) match.

Aufgrund der Anpassungen ist es möglich, einen Sammlungsdatenvertrag, wo noch ein weiterer erwartet wird, versehentlich zu verwenden.Due to customizations, it is possible to inadvertently use one collection data contract where another is expected. Dies sollte vermieden werden.This should be avoided. Siehe folgende Typen:See the following types.

[DataContract]
public class Student
{
    [DataMember]
    public string name;
    [DataMember]
    public IList<int> testMarks;
}
public class Marks1 : List<int> {}
[CollectionDataContract(ItemName="mark")]
public class Marks2 : List<int> {}
<DataContract()> _
Public Class Student

    <DataMember()> _
    Public name As String

    <DataMember()> _
    Public testMarks As IList(Of Integer)

End Class

Public Class Marks1
    Inherits List(Of Integer)
End Class

<CollectionDataContract(ItemName:="mark")> _
Public Class Marks2
    Inherits List(Of Integer)
End Class

In diesem Fall kann eine Instanz von Marks1 testMarkszugewiesen werden.In this case, an instance of Marks1 can be assigned to testMarks. Marks2 sollte jedoch nicht verwendet werden: Der zugehörige Datenvertrag stimmt nicht mit dem IList<int> -Datenvertrag überein.However, Marks2 should not be used because its data contract is not considered equivalent to the IList<int> data contract. Der Name des Vertrags "Marks2" und nicht "ArrayOfint", und sich wiederholende Elementname lautet "<markieren >" und nicht "<Int >".The data contract name is "Marks2" and not "ArrayOfint", and the repeating element name is "<mark>" and not "<int>".

Die Regeln in der folgenden Tabelle gelten für die polymorphe Zuweisung von Sammlungen:The rules in the following table apply to polymorphic assignment of collections.

Deklarierter TypDeclared type Zuweisen einer nicht benutzerdefinierten SammlungAssigning a non-customized collection Zuweisen einer benutzerdefinierten SammlungAssigning a customized collection
ObjectObject Vertragsname wird serialisiert.Contract name is serialized. Vertragsname wird serialisiert.Contract name is serialized.

Anpassung wird verwendet.Customization is used.
SammlungsschnittstelleCollection interface Vertragsname wird nicht serialisiert.Contract name is not serialized. Vertragsname wird nicht serialisiert.Contract name is not serialized.

Anpassung wird nicht verwendet.Customization is not used.
Nicht benutzerdefinierte SammlungNon-customized collection Vertragsname wird nicht serialisiert.Contract name is not serialized. Vertragsname wird serialisiert.Contract name is serialized.

Anpassung wird verwendet.Customization is used.
Benutzerdefinierte SammlungCustomized collection Vertragsname wird serialisiert.Contract name is serialized. Anpassung wird nicht verwendet.Customization is not used. Vertragsname wird serialisiert.Contract name is serialized.

Anpassung des zugewiesenen Typs wird verwendet. Customization of the assigned type is used.

* Mit der NetDataContractSerializer -Klasse wird Anpassung in diesem Fall verwendet.*With the NetDataContractSerializer class, customization is used in this case. Die NetDataContractSerializer -Klasse serialisiert auch den tatsächlichen Typnamen in diesem Fall, sodass die Deserialisierung wie erwartet funktioniert.The NetDataContractSerializer class also serializes the actual type name in this case, so deserialization works as expected.

** Diese Fälle führen zu Instanzen, die dem Schema nach ungültig sind und somit vermieden werden sollten.**These cases result in schema-invalid instances and thus should be avoided.

In Fällen, in denen der Vertragsname serialisiert wird, sollte die Liste der bekannten Typen den zugewiesenen Sammlungstyp enthalten.In the cases where the contract name is serialized, the assigned collection type should be in the known types list. Auch der entgegengesetzte Fall trifft zu: In Fällen, in denen der Name nicht serialisiert wird, muss der Typ nicht der Liste der bekannten Typen hinzugefügt werden.The opposite is also true: in the cases where the name is not serialized, adding the type to the known types list is not required.

Einem Array eines Basistyps kann ein Array eines abgeleiteten Typs zugewiesen werden.An array of a derived type can be assigned to an array of a base type. In diesem Fall wird der Vertragsname für den abgeleiteten Typ für jedes sich wiederholende Element serialisiert.In this case, the contract name for the derived type is serialized for each repeating element. Wenn z. B. ein Typ Book vom Typ LibraryItemabgeleitet wurde, können Sie ein Array von Book einem Array von LibraryItemhinzufügen.For example, if a type Book derives from the type LibraryItem, you can assign an array of Book to an array of LibraryItem. Dies gilt nicht für andere Sammlungstypen.This does not apply to other collection types. Sie können z. B. eine Generic List of Book nicht einem Generic List of LibraryItemzuweisen.For example, you cannot assign a Generic List of Book to a Generic List of LibraryItem. Sie können aber ein Generic List of LibraryItem zuweisen, das Book -Instanzen enthält.You can, however, assign a Generic List of LibraryItem that contains Book instances. Sowohl im Fall mit Array als auch im Fall ohne Array sollte Book in der Liste der bekannten Typen enthalten sein.In both the array and the non-array case, Book should be in the known types list.

Sammlungen und Beibehaltung von ObjektverweisenCollections and Object Reference Preservation

Wenn ein Serialisierungsprogramm in einem Modus ausgeführt wird, in dem es Objektverweise beibehält, gilt die Beibehaltung der Objektverweise auch für Sammlungen.When a serializer functions in a mode where it preserves object references, object reference preservation also applies to collections. Insbesondere wird Objektidentität sowohl für ganze Sammlungen als auch für einzelne Elemente beibehalten, die in Sammlungen enthalten sind.Specifically, object identity is preserved for both entire collections and individual items contained in collections. Für Wörterbücher wird Objektidentität sowohl für Schlüssel- und Wertepaarobjekte als auch für die einzelnen Schlüssel- und Werteobjekte beibehalten.For dictionaries, object identity is preserved both for the key/value pair objects and the individual key and value objects.

Siehe auchSee Also

CollectionDataContractAttribute