Freigeben über

Datenvertrags-Schemareferenz

  • Artikel

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)

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