Datenvertrags-SchemareferenzData Contract Schema Reference

In diesem Thema wird die von DataContractSerializer zur Beschreibung der Common Language Runtime (CLR)-Typen für die XML-Serialisierung verwendete Teilmenge des XML-Schemas (XSD) beschrieben.This topic describes the subset of the XML Schema (XSD) used by DataContractSerializer to describe common language runtime (CLR) types for XML serialization.

DataContractSerializer-ZuordnungenDataContractSerializer Mappings

Der DataContractSerializer ordnet CLR-Typen XSD zu, wenn Metadaten von einem Windows Communication Foundation (WCF)Windows Communication Foundation (WCF) -Dienst mithilfe eines Metadatenendpunkts oder dem ServiceModel Metadata Utility Tool (Svcutil.exe)exportiert werden.The DataContractSerializer maps CLR types to XSD when metadata is exported from a Windows Communication Foundation (WCF)Windows Communication Foundation (WCF) service using a metadata endpoint or the ServiceModel Metadata Utility Tool (Svcutil.exe). Weitere Informationen finden Sie unterFor more information, seeDatenvertrags-Serialisierer. Data Contract Serializer.

Der DataContractSerializer ordnet XSD auch dann CLR-Typen zu, wenn Svcutil.exe für den Zugriff auf WSDL- (Web Services Description Language) oder XSD-Dokumente und für die Generierung von Vertragsdateien für Dienste oder Clients verwendet wird.The DataContractSerializer also maps XSD to CLR types when Svcutil.exe is used to access Web Services Description Language (WSDL) or XSD documents and generate data contracts for services or clients.

Nur XML-Schemainstanzen, die den in diesem Dokument beschriebenen Anforderungen entsprechen, können mit DataContractSerializerCLR-Typen zugeordnet werden.Only XML Schema instances that conform to requirements stated in this document can be mapped to CLR types using DataContractSerializer.

UnterstützungsebenenSupport Levels

Der DataContractSerializer stellt die folgenden Unterstützungsebenen für eine gegebene XML-Schemafunktion bereit:The DataContractSerializer provides the following levels of support for a given XML Schema feature:

  • Unterstützt.Supported. Es gibt eine explizite Zuordnung dieser Funktion zu CLR-Typen oder -Attributen (oder beiden) mit DataContractSerializer.There is explicit mapping from this feature to CLR types or attributes (or both) using DataContractSerializer.

  • Ignoriert.Ignored. Die Funktion ist in vom DataContractSerializerimportierten Schemas zugelassen, hat aber keine Auswirkungen auf die Codegenerierung.The feature is allowed in schemas imported by the DataContractSerializer, but has no effect on code generation.

  • Unzulässig.Forbidden. Der DataContractSerializer unterstützt nicht den Import eines Schemas, das diese Funktion verwendet.The DataContractSerializer does not support importing a schema using the feature. Svcutil.exe verwendet beispielsweise wieder den XmlSerializer , wenn auf ein WSDL mit einem Schema zugegriffen wird, das eine solche Funktion verwendet.For example, Svcutil.exe, when accessing a WSDL with a schema that uses such a feature, falls back to using the XmlSerializer instead. Dies ist das Standardverhalten.This is by default.

Allgemeine InformationenGeneral Information

  • Der Schemanamespace wird unter XML-Schemabeschrieben.The schema namespace is described at XML Schema. In diesem Dokument wird das Präfix "xs" verwendet.The prefix "xs" is used in this document.

  • Alle Attribute mit einem Nicht-Schema-Namespace werden ignoriert.Any attributes with a non-schema namespace are ignored.

  • Alle Anmerkungen (außer den in diesem Dokument beschriebenen) werden ignoriert.Any annotations (except for those described in this document) are ignored.

<xs: Schema >: Attribute<xs:schema>: attributes

AttributAttribute DataContractDataContract
attributeFormDefault Ignoriert.Ignored.
blockDefault Ignoriert.Ignored.
elementFormDefault Muss qualifiziert sein.Must be qualified. Damit ein Schema vom DataContractSerializerunterstützt wird, müssen alle Elemente qualifiziert werden.All elements must be qualified for a schema to be supported by DataContractSerializer. Dies kann erreicht werden, indem entweder xs:schema/@elementFormDefault auf "qualified" oder durch Festlegen von xs:element/@form auf jeder einzelnen Elementdeklaration auf "qualified".This can be accomplished by either setting xs:schema/@elementFormDefault to "qualified" or by setting xs:element/@form to "qualified" on each individual element declaration.
finalDefault Ignoriert.Ignored.
Id Ignoriert.Ignored.
targetNamespace Unterstützt und wird dem Datenvertragsnamespace zugeordnet.Supported and mapped to the data contract namespace. Wenn dieses Attribut nicht angegeben ist, wird ein leerer Namespace verwendet.If this attribute is not specified, the blank namespace is used. Dies darf nicht der reservierte Namespace http://schemas.microsoft.com/2003/10/Serialization sein.Cannot be the reserved namespace http://schemas.microsoft.com/2003/10/Serialization/.
version Ignoriert.Ignored.

<xs: Schema >: Inhalt<xs:schema>: contents

InhaltContents SchemaSchema
include Unterstützt.Supported. DataContractSerializer unterstützt xs:include und xs:import.DataContractSerializer supports xs:include and xs:import. Svcutil.exe schränkt jedoch darauf folgende xs:include/@schemaLocation - und xs:import/@location -Verweise ein, wenn Metadaten aus einer lokalen Datei geladen werden.However, Svcutil.exe restricts following xs:include/@schemaLocation and xs:import/@location references when metadata is loaded from a local file. Die Liste der Schemadateien muss in diesem Fall über einen Out-of-Band-Mechanismus und nicht mittels include übergeben werden. Mit includeangegebene Schemadokumente werden ignoriert.The list of schema files must be passed through an out-of-band mechanism and not through include in this case; included schema documents are ignored.
redefine Unzulässig.Forbidden. Die Verwendung von xs:redefine durch DataContractSerializer ist aus Sicherheitsgründen unzulässig: x:redefine erfordert, dass schemaLocation befolgt wird.The use of xs:redefine is forbidden by DataContractSerializer for security reasons: x:redefine requires schemaLocation to be followed. Unter bestimmten Umständen schränkt Svcutil.exe mit DataContract die Verwendung von schemaLocationein.In certain circumstances, Svcutil.exe using DataContract restricts use of schemaLocation.
import Unterstützt.Supported. DataContractSerializer unterstützt xs:include und xs:import.DataContractSerializer supports xs:include and xs:import. Svcutil.exe schränkt jedoch darauf folgende xs:include/@schemaLocation - und xs:import/@location -Verweise ein, wenn Metadaten aus einer lokalen Datei geladen werden.However, Svcutil.exe restricts following xs:include/@schemaLocation and xs:import/@location references when metadata is loaded from a local file. Die Liste der Schemadateien muss in diesem Fall über einen Out-of-Band-Mechanismus und nicht mittels include übergeben werden. Mit includeangegebene Schemadokumente werden ignoriert.The list of schema files must be passed through an out-of-band mechanism and not through include in this case; included schema documents are ignored.
simpleType Unterstützt.Supported. Siehe den Abschnitt xs:simpleType .See the xs:simpleType section.
complexType Unterstützt, wird Datenverträgen zugeordnet.Supported, maps to data contracts. Siehe den Abschnitt xs:complexType .See the xs:complexType section.
group Ignoriert.Ignored. DataContractSerializer bietet keine Unterstützung für xs:group, xs:attributeGroupund xs:attribute.DataContractSerializer does not support use of xs:group, xs:attributeGroup, and xs:attribute. Diese Deklarationen werden als untergeordnete Elemente von xs:schemaignoriert; auf sie kann jedoch nicht innerhalb von complexType oder anderer unterstützter Konstrukte verwiesen werden.These declarations are ignored as children of xs:schema, but cannot be referenced from within complexType or other supported constructs.
attributeGroup Ignoriert.Ignored. DataContractSerializer bietet keine Unterstützung für xs:group, xs:attributeGroupund xs:attribute.DataContractSerializer does not support use of xs:group, xs:attributeGroup, and xs:attribute. Diese Deklarationen werden als untergeordnete Elemente von xs:schemaignoriert; auf sie kann jedoch nicht innerhalb von complexType oder anderer unterstützter Konstrukte verwiesen werden.These declarations are ignored as children of xs:schema, but cannot be referenced from within complexType or other supported constructs.
element Unterstützt.Supported. Siehe Globale Elementdeklaration (GED).See Global Element Declaration (GED).
attribute Ignoriert.Ignored. DataContractSerializer bietet keine Unterstützung für xs:group, xs:attributeGroupund xs:attribute.DataContractSerializer does not support use of xs:group, xs:attributeGroup, and xs:attribute. Diese Deklarationen werden als untergeordnete Elemente von xs:schemaignoriert; auf sie kann jedoch nicht innerhalb von complexType oder anderer unterstützter Konstrukte verwiesen werden.These declarations are ignored as children of xs:schema, but cannot be referenced from within complexType or other supported constructs.
notation Ignoriert.Ignored.

Komplexe Typen – <xs: complexType >Complex Types – <xs:complexType>

Allgemeine InformationenGeneral Information

Jeder komplexe Typ <xs: complexType > wird einem Datenvertrag zugeordnet.Each complex type <xs:complexType> maps to a data contract.

<xs: complexType >: Attribute<xs:complexType>: attributes

AttributAttribute SchemaSchema
abstract Muss den Wert false aufweisen (Standardwert)Must be false (default).
block Unzulässig.Forbidden.
final Ignoriert.Ignored.
id Ignoriert.Ignored.
mixed Muss den Wert false aufweisen (Standardwert)Must be false (default).
name Unterstützt. Wird dem Namen des Datenvertrags zugeordnet.Supported and mapped to the data contract name. Wenn der Name Punkte enthält, wird versucht, den Typ einem inneren Typ zuzuordnen.If there are periods in the name, an attempt is made to map the type to an inner type. Beispielsweise wird ein komplexer Typ namens A.B einem Datenvertragstyp zugeordnet, der ein innerer Typ mit dem Datenvertragsnamen Aist. Dies geschieht jedoch nur dann, wenn ein solcher Datenvertragstyp vorhanden ist.For example, a complex type named A.B maps to a data contract type that is an inner type of a type with the data contract name A, but only if such a data contract type exists. Es ist mehr als eine Verschachtelungsebene möglich: A.B.C z.&#160;B. kann ein innerer Typ sein, jedoch nur dann, wenn sowohl A als auch A.B vorhanden sind.More than one level of nesting is possible: for example, A.B.C can be an inner type, but only if A and A.B both exist.

<xs: complexType >: Inhalt<xs:complexType>: contents

InhaltContents SchemaSchema
simpleContent Erweiterungen sind unzulässig.Extensions are forbidden.

Einschränkung wird nur von anySimpleTypezugelassen.Restriction is allowed only from anySimpleType.
complexContent Unterstützt.Supported. Siehe "Vererbung".See "Inheritance".
group Unzulässig.Forbidden.
all Unzulässig.Forbidden.
choice UnzulässigForbidden
sequence Unterstützt, wird Datenmembern eines Datenvertrags zugeordnet.Supported, maps to data members of a data contract.
attribute Unzulässig, auch wenn use="prohibited" (mit einer Ausnahme).Forbidden, even if use="prohibited" (with one exception). Nur optionale Attribute aus dem Standardserialisierungsschema-Namespace werden unterstützt.Only optional attributes from the Standard Serialization Schema namespace are supported. Sie werden Datenmembern im Datenvertragsprogrammiermodell nicht zugeordnet.They do not map to data members in the data contract programming model. Aktuell hat nur ein solches Attribut Bedeutung, es wird im Abschnitt ISerializable erläutert.Currently, only one such attribute has meaning and is discussed in the ISerializable section. Alle anderen werden ignoriert.All others are ignored.
attributeGroup Unzulässig.Forbidden. In Version&#160;1 von WCFWCF ignoriert DataContractSerializer das Vorhandensein von attributeGroup in xs:complexType.In the WCFWCF v1 release, DataContractSerializer ignores the presence of attributeGroup inside xs:complexType.
anyAttribute Unzulässig.Forbidden.
(leer)(empty) Wird einem Datenvertrag ohne Datenmember zugeordnet.Maps to a data contract with no data members.

<xs: Sequence > in einem komplexen Typ: Attribute<xs:sequence> in a complex type: attributes

AttributAttribute SchemaSchema
id Ignoriert.Ignored.
maxOccurs Muss 1 (Standard) sein.Must be 1 (default).
minOccurs Muss 1 (Standard) sein.Must be 1 (default).

<xs: Sequence > in einem komplexen Typ: Inhalt<xs:sequence> in a complex type: contents

InhaltContents SchemaSchema
element Jede Instanz wird einem Datenmember zugeordnet.Each instance maps to a data member.
group Unzulässig.Forbidden.
choice Unzulässig.Forbidden.
sequence Unzulässig.Forbidden.
any Unzulässig.Forbidden.
(leer)(empty) Wird einem Datenvertrag ohne Datenmember zugeordnet.Maps to a data contract with no data members.

Elemente – <xs: Element >Elements – <xs:element>

Allgemeine InformationenGeneral Information

<xs:element> kann in den folgenden Kontexten auftreten:<xs:element> can occur in the following contexts:

  • Es kann innerhalb eines <xs:sequence>-Elements auftreten, das einen Datenmember eines regulären Datenvertrags (keines Auflistungsdatenvertrags) beschreibt.It can occur within an <xs:sequence>, which describes a data member of a regular (non-collection) data contract. In diesem Fall muss das maxOccurs -Attribut 1 sein.In this case, the maxOccurs attribute must be 1. (Der Wert 0 ist nicht zulässig.)(A value of 0 is not allowed).

  • Es kann innerhalb eines <xs:sequence>-Elements auftreten, das einen Datenmember eines Auflistungsdatenvertrags beschreibt.It can occur within an <xs:sequence>, which describes a data member of a collection data contract. In diesem Fall muss der Wert des maxOccurs -Attributs größer&#160;1 oder "unbounded" sein.In this case, the maxOccurs attribute must be greater than 1 or "unbounded".

  • Es kann innerhalb eines <xs:schema> -Elements als eine globale Elementdeklaration (GED) auftreten.It can occur within an <xs:schema> as a Global Element Declaration (GED).

<xs: Element > mit MaxOccurs = 1 innerhalb einer <xs: Sequence > (Datenmember)<xs:element> with maxOccurs=1 within an <xs:sequence> (Data Members)

AttributAttribute SchemaSchema
ref Unzulässig.Forbidden.
name Unterstützt, wird dem Datenmembernamen zugeordnet.Supported, maps to the data member name.
type Unterstützt, wird dem Datenmembertyp zugeordnet.Supported, maps to the data member type. Weitere Informationen finden Sie unter Zuordnung von Typen zu primitivem Typen.For more information, see Type/primitive mapping. Wenn nicht angegeben (und wenn das Element keinen anonymen Typ enthält), wird xs:anyType angenommen.If not specified (and the element does not contain an anonymous type), xs:anyType is assumed.
block Ignoriert.Ignored.
default Unzulässig.Forbidden.
fixed Unzulässig.Forbidden.
form Muss qualifiziert sein.Must be qualified. Dieses Attribut kann über elementFormDefault auf xs:schemafestgelegt werden.This attribute can be set through elementFormDefault on xs:schema.
id Ignoriert.Ignored.
maxOccurs 11
minOccurs Wird der IsRequired -Eigenschaft eines Datenmembers zugeordnet (IsRequired hat den Wert true, wenn minOccurs &#160;1 ist).Maps to the IsRequired property of a data member (IsRequired is true when minOccurs is 1).
nillable Beeinflusst die Typzuordnung.Affects type mapping. Siehe Zuordnung von Typen zu primitivem Typen.See Type/primitive mapping.

<xs: Element > mit MaxOccurs > 1 innerhalb einer <xs: Sequence > (Auflistungen)<xs:element> with maxOccurs>1 within an <xs:sequence> (Collections)

Auflistungen können einen der folgenden Typen aufweisen:Collections can be of the following types:

  • Reguläre Auflistungen (z. B. Arrays).Regular collections (for example, arrays).

  • Wörterbuchauflistungen (die einen Wert einem anderen zuordnen, z.&#160;B. eine Hashtable).Dictionary collections (mapping one value to another; for example, a Hashtable).

  • Der einzige Unterschied zwischen einem Wörterbuchtyp und einem Array mit Schlüssel-Wert-Paaren liegt im generierten Programmiermodell.The only difference between a dictionary and an array of a key/value pair type is in the generated programming model. Es gibt einen Schemaanmerkungsmechanismus, der verwendet werden kann, um anzugeben, dass ein bestimmter Typ eine Wörterbuchauflistung ist.There is a schema annotation mechanism that can be used to indicate that a given type is a dictionary collection.

Die Regeln für die Attribute ref, block, default, fixed, formund id sind die gleichen wie für diejenigen, die keine Auflistungstypen sind.The rules for the ref, block, default, fixed, form, and id attributes are the same as for the non-collection case. Die anderen Attribute sind in der folgenden Tabelle aufgeführt:Other attributes include those in the following table.

AttributAttribute SchemaSchema
name Unterstützt, wird der ItemName -Eigenschaft des CollectionDataContractAttribute -Attributs zugeordnet.Supported, maps to the ItemName property in the CollectionDataContractAttribute attribute.
type Unterstützt, wird dem in der Auflistung gespeicherten Typ zugeordnet.Supported, maps to the type stored in the collection.
maxOccurs Größer 1 oder "unbounded".Greater than 1 or "unbounded". Das DC-Schema sollte "unbounded" verwenden.The DC schema should use "unbounded".
minOccurs Ignoriert.Ignored.
nillable Beeinflusst die Typzuordnung.Affects type mapping. Dieses Attribut wird für Wörterbuchauflistungen ignoriert.This attribute is ignored for dictionary collections.

<xs: Element > innerhalb einer <xs: Schema > globale Elementdeklaration<xs:element> within an <xs:schema> Global Element Declaration

  • Eine globale Elementdeklaration (GED), die den gleichen Namen und Namespace wie ein Typ im Schema besitzt, oder die innerhalb ihrer selbst einen anonymen Typ definiert, wird als diesem Typ zugeordnet angesehen.A Global Element Declaration (GED) that has the same name and namespace as a type in schema, or that defines an anonymous type inside itself, is said to be associated with the type.

  • Schemaexport: Für alle generierten Typen, sowohl einfache als auch komplexe, werden zugeordnete GEDs generiert.Schema export: associated GEDs are generated for every generated type, both simple and complex.

  • Deserialisierung/Serialisierung: Zugeordnete GEDs werden als Stammelemente für den Typ verwendet.Deserialization/serialization: associated GEDs are used as root elements for the type.

  • Schemaimport: Zugeordnete GEDs sind nicht erforderlich und werden ignoriert, wenn sie den folgenden Regeln entsprechen (es sei denn, sie definieren Typen).Schema import: associated GEDs are not required and are ignored if they follow the following rules (unless they define types).

AttributAttribute SchemaSchema
abstract Muss für zugeordnete GEDs den Wert false aufweisen.Must be false for associated GEDs.
block Unzulässig in zugeordneten GEDs.Forbidden in associated GEDs.
default Unzulässig in zugeordneten GEDs.Forbidden in associated GEDs.
final Muss für zugeordnete GEDs den Wert false aufweisen.Must be false for associated GEDs.
fixed Unzulässig in zugeordneten GEDs.Forbidden in associated GEDs.
id Ignoriert.Ignored.
name Unterstützt.Supported. Siehe die Definition von zugeordneten GEDs.See the definition of associated GEDs.
nillable Muss für zugeordnete GEDs den Wert true aufweisen.Must be true for associated GEDs.
substitutionGroup Unzulässig in zugeordneten GEDs.Forbidden in associated GEDs.
type Unterstützt. Muss dem zugeordneten Typ für zugeordnete GEDs entsprechen (außer wenn das Element einen anonymen Typ enthält).Supported, and must match the associated type for associated GEDs (unless the element contains an anonymous type).

<xs: Element >: Inhalt<xs:element>: contents

InhaltContents SchemaSchema
simpleType Unterstützt.Supported.
complexType Unterstützt.Supported.
unique Ignoriert.Ignored.
key Ignoriert.Ignored.
keyref Ignoriert.Ignored.
(leer)(blank) Unterstützt.Supported.

*Bei Verwendung der simpleType und complexType, Zuordnung von anonymen Typen entspricht derjenigen nicht anonyme Typen, außer dass es keine anonymen Datenverträge gibt, weshalb ein benannter Datenvertrag erstellt wird, dessen generierter Name von dem Elementnamen abgeleitet.* When using the simpleType and complexType, mapping for anonymous types is the same as for non-anonymous types, except that there is no anonymous data contracts, and so a named data contract is created, with a generated name derived from the element name. Die folgende Liste enthält die Regeln für anonyme Typen:The rules for anonymous types are in the following list:

  • WCFWCF -Implementierungsdetail: Wenn der xs:element -Name keine Punkte enthält, wird der anonyme Typ einem inneren Typ des äußeren Datenvertragstyps zugeordnet. implementation detail: If the xs:element name does not contain periods, the anonymous type maps to an inner type of the outer data contract type. Wenn der Name Punkte enthält, ist der resultierende Datenvertragstyp unabhängig (kein innerer Typ).If the name contains periods, the resulting data contract type is independent (not an inner type).

  • Der generierte Datenvertragsname des inneren Typs setzt sich zusammen aus dem Namen des äußeren Typs, gefolgt von einem Punkt, dem Namen des Elements und der Zeichenfolge "Type".The generated data contract name of the inner type is the data contract name of the outer type followed by a period, the name of the element, and the string "Type".

  • Ist ein Datenvertrag mit diesem Namen bereits vorhanden, wird dem Namen "1", "2", "3" usw. angehängt, um ihn eindeutig zu machen.If a data contract with such a name already exists, the name is made unique by appending "1", "2", "3", and so on until a unique name is created.

Einfache Typen – <simpleType >Simple Types - <xs:simpleType>

<simpleType >: Attribute<xs:simpleType>: attributes

AttributAttribute SchemaSchema
final Ignoriert.Ignored.
id Ignoriert.Ignored.
name Unterstützt, wird dem Namen des Datenvertrags zugeordnet.Supported, maps to the data contract name.

<simpleType >: Inhalt<xs:simpleType>: contents

InhaltContents SchemaSchema
restriction Unterstützt.Supported. Wird Enumerationsdatenverträgen zugeordnet.Maps to enumeration data contracts. Dieses Attribut wird ignoriert, wenn es nicht zum Enumerationsmuster passt.This attribute is ignored if it does not match the enumeration pattern. Siehe den Abschnitt xs:simpleType -Einschränkungen.See the xs:simpleType restrictions section.
list Unterstützt.Supported. Wird Flagenumerationsdatenverträgen zugeordnet.Maps to flag enumeration data contracts. Siehe den Abschnitt xs:simpleType -Listen.See the xs:simpleType lists section.
union Unzulässig.Forbidden.

<xs: restriction ><xs:restriction>

  • Einschränkungen komplexer Typen werden nur für base="xs:anyType" unterstützt.Complex type restrictions are supported only for base="xs:anyType".

  • Einfache Typeinschränkungen von xs:string , die keine anderen Einschränkungsfacets als xs:enumeration haben, werden Enumerationsdatenverträgen zugeordnet.Simple type restrictions of xs:string that do not have any restriction facets other than xs:enumeration are mapped to enumeration data contracts.

  • Alle anderen einfachen Typeinschränkungen werden den Typen zugeordnet, die sie einschränken.All other simple type restrictions are mapped to the types they restrict. Beispielsweise wird eine Einschränkung von xs:int einem Integer zugeordnet, wie es auch bei xs:int selbst der Fall ist.For example, a restriction of xs:int maps to an integer, just as xs:int itself does. Weitere Informationen finden Sie unterFor more information about zur Zuordnung primitiver Typen finden Sie unter "Zuordnung von Typen zu primitiven Typen". primitive type mapping, see Type/primitive mapping.

<xs: restriction >: Attribute<xs:restriction>: attributes

AttributAttribute SchemaSchema
base Muss ein unterstützter einfacher Typ oder xs:anyTypesein.Must be a supported simple type or xs:anyType.
id Ignoriert.Ignored.

<xs: restriction > für alle anderen Fälle: Inhalt<xs:restriction> for all other cases: contents

InhaltContents SchemaSchema
simpleType Muss, falls vorhanden, von einem unterstützten primitiven Typ abgeleitet sein.If present, must be derived from a supported primitive type.
minExclusive Ignoriert.Ignored.
minInclusive Ignoriert.Ignored.
maxExclusive Ignoriert.Ignored.
maxInclusive Ignoriert.Ignored.
totalDigits Ignoriert.Ignored.
fractionDigits Ignoriert.Ignored.
length Ignoriert.Ignored.
minLength Ignoriert.Ignored.
maxLength Ignoriert.Ignored.
enumeration Ignoriert.Ignored.
whiteSpace Ignoriert.Ignored.
pattern Ignoriert.Ignored.
(leer)(blank) Unterstützt.Supported.

EnumerationEnumeration

<xs: restriction > für Enumerationen: Attribute<xs:restriction> for enumerations: attributes

AttributAttribute SchemaSchema
base Muss, falls vorhanden, xs:stringsein.If present, must be xs:string.
id Ignoriert.Ignored.

<xs: restriction > für Enumerationen: Inhalt<xs:restriction> for enumerations: contents

InhaltContents SchemaSchema
simpleType Muss, falls vorhanden, eine vom Datenvertrag (dieser Abschnitt) unterstützte Enumerationsbeschränkung sein.If present, must be an enumeration restriction supported by the data contract (this section).
minExclusive Ignoriert.Ignored.
minInclusive Ignoriert.Ignored.
maxExclusive Ignoriert.Ignored.
maxInclusive Ignoriert.Ignored.
totalDigits Ignoriert.Ignored.
fractionDigits Ignoriert.Ignored.
length Unzulässig.Forbidden.
minLength Unzulässig.Forbidden.
maxLength Unzulässig.Forbidden.
enumeration Unterstützt.Supported. Enumerations-"ID" wird ignoriert, und "value" wird dem Wertnamen im Enumerationsdatenvertrag zugeordnet.Enumeration "id" is ignored, and "value" maps to the value name in the enumeration data contract.
whiteSpace Unzulässig.Forbidden.
pattern Unzulässig.Forbidden.
(leer)(empty) Unterstützt, wird leerem Enumerationstyp zugeordnet.Supported, maps to empty enumeration type.

Der folgende Code zeigt eine C#-Enumerationsklasse.The following code shows a C# enumeration class.

public enum MyEnum  
{  
   first = 3,  
   second = 4,  
   third =5  

}}

Diese Klasse wird vom DataContractSerializerdem folgenden Schema zugeordnet.This class maps to the following schema by the DataContractSerializer. Wenn die Enumerationswerte mit&#160;1 beginnen, werden keine xs:annotation -Blöcke generiert.If enumeration values start from 1, xs:annotation blocks are not generated.

<xs:simpleType name="MyEnum">  
<xs:restriction base="xs:string">  
 <xs:enumeration value="first">  
  <xs:annotation>  
   <xs:appinfo>  
    <EnumerationValue   
     xmlns="http://schemas.microsoft.com/2003/10/Serialization/">  
     3  
    </EnumerationValue>  
   </xs:appinfo>  
  </xs:annotation>  
 </xs:enumeration>  
 <xs:enumeration value="second">  
  <xs:annotation>  
   <xs:appinfo>  
    <EnumerationValue   
     xmlns="http://schemas.microsoft.com/2003/10/Serialization/">  
     4  
    </EnumerationValue>  
   </xs:appinfo>  
  </xs:annotation>  
 </xs:enumeration>  
</xs:restriction>  
</xs:simpleType>  

<xs: List ><xs:list>

DataContractSerializer ordnet mit System.FlagsAttribute markierte Enumerationstypen einer von xs:list abgeleiteten xs:stringzu.DataContractSerializer maps enumeration types marked with System.FlagsAttribute to xs:list derived from xs:string. Andere xs:list -Variationen werden nicht unterstützt.No other xs:list variations are supported.

<xs: List >: Attribute<xs:list>: attributes

AttributAttribute SchemaSchema
itemType Unzulässig.Forbidden.
id Ignoriert.Ignored.

<xs: List >: Inhalt<xs:list>: contents

InhaltContents SchemaSchema
simpleType Muss eine Einschränkung von xs:string mit xs:enumeration -Facet sein.Must be restriction from xs:string using xs:enumeration facet.

Sind die Enumerationswerte keine Folge mit Potenzen des Werts&#160;2 (für Flags der Standard), wird der Wert im xs:annotation/xs:appInfo/ser:EnumerationValue -Element gespeichert.If enumeration value does not follow a power of 2 progression (default for Flags), the value is stored in the xs:annotation/xs:appInfo/ser:EnumerationValue element.

Der folgende Code definiert z. B. einen Enumerationstyp für Flags.For example, the following code flags an enumeration type.

[Flags]  
public enum AuthFlags  
{    
  AuthAnonymous = 1,  
  AuthBasic = 2,  
  AuthNTLM = 4,  
  AuthMD5 = 16,  
  AuthWindowsLiveID = 64,  
}  

Dieser Typ wird dem folgenden Schema zugeordnet.This type maps to the following schema.

<xs:simpleType name="AuthFlags">  
    <xs:list>  
      <xs:simpleType>  
        <xs:restriction base="xs:string">  
          <xs:enumeration value="AuthAnonymous" />  
          <xs:enumeration value="AuthBasic" />  
          <xs:enumeration value="AuthNTLM" />  
          <xs:enumeration value="AuthMD5">  
            <xs:annotation>  
              <xs:appinfo>  
                <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Se  
rialization/">16</EnumerationValue>  
              </xs:appinfo>  
            </xs:annotation>  
          </xs:enumeration>  
          <xs:enumeration value="AuthWindowsLiveID">  
            <xs:annotation>  
              <xs:appinfo>  
                <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Se  
rialization/">64</EnumerationValue>  
              </xs:appinfo>  
            </xs:annotation>  
          </xs:enumeration>  
        </xs:restriction>  
      </xs:simpleType>  
    </xs:list>  
  </xs:simpleType>  

VererbungInheritance

Allgemeine RegelnGeneral rules

Ein Datenvertrag kann von einem anderen Datenvertrag erben.A data contract can inherit from another data contract. Solche Datenverträge werden einem Basistyp zugeordnet und durch Erweiterungstypen mithilfe des <xs:extension> -XML-Schemakonstrukts abgeleitet.Such data contracts map to a base and are derived by extension types using the <xs:extension> XML Schema construct.

Ein Datenvertrag kann nicht von einem Auflistungsdatenvertrag erben.A data contract cannot inherit from a collection data contract.

Der folgende Code stellt z. B. einen Datenvertrag dar.For example, the following code is a data contract.

[DataContract]  
public class Person  
{  
  [DataMember]  
  public string Name;  
}  
[DataContract]  
public class Employee : Person   
{      
  [DataMember]  
  public int ID;  
}  

Dieser Datenvertrag wird der folgenden XML-Schema-Typdeklaration zugeordnet.This data contract maps to the following XML Schema type declaration.

<xs:complexType name="Employee">  
 <xs:complexContent mixed="false">  
  <xs:extension base="tns:Person">  
   <xs:sequence>  
    <xs:element minOccurs="0" name="ID" type="xs:int"/>  
   </xs:sequence>  
  </xs:extension>  
 </xs:complexContent>  
</xs:complexType>  
<xs:complexType name="Person">  
 <xs:sequence>  
  <xs:element minOccurs="0" name="Name"   
    nillable="true" type="xs:string"/>  
 </xs:sequence>  
</xs:complexType>  

<complexContent >: Attribute<xs:complexContent>: attributes

AttributAttribute SchemaSchema
id Ignoriert.Ignored.
mixed Muss den Wert false aufweisen.Must be false.

<complexContent >: Inhalt<xs:complexContent>: contents

InhaltContents SchemaSchema
restriction Unzulässig, außer wenn base="xs:anyType".Forbidden, except when base="xs:anyType". Letzteres entspricht der Platzierung des Inhalts von xs:restriction direkt unter den Container von xs:complexContent.The latter is equivalent to placing the content of the xs:restriction directly under the container of the xs:complexContent.
extension Unterstützt.Supported. Wird der Datenvertragsvererbung zugeordnet.Maps to data contract inheritance.

<xs: Extension > in <complexContent >: Attribute<xs:extension> in <xs:complexContent>: attributes

AttributAttribute SchemaSchema
id Ignoriert.Ignored.
base Unterstützt.Supported. Wird dem Basisdatenvertragstyp zugeordnet, von dem dieser Typ erbt.Maps to the base data contract type that this type inherits from.

<xs: Extension > in <complexContent >: Inhalt<xs:extension> in <xs:complexContent>: contents

Die Regeln sind die gleichen wie für den <xs:complexType> -Inhalt.The rules are the same as for <xs:complexType> contents.

Wird <xs:sequence> angegeben, werden dessen Memberelemente den zusätzlichen Datenmembern zugeordnet, die im abgeleiteten Datenvertrag vorhanden sind.If an <xs:sequence> is provided, its member elements map to additional data members that are present in the derived data contract.

Wenn ein abgeleiteter Typ ein Element mit dem gleichen Namen wie ein Element in einem Basistyp enthält, wird die doppelte Elementdeklaration einem Datenmember zugeordnet, für den ein eindeutiger Name generiert wurde.If a derived type contains an element with the same name as an element in a base type, the duplicate element declaration maps to a data member with a name that is generated to be unique. Dazu werden dem Datenmember so lange positive Ganzzahlen hinzugefügt ("member1", "member2" usw.), bis ein eindeutiger Name gefunden ist.Positive integer numbers are added to the data member name ("member1", "member2", and so on) until a unique name is found. Umgekehrt:Conversely:

  • Wenn ein abgeleiteter Datenvertrag einen Datenmember mit dem gleichen Namen und Typ wie ein Datenmember in einem Basisdatenvertrag enthält, generiert der DataContractSerializer dieses entsprechende Element im abgeleiteten Typ.If a derived data contract has a data member with the same name and type as a data member in a base data contract, DataContractSerializer generates this corresponding element in the derived type.

  • Wenn ein abgeleiteter Datenvertrag einen Datenmember mit dem gleichen Namen, jedoch einem anderen Typ als ein Datenmember in einem Basisdatenvertrag enthält, importiert der DataContractSerializer ein Schema mit einem Element des Typs xs:anyType in die Deklarationen sowohl des Basistyps als auch des abgeleiteten Typs.If a derived data contract has a data member with the same name as a data member in a base data contract but a different type, the DataContractSerializer imports a schema with an element of the type xs:anyType in both base type and derived type declarations. Der ursprüngliche Typname wird in xs:annotations/xs:appInfo/ser:ActualType/@Namebeibehalten.The original type name is preserved in xs:annotations/xs:appInfo/ser:ActualType/@Name.

Beide Variationen können zu einem Schema mit einem mehrdeutigen Inhaltsmodell führen, das von der Reihenfolge der jeweiligen Datenmember abhängt.Both variations may lead to a schema with an ambiguous content model, which depends on the order of the respective data members.

Zuordnung von Typen zu primitivem TypenType/primitive mapping

Der DataContractSerializer verwendet die folgende Zuordnung für primitive Typen von XML-Schemas.The DataContractSerializer uses the following mapping for XML Schema primitive types.

XSD-TypXSD type .NET-Typ.NET type
anyType Object.Object.
anySimpleType StringString.
duration TimeSpan.TimeSpan.
dateTime DateTime.DateTime.
dateTimeOffset DateTime und TimeSpan für den Offset.DateTime and TimeSpan for the offset. Siehe DateTimeOffset-Serialisierung (unten).See DateTimeOffset Serialization below.
time StringString.
date StringString.
gYearMonth StringString.
gYear StringString.
gMonthDay StringString.
gDay StringString.
gMonth String.String.
boolean Boolean
base64Binary Byte -Array.Byte array.
hexBinary StringString.
float Single.Single.
double Double.Double.
anyURI Uri.Uri.
QName XmlQualifiedName.XmlQualifiedName.
string StringString.
normalizedString StringString.
token StringString.
language StringString.
Name StringString.
NCName StringString.
ID StringString.
IDREF StringString.
IDREFS StringString.
ENTITY StringString.
ENTITIES StringString.
NMTOKEN StringString.
NMTOKENS StringString.
decimal Decimal.Decimal.
integer Int64.Int64.
nonPositiveInteger Int64.Int64.
negativeInteger Int64.Int64.
long Int64.Int64.
int Int32.Int32.
short Int16.Int16.
Byte SByte.SByte.
nonNegativeInteger Int64.Int64.
unsignedLong UInt64.UInt64.
unsignedInt UInt32.UInt32.
unsignedShort UInt16.UInt16.
unsignedByte Byte.Byte.
positiveInteger Int64Int64.

Zuordnung von ISerializable-TypenISerializable types mapping

In .NET Framework.NET Framework Version&#160;1.0 wurde ISerializable als ein allgemeiner Mechanismus für die Serialisierung von Objekten für persistente Speicherung oder die Datenübertragung eingeführt.In .NET Framework.NET Framework version 1.0, ISerializable was introduced as a general mechanism to serialize objects for persistence or data transfer. Es gibt viele .NET Framework.NET Framework -Typen, die ISerializable implementieren und zwischen Anwendungen übergeben werden können.There are many .NET Framework.NET Framework types that implement ISerializable and that can be passed between applications. DataContractSerializer unterstützt von sich aus ISerializable -Klassen.DataContractSerializer naturally provides support for ISerializable classes. Der DataContractSerializer ordnet ISerializable-Implementierungsschematypen zu, die sich nur durch den qualifizierten Namen (QName) des Typs unterscheiden und tatsächlich Eigenschaftenauflistungen sind.The DataContractSerializer maps ISerializable implementation schema types that differ only by the QName (qualified name) of the type and are effectively property collections. Zum Beispiel ordnet der DataContractSerializer Exception dem folgenden XSD-Typ im Namespace http://schemas.datacontract.org/2004/07/System zu.For example, the DataContractSerializer maps Exception to the following XSD type in the http://schemas.datacontract.org/2004/07/System namespace.

<xs:complexType name="Exception">  
 <xs:sequence>  
  <xs:any minOccurs="0" maxOccurs="unbounded"   
      namespace="##local" processContents="skip"/>  
 </xs:sequence>  
 <xs:attribute ref="ser:FactoryType"/>  
</xs:complexType>  

Das optionale, im Serialisierungsschema des Datenvertrags deklarierte Attribut ser:FactoryType verweist auf eine Factoryklasse, die den Typ deserialisieren kann.The optional attribute ser:FactoryType declared in the Data Contract Serialization schema references a factory class that can deserialize the type. Die Factoryklasse muss Teil der Auflistung bekannter Typen der verwendeten DataContractSerializer -Instanz sein.The factory class must be part of the known types collection of the DataContractSerializer instance being used. Weitere Informationen finden Sie unterFor more information about zu bekannten Typen finden Sie unter Data Contract Known Typesexportiert werden. known types, see Data Contract Known Types.

DataContract-SerialisierungsschemaDataContract Serialization Schema

Eine Anzahl der vom DataContractSerializer exportierten Schemas verwendet Typen, Elemente und Attribute eines speziellen Datenvertrags-Serialisierungsnamespace:A number of schemas exported by the DataContractSerializer use types, elements, and attributes from a special Data Contract Serialization namespace:

http://schemas.microsoft.com/2003/10/Serializationhttp://schemas.microsoft.com/2003/10/Serialization

Das Folgende ist eine vollständige Schemadeklaration für die Datenvertragsserialisierung.The following is a complete Data Contract Serialization schema declaration.

<xs:schema attributeFormDefault="qualified"          
   elementFormDefault="qualified"        
   targetNamespace =   
    "http://schemas.microsoft.com/2003/10/Serialization/"   
   xmlns:xs="http://www.w3.org/2001/XMLSchema"        
   xmlns:tns="http://schemas.microsoft.com/2003/10/Serialization/">  

 <!-- Top-level elements for primitive types. -->  
 <xs:element name="anyType" nillable="true" type="xs:anyType"/>  
 <xs:element name="anyURI" nillable="true" type="xs:anyURI"/>  
 <xs:element name="base64Binary"  
       nillable="true" type="xs:base64Binary"/>  
 <xs:element name="boolean" nillable="true" type="xs:boolean"/>  
 <xs:element name="byte" nillable="true" type="xs:byte"/>  
 <xs:element name="dateTime" nillable="true" type="xs:dateTime"/>  
 <xs:element name="decimal" nillable="true" type="xs:decimal"/>  
 <xs:element name="double" nillable="true" type="xs:double"/>  
 <xs:element name="float" nillable="true" type="xs:float"/>  
 <xs:element name="int" nillable="true" type="xs:int"/>  
 <xs:element name="long" nillable="true" type="xs:long"/>  
 <xs:element name="QName" nillable="true" type="xs:QName"/>  
 <xs:element name="short" nillable="true" type="xs:short"/>  
 <xs:element name="string" nillable="true" type="xs:string"/>  
 <xs:element name="unsignedByte"  
       nillable="true" type="xs:unsignedByte"/>  
 <xs:element name="unsignedInt"  
       nillable="true" type="xs:unsignedInt"/>  
 <xs:element name="unsignedLong"  
       nillable="true" type="xs:unsignedLong"/>  
 <xs:element name="unsignedShort"  
       nillable="true" type="xs:unsignedShort"/>  

 <!-- Primitive types introduced for certain .NET simple types. -->  
 <xs:element name="char" nillable="true" type="tns:char"/>  
 <xs:simpleType name="char">  
  <xs:restriction base="xs:int"/>  
 </xs:simpleType>  

 <!-- xs:duration is restricted to an ordered value space,  
    to map to System.TimeSpan -->  
 <xs:element name="duration" nillable="true" type="tns:duration"/>  
 <xs:simpleType name="duration">  
  <xs:restriction base="xs:duration">  
   <xs:pattern   
     value="\-?P(\d*D)?(T(\d*H)?(\d*M)?(\d*(\.\d*)?S)?)?"/>  
   <xs:minInclusive value="-P10675199DT2H48M5.4775808S"/>  
   <xs:maxInclusive value="P10675199DT2H48M5.4775807S"/>  
  </xs:restriction>  
 </xs:simpleType>  

 <xs:element name="guid" nillable="true" type="tns:guid"/>  
 <xs:simpleType name="guid">  
  <xs:restriction base="xs:string">  
   <xs:pattern value="[\da-fA-F]{8}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{12}"/>  
  </xs:restriction>  
 </xs:simpleType>  

 <!-- This is used for schemas exported from ISerializable type. -->  
 <xs:attribute name="FactoryType" type="xs:QName"/>  
</xs:schema>  

Auf Folgendes sollte geachtet werden:The following should be noted:

  • ser:char wurde eingeführt, um Unicode-Zeichen des Typs Chardarzustellen.ser:char is introduced to represent Unicode characters of type Char.

  • Der valuespace von xs:duration wurde zu einer geordneten Menge reduziert, damit diese einem TimeSpanzugeordnet werden kann.The valuespace of xs:duration is reduced to an ordered set so that it can be mapped to a TimeSpan.

  • FactoryType wird in Schemas verwendet, die von Typen exportiert werden, die von ISerializableabgeleitet wurden.FactoryType is used in schemas exported from types that are derived from ISerializable.

Importieren von Nicht-DataContract-SchemasImporting non-DataContract schemas

DataContractSerializer verfügt über die ImportXmlTypes -Option, die den Import von Schemas erlaubt, die dem DataContractSerializer -XSD-Profil nicht entsprechen (siehe die Options -Eigenschaft).DataContractSerializer has the ImportXmlTypes option to allow import of schemas that do not conform to the DataContractSerializer XSD profile (see the Options property). Die Festlegung dieser Option auf true aktiviert die Akzeptanz nicht-konformer Schematypen und ihre Zuordnung zu der folgenden Implementierung, wobei IXmlSerializable ein Array von XmlNode einschließt (nur der Klassenname unterscheidet sich).Setting this option to true enables acceptance of non-conforming schema types and mapping them to the following implementation, IXmlSerializable wrapping an array of XmlNode (only the class name differs).

[GeneratedCodeAttribute("System.Runtime.Serialization", "3.0.0.0")]  
[System.Xml.Serialization.XmlSchemaProviderAttribute("ExportSchema")]  
[System.Xml.Serialization.XmlRootAttribute(IsNullable=false)]  
public partial class Person : object, IXmlSerializable  
{    
  private XmlNode[] nodesField;    
  private static XmlQualifiedName typeName =   
new XmlQualifiedName("Person","http://Microsoft.ServiceModel.Samples");    
  public XmlNode[] Nodes  
  {  
    get {return this.nodesField;}  
    set {this.nodesField = value;}  
  }    
  public void ReadXml(XmlReader reader)  
  {  
    this.nodesField = XmlSerializableServices.ReadNodes(reader);  
  }    
  public void WriteXml(XmlWriter writer)  
  {  
    XmlSerializableServices.WriteNodes(writer, this.Nodes);  
  }    
  public System.Xml.Schema.XmlSchema GetSchema()  
  {  
    return null;  
  }    
  public static XmlQualifiedName ExportSchema(XmlSchemaSet schemas)  
  {  
    XmlSerializableServices.AddDefaultSchema(schemas, typeName);  
    return typeName;  
  }  
}  

DateTimeOffset-SerialisierungDateTimeOffset Serialization

DateTimeOffset wird nicht als primitiver Typ behandelt.The DateTimeOffset is not treated as a primitive type. Stattdessen wird dieser Typ als komplexes Element mit zwei Teilen serialisiert.Instead, it is serialized as a complex element with two parts. Der erste Teil stellt die Datums- und Uhrzeitangabe dar und der zweite Teil den Offset dieser Datums- und Uhrzeitangabe.The first part represents the date time, and the second part represents the offset from the date time. Ein Beispiel für einen serialisierten DateTimeOffset-Wert wird im folgenden Code gezeigt.An example of a serialized DateTimeOffset value is shown in the following code.

<OffSet xmlns:a="http://schemas.datacontract.org/2004/07/System">  
  <DateTime i:type="b:dateTime" xmlns=""   
    xmlns:b="http://www.w3.org/2001/XMLSchema">2008-08-28T08:00:00    
  </DateTime>   
  <OffsetMinutes i:type="b:short" xmlns=""   
   xmlns:b="http://www.w3.org/2001/XMLSchema">-480  
   </OffsetMinutes>   
</OffSet>  

Das Schema lautet folgendermaßen:The schema is as follows.

<xs:schema targetNamespace="http://schemas.datacontract.org/2004/07/System">  
   <xs:complexType name="DateTimeOffset">  
      <xs:sequence minOccurs="1" maxOccurs="1">  
         <xs:element name="DateTime" type="xs:dateTime"  
         minOccurs="1" maxOccurs="1" />  
         <xs:elementname="OffsetMinutes" type="xs:short"  
         minOccurs="1" maxOccurs="1" />  
      </xs:sequence>  
   </xs:complexType>  
</xs:schema>  

Siehe auchSee Also

DataContractSerializer
DataContractAttribute
DataMemberAttribute
XsdDataContractImporter
Verwenden von DatenverträgenUsing Data Contracts