Datenvertrags-Schemareferenz

Artikel
02/27/2011

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.

DataContractSerializer-Zuordnungen

Der DataContractSerializer ordnet CLR-Typen XSD zu, wenn Metadaten von einem Windows Communication Foundation (WCF)-Dienst mithilfe eines Metadatenendpunkts oder dem ServiceModel Metadata Utility-Tool (Svcutil.exe) exportiert werden. Weitere Informationen finden Sie unter 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.

Nur XML-Schemainstanzen, die den in diesem Dokument beschriebenen Anforderungen entsprechen, können mit DataContractSerializer CLR-Typen zugeordnet werden.

Unterstützungsebenen

Der DataContractSerializer stellt die folgenden Unterstützungsebenen für eine gegebene XML-Schemafunktion bereit:

Unterstützt. Es gibt eine explizite Zuordnung dieser Funktion zu CLR-Typen oder -Attributen (oder beiden) mit DataContractSerializer.
Ignoriert. Die Funktion ist in vom DataContractSerializer importierten Schemas zugelassen, hat aber keine Auswirkungen auf die Codegenerierung.
Unzulässig. Der DataContractSerializer unterstützt nicht den Import eines Schemas, das diese Funktion verwendet. Svcutil.exe verwendet beispielsweise wieder den XmlSerializer, wenn auf ein WSDL mit einem Schema zugegriffen wird, das eine solche Funktion verwendet. Dies ist das Standardverhalten.

Allgemeine Informationen

Der Schemanamespace wird unter XML-Schema (Seite möglicherweise auf Englisch) beschrieben. In diesem Dokument wird das Präfix "xs" verwendet.
Alle Attribute mit einem Nicht-Schema-Namespace werden ignoriert.
Alle Anmerkungen (außer den in diesem Dokument beschriebenen) werden ignoriert.

<xs:schema>: Attribute

Attribut	DataContract
attributeFormDefault	Ignoriert.
blockDefault	Ignoriert.
elementFormDefault	Muss qualifiziert sein. Damit ein Schema vom DataContractSerializer unterstützt wird, müssen alle Elemente qualifiziert werden. Dies kann erreicht werden, indem bei jeder einzelnen Elementdeklaration entweder xs:schema/@elementFormDefault auf "qualified" oder xs:element/@form auf "qualified" festgelegt wird.
finalDefault	Ignoriert.
Id	Ignoriert.
targetNamespace	Unterstützt und wird dem Datenvertragsnamespace zugeordnet. Wenn dieses Attribut nicht angegeben ist, wird ein leerer Namespace verwendet. Dies darf nicht der reservierte Namespace https://schemas.microsoft.com/2003/10/Serialization sein.
version	Ignoriert.

<xs:schema>: Inhalt

Inhalt	Schema
include	Unterstützt. DataContractSerializer unterstützt xs:include und 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. Die Liste der Schemadateien muss in diesem Fall über einen Out-of-Band-Mechanismus und nicht mittels include übergeben werden. Mit include angegebene Schemadokumente werden ignoriert.
redefine	Unzulässig. Die Verwendung von xs:redefine durch DataContractSerializer ist aus Sicherheitsgründen unzulässig: x:redefine erfordert, dass schemaLocation befolgt wird. Unter bestimmten Umständen schränkt Svcutil.exe mit DataContract die Verwendung von schemaLocation ein.
import	Unterstützt. DataContractSerializer unterstützt xs:include und 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. Die Liste der Schemadateien muss in diesem Fall über einen Out-of-Band-Mechanismus und nicht mittels include übergeben werden. Mit include angegebene Schemadokumente werden ignoriert.
simpleType	Unterstützt. Siehe den Abschnitt xs:simpleType.
complexType	Unterstützt, wird Datenverträgen zugeordnet. Siehe den Abschnitt xs:complexType.
group	Ignoriert. DataContractSerializer unterstützt die Verwendung von xs:group, xs:attributeGroup und xs:attribute nicht. Diese Deklarationen werden als untergeordnete Elemente von xs:schema ignoriert, auf sie kann jedoch nicht innerhalb von complexType oder anderer unterstützter Konstrukte verwiesen werden.
attributeGroup	Ignoriert. DataContractSerializer unterstützt die Verwendung von xs:group, xs:attributeGroup und xs:attribute nicht. Diese Deklarationen werden als untergeordnete Elemente von xs:schema ignoriert; auf sie kann jedoch nicht innerhalb von complexType oder anderer unterstützter Konstrukte verwiesen werden.
element	Unterstützt. Siehe Globale Elementdeklaration (GED).
attribute	Ignoriert. DataContractSerializer unterstützt die Verwendung von xs:group, xs:attributeGroup und xs:attribute nicht. Diese Deklarationen werden als untergeordnete Elemente von xs:schema ignoriert; auf sie kann jedoch nicht innerhalb von complexType oder anderer unterstützter Konstrukte verwiesen werden.
notation	Ignoriert.

Komplexe Typen – <xs:complexType>

Allgemeine Informationen

Jeder komplexe Typ <xs:complexType> wird einem Datenvertrag zugeordnet.

<xs:complexType>: Attribute

Attribut	Schema
abstract	Muss den Wert false aufweisen (Standardwert)
block	Unzulässig.
final	Ignoriert.
id	Ignoriert.
mixed	Muss den Wert false aufweisen (Standardwert)
name	Unterstützt. Wird dem Namen des Datenvertrags zugeordnet. Wenn der Name Punkte enthält, wird versucht, den Typ einem inneren Typ zuzuordnen. Beispielsweise wird ein komplexer Typ namens A.B einem Datenvertragstyp zugeordnet, der ein innerer Typ mit dem Datenvertragsnamen A ist. Dies geschieht jedoch nur dann, wenn ein solcher Datenvertragstyp vorhanden ist. Es ist mehr als eine Verschachtelungsebene möglich: A.B.C z. B. kann ein innerer Typ sein, jedoch nur dann, wenn sowohl A als auch A.B vorhanden sind.

<xs:complexType>: Inhalt

Inhalt	Schema
simpleContent	Erweiterungen sind unzulässig. Einschränkung wird nur von anySimpleType zugelassen.
complexContent	Unterstützt. Siehe "Vererbung".
group	Unzulässig.
all	Unzulässig.
choice	Unzulässig
sequence	Unterstützt, wird Datenmembern eines Datenvertrags zugeordnet.
attribute	Unzulässig, auch wenn use="prohibited" (mit einer Ausnahme). Nur optionale Attribute aus dem Standardserialisierungsschema-Namespace werden unterstützt. Sie werden Datenmembern im Datenvertragsprogrammiermodell nicht zugeordnet. Aktuell hat nur ein solches Attribut Bedeutung, es wird im Abschnitt ISerializable erläutert. Alle anderen werden ignoriert.
attributeGroup	Unzulässig. In Version 1 von WCF ignoriert DataContractSerializer das Vorhandensein von attributeGroup in xs:complexType.
anyAttribute	Unzulässig.
(leer)	Wird einem Datenvertrag ohne Datenmember zugeordnet.

<xs:sequence> in einem komplexen Typ: Attribute

Attribut	Schema
id	Ignoriert.
maxOccurs	Muss 1 (Standard) sein.
minOccurs	Muss 1 (Standard) sein.

<xs:sequence> in einem komplexen Typ: Inhalt

Inhalt	Schema
element	Jede Instanz wird einem Datenmember zugeordnet.
group	Unzulässig.
choice	Unzulässig.
sequence	Unzulässig.
any	Unzulässig.
(leer)	Wird einem Datenvertrag ohne Datenmember zugeordnet.

Elemente – <xs:element>

Allgemeine Informationen

<xs:element> kann in den folgenden Kontexten auftreten:

Es kann innerhalb eines <xs:sequence>-Elements auftreten, das einen Datenmember eines regulären Datenvertrags (keines Auflistungsdatenvertrags) beschreibt. In diesem Fall muss das maxOccurs-Attribut 1 sein. (Der Wert 0 ist nicht zulässig.)
Es kann innerhalb eines <xs:sequence>-Elements auftreten, das einen Datenmember eines Auflistungsdatenvertrags beschreibt. In diesem Fall muss der Wert des maxOccurs-Attributs größer 1 oder "unbounded" sein.
Es kann innerhalb eines <xs:schema>-Elements als eine globale Elementdeklaration (GED) auftreten.

<xs:element> mit maxOccurs=1 innerhalb eines <xs:sequence>-Elements (Datenmember)

Attribut	Schema
ref	Unzulässig.
name	Unterstützt, wird dem Datenmembernamen zugeordnet.
type	Unterstützt, wird dem Datenmembertyp zugeordnet. Weitere Informationen finden Sie unter Zuordnung von Typen zu primitivem Typen. Wenn nicht angegeben (und wenn das Element keinen anonymen Typ enthält), wird xs:anyType angenommen.
block	Ignoriert.
default	Unzulässig.
fixed	Unzulässig.
form	Muss qualifiziert sein. Dieses Attribut kann über elementFormDefault auf xs:schema festgelegt werden.
id	Ignoriert.
maxOccurs	1
minOccurs	Wird der IsRequired-Eigenschaft eines Datenmembers zugeordnet (IsRequired hat den Wert true, wenn minOccurs 1 ist).
nillable	Beeinflusst die Typzuordnung. Siehe Zuordnung von Typen zu primitivem Typen.

<xs:element> mit maxOccurs>1 innerhalb eines <xs:sequence>-Elements (Auflistungen)

Wird einem CollectionDataContractAttribute zugeordnet.
In Auflistungstypen ist nur ein xs:element innerhalb eines xs:sequence-Elements zugelassen.

Auflistungen können einen der folgenden Typen aufweisen:

Reguläre Auflistungen (z. B. Arrays).
Wörterbuchauflistungen (die einen Wert einem anderen zuordnen, z. B. eine Hashtable).

Der einzige Unterschied zwischen einem Wörterbuchtyp und einem Array mit Schlüssel-Wert-Paaren liegt im generierten Programmiermodell. Es gibt einen Schemaanmerkungsmechanismus, der verwendet werden kann, um anzugeben, dass ein bestimmter Typ eine Wörterbuchauflistung ist.

Die Regeln für die Attribute ref, block, default, fixed, form und id sind die gleichen wie für diejenigen, die keine Auflistungstypen sind. Die anderen Attribute sind in der folgenden Tabelle aufgeführt:

Attribut	Schema
name	Unterstützt, wird der ItemName-Eigenschaft des CollectionDataContractAttribute-Attributs zugeordnet.
type	Unterstützt, wird dem in der Auflistung gespeicherten Typ zugeordnet.
maxOccurs	Größer 1 oder "unbounded". Das DC-Schema sollte "unbounded" verwenden.
minOccurs	Ignoriert.
nillable	Beeinflusst die Typzuordnung. Dieses Attribut wird für Wörterbuchauflistungen ignoriert.

<xs:element> innerhalb einer globalen Elementdeklaration <xs:schema>

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.
Schemaexport: Für alle generierten Typen, sowohl einfache als auch komplexe, werden zugeordnete GEDs generiert.
Deserialisierung/Serialisierung: Zugeordnete GEDs werden als Stammelemente für den Typ verwendet.
Schemaimport: Zugeordnete GEDs sind nicht erforderlich und werden ignoriert, wenn sie den folgenden Regeln entsprechen (es sei denn, sie definieren Typen).

Attribut	Schema
abstract	Muss für zugeordnete GEDs den Wert false aufweisen.
block	Unzulässig in zugeordneten GEDs.
default	Unzulässig in zugeordneten GEDs.
final	Muss für zugeordnete GEDs den Wert false aufweisen.
fixed	Unzulässig in zugeordneten GEDs.
id	Ignoriert.
name	Unterstützt. Siehe die Definition von zugeordneten GEDs.
nillable	Muss für zugeordnete GEDs den Wert true aufweisen.
substitutionGroup	Unzulässig in zugeordneten GEDs.
type	Unterstützt. Muss dem zugeordneten Typ für zugeordnete GEDs entsprechen (außer wenn das Element einen anonymen Typ enthält).

<xs:element>: Inhalt

Inhalt	Schema
simpleType	Unterstützt.*
complexType	Unterstützt.*
unique	Ignoriert.
key	Ignoriert.
keyref	Ignoriert.
(leer)	Unterstützt.

* Werden simpleType und verwendet, ist die Zuordnung von anonymen Typen dieselbe wie für nicht anonyme Typen, mit der Ausnahme, dass es keine anonymen Datenverträge gibt, weshalb ein benannter Datenvertrag erstellt wird, dessen generierter Name von dem Elementnamen abgeleitet wird. Die folgende Liste enthält die Regeln für anonyme Typen:

WCF-Implementierungsdetail: Wenn der xs:element-Name keine Punkte enthält, wird der anonyme Typ einem inneren Typ des äußeren Datenvertragstyps zugeordnet. Wenn der Name Punkte enthält, ist der resultierende Datenvertragstyp unabhängig (kein innerer Typ).
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".
Ist ein Datenvertrag mit diesem Namen bereits vorhanden, wird dem Namen "1", "2", "3" usw. angehängt, um ihn eindeutig zu machen.

Einfache Typen – <xs:simpleType>

<xs:simpleType>: Attribute

Attribut	Schema
final	Ignoriert.
id	Ignoriert.
name	Unterstützt, wird dem Namen des Datenvertrags zugeordnet.

<xs:simpleType>: Inhalt

Inhalt	Schema
restriction	Unterstützt. Wird Enumerationsdatenverträgen zugeordnet. Dieses Attribut wird ignoriert, wenn es nicht zum Enumerationsmuster passt. Siehe den Abschnitt xs:simpleType-Einschränkungen.
list	Unterstützt. Wird Flagenumerationsdatenverträgen zugeordnet. Siehe den Abschnitt xs:simpleType-Listen.
union	Unzulässig.

<xs:restriction>

Einschränkungen komplexer Typen werden nur für base="xs:anyType" unterstützt.
Einfache Typeinschränkungen von xs:string, die keine anderen Einschränkungsfacets als xs:enumeration haben, werden Enumerationsdatenverträgen zugeordnet.
Alle anderen einfachen Typeinschränkungen werden den Typen zugeordnet, die sie einschränken. Beispielsweise wird eine Einschränkung von xs:int einem Integertyp zugeordnet, wie es auch xs:int selbst tut. Weitere Informationen über zur Zuordnung primitiver Typen finden Sie unter "Zuordnung von Typen zu primitivem Typen".

<xs:restriction>: Attribute

Attribut	Schema
base	Muss ein unterstützter einfacher Typ oder xs:anyType sein.
id	Ignoriert.

<xs:restriction> für alle anderen Fälle: Inhalt

Inhalt	Schema
simpleType	Muss, falls vorhanden, von einem unterstützten primitiven Typ abgeleitet sein.
minExclusive	Ignoriert.
minInclusive	Ignoriert.
maxExclusive	Ignoriert.
maxInclusive	Ignoriert.
totalDigits	Ignoriert.
fractionDigits	Ignoriert.
length	Ignoriert.
minLength	Ignoriert.
maxLength	Ignoriert.
enumeration	Ignoriert.
whiteSpace	Ignoriert.
pattern	Ignoriert.
(leer)	Unterstützt.

Enumeration

<xs:restriction> für Enumerationen: Attribute

Attribut	Schema
base	Muss, falls vorhanden, xs:string sein.
id	Ignoriert.

<xs:restriction> für Enumerationen: Inhalt

Inhalt	Schema
simpleType	Muss, falls vorhanden, eine vom Datenvertrag (dieser Abschnitt) unterstützte Enumerationsbeschränkung sein.
minExclusive	Ignoriert.
minInclusive	Ignoriert.
maxExclusive	Ignoriert.
maxInclusive	Ignoriert.
totalDigits	Ignoriert.
fractionDigits	Ignoriert.
length	Unzulässig.
minLength	Unzulässig.
maxLength	Unzulässig.
enumeration	Unterstützt. Enumerations-"ID" wird ignoriert, und "value" wird dem Wertnamen im Enumerationsdatenvertrag zugeordnet.
whiteSpace	Unzulässig.
pattern	Unzulässig.
(leer)	Unterstützt, wird leerem Enumerationstyp zugeordnet.

Der folgende Code zeigt eine C#-Enumerationsklasse.

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

}

Diese Klasse wird vom DataContractSerializer dem folgenden Schema zugeordnet. Wenn die Enumerationswerte mit 1 beginnen, werden keine xs:annotation-Blöcke generiert.

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

<xs:list>

DataContractSerializer ordnet mit System.FlagsAttribute markierte Enumerationstypen einer von xs:string abgeleiteten xs:list zu. Andere xs:list-Variationen werden nicht unterstützt.

<xs:list>: Attribute

Attribut	Schema
itemType	Unzulässig.
id	Ignoriert.

<xs:list>: Inhalt

Inhalt	Schema
simpleType	Muss eine Einschränkung von xs:string mit xs:enumeration-Facet sein.

Sind die Enumerationswerte keine Folge mit Potenzen des Werts 2 (für Flags der Standard), wird der Wert im xs:annotation/xs:appInfo/ser:EnumerationValue-Element gespeichert.

Der folgende Code definiert z. B. einen Enumerationstyp für Flags.

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

Dieser Typ wird dem folgenden Schema zugeordnet.

<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="https://schemas.microsoft.com/2003/10/Se
rialization/">16</EnumerationValue>
              </xs:appinfo>
            </xs:annotation>
          </xs:enumeration>
          <xs:enumeration value="AuthPassport">
            <xs:annotation>
              <xs:appinfo>
                <EnumerationValue xmlns="https://schemas.microsoft.com/2003/10/Se
rialization/">64</EnumerationValue>
              </xs:appinfo>
            </xs:annotation>
          </xs:enumeration>
        </xs:restriction>
      </xs:simpleType>
    </xs:list>
  </xs:simpleType>

Vererbung

Allgemeine Regeln

Ein Datenvertrag kann von einem anderen Datenvertrag erben. Solche Datenverträge werden einem Basistyp zugeordnet und durch Erweiterungstypen mithilfe des <xs:extension>-XML-Schemakonstrukts abgeleitet.

Ein Datenvertrag kann nicht von einem Auflistungsdatenvertrag erben.

Der folgende Code stellt z. B. einen Datenvertrag dar.

[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.

<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>

<xs:complexContent>: Attribute

Attribut	Schema
id	Ignoriert.
mixed	Muss den Wert false aufweisen.

<xs:complexContent>: Inhalt

Inhalt	Schema
restriction	Unzulässig, außer wenn base="xs:anyType". Letzteres entspricht der Platzierung des Inhalts von xs:restriction direkt unter den Container von xs:complexContent.
extension	Unterstützt. Wird der Datenvertragsvererbung zugeordnet.

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

Attribut	Schema
id	Ignoriert.
base	Unterstützt. Wird dem Basisdatenvertragstyp zugeordnet, von dem dieser Typ erbt.

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

Die Regeln sind die gleichen wie für den <xs:complexType>-Inhalt.

Wird <xs:sequence> angegeben, werden dessen Memberelemente den zusätzlichen Datenmembern zugeordnet, die im abgeleiteten Datenvertrag vorhanden sind.

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. Dazu werden dem Datenmember so lange positive Ganzzahlen hinzugefügt ("member1", "member2" usw.), bis ein eindeutiger Name gefunden ist. Umgekehrt:

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.
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. Der ursprüngliche Typname wird in xs:annotations/xs:appInfo/ser:ActualType/@Name beibehalten.

Beide Variationen können zu einem Schema mit einem mehrdeutigen Inhaltsmodell führen, das von der Reihenfolge der jeweiligen Datenmember abhängt.

Zuordnung von Typen zu primitivem Typen

Der DataContractSerializer verwendet die folgende Zuordnung für primitive Typen von XML-Schemas.

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

Zuordnung von ISerializable-Typen

In .NET Framework Version 1.0 wurde ISerializable als ein allgemeiner Mechanismus für die Serialisierung von Objekten für persistente Speicherung oder die Datenübertragung eingeführt. Es gibt viele .NET Framework-Typen, die ISerializable implementieren und zwischen Anwendungen übergeben werden können. Natürlich bietet der DataContractSerializer Unterstützung für ISerializable-Klassen. Der DataContractSerializer ordnet ISerializable-Implementierungsschematypen zu, die sich nur durch den qualifizierten Namen (QName) des Typs unterscheiden und tatsächlich Eigenschaftenauflistungen sind. Zum Beispiel ordnet der DataContractSerializer Exception dem folgenden XSD-Typ im Namespace http://schemas.datacontract.org/2004/07/System zu.

<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. Die Factoryklasse muss Teil der Auflistung bekannter Typen der verwendeten DataContractSerializer-Instanz sein. Weitere Informationen über zu bekannten Typen finden Sie unter Bekannte Typen in Datenverträgen.

DataContract-Serialisierungsschema

Eine Anzahl der vom DataContractSerializer exportierten Schemas verwendet Typen, Elemente und Attribute eines speziellen Datenvertrags-Serialisierungsnamespace:

https://schemas.microsoft.com/2003/10/Serialization

Das Folgende ist eine vollständige Schemadeklaration für die Datenvertragsserialisierung.

<xs:schema attributeFormDefault="qualified"        
   elementFormDefault="qualified"      
   targetNamespace = 
    "https://schemas.microsoft.com/2003/10/Serialization/" 
   xmlns:xs="http://www.w3.org/2001/XMLSchema"      
   xmlns:tns="https://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:

ser:char wurde eingeführt, um Unicode-Zeichen des Typs Char darzustellen.
Der valuespace von xs:duration wurde zu einer geordneten Menge reduziert, damit diese einem TimeSpan zugeordnet werden kann.
FactoryType wird in Schemas verwendet, die von Typen exportiert werden, die von ISerializable abgeleitet wurden.

Importieren von Nicht-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). 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).

[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-Serialisierung

DateTimeOffset wird nicht als primitiver Typ behandelt. Stattdessen wird dieser Typ als komplexes Element mit zwei Teilen serialisiert. Der erste Teil stellt die Datums- und Uhrzeitangabe dar und der zweite Teil den Offset dieser Datums- und Uhrzeitangabe. Ein Beispiel für einen serialisierten DateTimeOffset-Wert wird im folgenden Code gezeigt.

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

Das Schema lautet folgendermaßen:

<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 auch

Verweis

DataContractSerializer
DataContractAttribute
DataMemberAttribute
XsdDataContractImporter

Konzepte

Verwenden von Datenverträgen

Freigeben über

Datenvertrags-Schemareferenz

DataContractSerializer-Zuordnungen

Unterstützungsebenen

Allgemeine Informationen

<xs:schema>: Attribute

<xs:schema>: Inhalt

Komplexe Typen – <xs:complexType>

Allgemeine Informationen

<xs:complexType>: Attribute

<xs:complexType>: Inhalt

<xs:sequence> in einem komplexen Typ: Attribute

<xs:sequence> in einem komplexen Typ: Inhalt

Elemente – <xs:element>

Allgemeine Informationen

<xs:element> mit maxOccurs=1 innerhalb eines <xs:sequence>-Elements (Datenmember)

<xs:element> mit maxOccurs>1 innerhalb eines <xs:sequence>-Elements (Auflistungen)

<xs:element> innerhalb einer globalen Elementdeklaration <xs:schema>

<xs:element>: Inhalt

Einfache Typen – <xs:simpleType>

<xs:simpleType>: Attribute

<xs:simpleType>: Inhalt

<xs:restriction>

<xs:restriction>: Attribute

<xs:restriction> für alle anderen Fälle: Inhalt

Enumeration

<xs:restriction> für Enumerationen: Attribute

<xs:restriction> für Enumerationen: Inhalt

<xs:list>

<xs:list>: Attribute

<xs:list>: Inhalt

Vererbung

Allgemeine Regeln

<xs:complexContent>: Attribute

<xs:complexContent>: Inhalt

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

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

Zuordnung von Typen zu primitivem Typen

Zuordnung von ISerializable-Typen

DataContract-Serialisierungsschema

Importieren von Nicht-DataContract-Schemas

DateTimeOffset-Serialisierung

Siehe auch

Verweis

Konzepte

Zusätzliche Ressourcen