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 WCF-Dienst (Windows Communication Foundation) mithilfe eines Metadatenendpunkts oder mit dem ServiceModel Metadata Utility-Tool (Svcutil.exe) exportiert werden. Weitere Informationen finden Sie unter Serialisierungsmodul für Datenvertrag.

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 DataContractSerializerCLR-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 DataContractSerializerimportierten 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 die Standardeinstellung.

Allgemeine Informationen

  • Der Schemanamespace wird unter XML-Schemabeschrieben. 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

attribute DataContract
attributeFormDefault Ignoriert.
blockDefault Ignoriert.
elementFormDefault Muss qualifiziert sein. Damit ein Schema vom DataContractSerializerunterstü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. Darf nicht der reservierte Namespace http://schemas.microsoft.com/2003/10/Serialization/ sein.
version Ignoriert.

<xs:schema>: Inhalt

Inhalte 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 includeangegebene 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 schemaLocationein.
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 includeangegebene 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 bietet keine Unterstützung für xs:group, xs:attributeGroupund 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.
attributeGroup Ignoriert. DataContractSerializer bietet keine Unterstützung für xs:group, xs:attributeGroupund 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.
element Unterstützt. Siehe Globale Elementdeklaration (GED).
attribute Ignoriert. DataContractSerializer bietet keine Unterstützung für xs:group, xs:attributeGroupund 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.
notation Ignoriert.

Komplexe Typen: <xs:complexType>

Allgemeine Informationen

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

<xs:complexType>: Attribute

attribute 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 Aist. 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

Inhalte Schema
simpleContent Erweiterungen sind unzulässig.

Einschränkung wird nur von anySimpleTypezugelassen.
complexContent Unterstützt. Siehe "Vererbung".
group Unzulässig.
all Unzulässig.
choice Verboten
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. Inm Release WCF v1 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

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

<xs:sequence> in einem komplexen Typ: Inhalt

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

attribute 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:schemafestgelegt 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 einer <xs:sequence> (Sammlungen)

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, formund id sind die gleichen wie für diejenigen, die keine Auflistungstypen sind. Die anderen Attribute sind in der folgenden Tabelle aufgeführt:

attribute 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).

attribute 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

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

* Bei Verwendung der simpleType Und- und complexType, Zuordnung für anonyme Typen ist identisch mit nicht anonymen Typen, mit der Ausnahme, dass es keine Verträge für anonyme Daten gibt und daher ein benannter Datenvertrag erstellt wird, wobei ein generierter Name vom 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

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

<xs:simpleType>: Inhalt

Inhalte 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 Integer zugeordnet, wie es auch bei xs:int selbst der Fall ist. Weitere Informationen zur Zuordnung primitiver Typen finden Sie unter „Zuordnung von Typen zu primitivem Typen“.

<xs:restriction>: Attribute

attribute Schema
base Muss ein unterstützter einfacher Typ oder xs:anyTypesein.
id Ignoriert.

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

Inhalte 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

attribute Schema
base Muss, falls vorhanden, xs:stringsein.
id Ignoriert.

<xs:restriction> für Enumerationen: Inhalt

Inhalte 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 DataContractSerializerdem 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="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>

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

<xs:list>: Attribute

attribute Schema
itemType Unzulässig.
id Ignoriert.

<xs:list>: Inhalt

Inhalte 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,
  AuthWindowsLiveID = 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="http://schemas.microsoft.com/2003/10/Serialization/">16</EnumerationValue>
              </xs:appinfo>
            </xs:annotation>
          </xs:enumeration>
          <xs:enumeration value="AuthWindowsLiveID">
            <xs:annotation>
              <xs:appinfo>
                <EnumerationValue xmlns="http://schemas.microsoft.com/2003/10/Serialization/">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

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

<xs:complexContent>: Inhalt

Inhalte 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

attribute 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/@Namebeibehalten.

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

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

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

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

  • ser:char wurde eingeführt, um Unicode-Zeichen des Typs Chardarzustellen.

  • Der valuespace von xs:duration wurde zu einer geordneten Menge reduziert, damit diese einem TimeSpanzugeordnet werden kann.

  • FactoryType wird in Schemas verwendet, die von Typen exportiert werden, die von ISerializableabgeleitet 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=""
    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:

<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:element name="OffsetMinutes" type="xs:short"
         minOccurs="1" maxOccurs="1" />
      </xs:sequence>
   </xs:complexType>
</xs:schema>

Siehe auch