Odwołanie do schematu kontraktu danych

Artykuł
04/08/2023

W tym temacie opisano podzestaw schematu XML (XSD) używanego do DataContractSerializer opisywania typów środowiska uruchomieniowego języka wspólnego (CLR) na potrzeby serializacji XML.

Mapowania elementu DataContractSerializer

Typy DataContractSerializer CLR są mapowane na XSD, gdy metadane są eksportowane z usługi Windows Communication Foundation (WCF) przy użyciu punktu końcowego metadanych lub narzędzia ServiceModel Metadata Tool (Svcutil.exe). Aby uzyskać więcej informacji, zobacz Serializator kontraktu danych.

Mapuje DataContractSerializer również XSD na typy CLR, gdy Svcutil.exe jest używany do uzyskiwania dostępu do dokumentów WSDL (Web Services Description Language) lub XSD i generowania kontraktów danych dla usług lub klientów.

Tylko wystąpienia schematu XML zgodne z wymaganiami określonymi w tym dokumencie można mapować na typy CLR przy użyciu polecenia DataContractSerializer.

Poziomy obsługi

Zapewnia DataContractSerializer następujące poziomy obsługi dla danej funkcji schematu XML:

Obsługiwane. Istnieje jawne mapowanie z tej funkcji na typy lub atrybuty CLR (lub oba) przy użyciu polecenia DataContractSerializer.
Zignorowano. Funkcja jest dozwolona w schematach importowanych przez DataContractSerializerobiekt , ale nie ma wpływu na generowanie kodu.
Zabronione. Element DataContractSerializer nie obsługuje importowania schematu przy użyciu funkcji. Na przykład Svcutil.exe podczas uzyskiwania dostępu do WSDL przy użyciu schematu, który używa takiej funkcji, wraca do używania elementu XmlSerializer zamiast tego. Jest to domyślnie.

Informacje ogólne

Przestrzeń nazw schematu jest opisana w temacie Schemat XML. Prefiks "xs" jest używany w tym dokumencie.
Wszystkie atrybuty z przestrzenią nazw innych niż schemat są ignorowane.
Wszelkie adnotacje (z wyjątkiem adnotacji opisanych w tym dokumencie) są ignorowane.

<xs:schema>: atrybuty

Atrybut	Datacontract
`attributeFormDefault`	Ignorowane.
`blockDefault`	Ignorowane.
`elementFormDefault`	Musi być kwalifikowana. Wszystkie elementy muszą być kwalifikowane, aby schemat był obsługiwany przez program `DataContractSerializer`. Można to zrobić, ustawiając wartość xs:schema/@elementFormDefault na "kwalifikowaną" lub ustawiając wartość xs:element/@form na "kwalifikowaną" dla każdej indywidualnej deklaracji elementu.
`finalDefault`	Ignorowane.
`Id`	Ignorowane.
`targetNamespace`	Obsługiwane i mapowane na przestrzeń nazw kontraktu danych. Jeśli ten atrybut nie zostanie określony, zostanie użyta pusta przestrzeń nazw. Nie można być zarezerwowaną przestrzenią nazw `http://schemas.microsoft.com/2003/10/Serialization/`.
`version`	Ignorowane.

<xs:schema>: zawartość

Zawartość	Schemat
`include`	Obsługiwane. `DataContractSerializer` obsługuje xs:include i xs:import. Jednak Svcutil.exe ogranicza następujące `xs:include/@schemaLocation` i `xs:import/@location` odwołania, gdy metadane są ładowane z pliku lokalnego. Lista plików schematu musi być przekazywana przez mechanizm poza pasmem, a nie przez `include` ten przypadek; `include` Dokumenty schematu d są ignorowane.
`redefine`	Zakazane. Korzystanie z usługi `xs:redefine` jest zabronione ze `DataContractSerializer` względów bezpieczeństwa: `x:redefine` należy `schemaLocation` postępować zgodnie z wymaganiami. W pewnych okolicznościach Svcutil.exe korzystanie z usługi DataContract ogranicza użycie elementu `schemaLocation`.
`import`	Obsługiwane. `DataContractSerializer` program obsługuje i `xs:includexs:import`. Jednak Svcutil.exe ogranicza następujące `xs:include/@schemaLocation` i `xs:import/@location` odwołania, gdy metadane są ładowane z pliku lokalnego. Lista plików schematu musi być przekazywana przez mechanizm poza pasmem, a nie przez `include` ten przypadek; `include` Dokumenty schematu d są ignorowane.
`simpleType`	Obsługiwane. Zobacz sekcję `xs:simpleType` .
`complexType`	Obsługiwane, mapuje na kontrakty danych. Zobacz sekcję `xs:complexType` .
`group`	Ignorowane. `DataContractSerializer` nie obsługuje używania `xs:group`, `xs:attributeGroup`i `xs:attribute`. Te deklaracje są ignorowane jako elementy podrzędne elementu `xs:schema`, ale nie mogą być przywoływane z wewnątrz `complexType` lub innych obsługiwanych konstrukcji.
`attributeGroup`	Ignorowane. `DataContractSerializer` nie obsługuje używania `xs:group`, `xs:attributeGroup`i `xs:attribute`. Te deklaracje są ignorowane jako elementy podrzędne elementu `xs:schema`, ale nie mogą być przywoływane z wewnątrz `complexType` lub innych obsługiwanych konstrukcji.
`element`	Obsługiwane. Zobacz Deklarację elementu globalnego (GED).
`attribute`	Ignorowane. `DataContractSerializer` nie obsługuje używania `xs:group`, `xs:attributeGroup`i `xs:attribute`. Te deklaracje są ignorowane jako elementy podrzędne elementu `xs:schema`, ale nie mogą być przywoływane z wewnątrz `complexType` lub innych obsługiwanych konstrukcji.
`notation`	Ignorowane.

Typy złożone — <xs:complexType>

Informacje ogólne

Każdy typ <złożony xs:complexType> mapuje na kontrakt danych.

<xs:complexType>: atrybuty

Atrybut	Schemat
`abstract`	Musi być fałsz (wartość domyślna).
`block`	Zakazane.
`final`	Ignorowane.
`id`	Ignorowane.
`mixed`	Musi być fałsz (wartość domyślna).
`name`	Obsługiwane i mapowane na nazwę kontraktu danych. Jeśli w nazwie występują kropki, podjęto próbę zamapowania typu na typ wewnętrzny. Na przykład typ złożony o nazwie `A.B` mapuje na typ kontraktu danych, który jest typem wewnętrznym typu o nazwie `A`kontraktu danych, ale tylko wtedy, gdy istnieje taki typ kontraktu danych. Istnieje więcej niż jeden poziom zagnieżdżania: na przykład `A.B.C` może być typem wewnętrznym, ale tylko wtedy, gdy `A` i `A.B` oba te elementy istnieją.

<xs:complexType>: zawartość

Zawartość	Schemat
`simpleContent`	Rozszerzenia są zabronione. Ograniczenie jest dozwolone tylko z `anySimpleType`elementu .
`complexContent`	Obsługiwane. Zobacz "Dziedziczenie".
`group`	Zakazane.
`all`	Zakazane.
`choice`	Forbidden
`sequence`	Obsługiwane, mapuje na składowe danych kontraktu danych.
`attribute`	Zabronione, nawet jeśli use="zabronione" (z jednym wyjątkiem). Obsługiwane są tylko opcjonalne atrybuty z przestrzeni nazw schematu serializacji standardowej. Nie są mapować na elementy członkowskie danych w modelu programowania kontraktów danych. Obecnie tylko jeden taki atrybut ma znaczenie i jest omówiony w sekcji ISerializable. Wszystkie inne są ignorowane.
`attributeGroup`	Zakazane. W wersji WCF w wersji `DataContractSerializer` 1 ignoruje obecność wewnątrz `attributeGroupxs:complexType`elementu .
`anyAttribute`	Zakazane.
(puste)	Mapuje na kontrakt danych bez elementów członkowskich danych.

<xs:sequence> w typie złożonym: atrybuty

Atrybut	Schemat
`id`	Ignorowane.
`maxOccurs`	Musi mieć wartość 1 (wartość domyślna).
`minOccurs`	Musi mieć wartość 1 (wartość domyślna).

<xs:sequence> w typie złożonym: zawartość

Zawartość	Schemat
`element`	Każde wystąpienie mapuje na element członkowski danych.
`group`	Zakazane.
`choice`	Zakazane.
`sequence`	Zakazane.
`any`	Zakazane.
(puste)	Mapuje na kontrakt danych bez elementów członkowskich danych.

Elements — <xs:element>

Informacje ogólne

<xs:element> może wystąpić w następujących kontekstach:

Może wystąpić w ramach <xs:sequence>elementu , który opisuje element członkowski danych regularnego (niezwiązanego z zbieraniem) kontraktu danych. W takim przypadku maxOccurs atrybut musi mieć wartość 1. (Wartość 0 jest niedozwolona).
Może wystąpić w obiekcie <xs:sequence>, który opisuje element członkowski danych w umowie danych zbierania. W takim przypadku maxOccurs atrybut musi być większy niż 1 lub "bez ruchu".
Może wystąpić w ramach <xs:schema> deklaracji elementu globalnego (GED).

<xs:element> with maxOccurs=1 within an <xs:sequence> (Data Members)

Atrybut	Schemat
`ref`	Zakazane.
`name`	Obsługiwane, mapuje na nazwę elementu członkowskiego danych.
`type`	Obsługiwane, mapuje na typ elementu członkowskiego danych. Aby uzyskać więcej informacji, zobacz Mapowanie typów/pierwotnych. Jeśli nie zostanie określony (a element nie zawiera typu anonimowego), `xs:anyType` przyjmuje się założenie.
`block`	Ignorowane.
`default`	Zakazane.
`fixed`	Zakazane.
`form`	Musi być kwalifikowana. Ten atrybut można ustawić przy użyciu `elementFormDefault` elementu `xs:schema`.
`id`	Ignorowane.
`maxOccurs`	1
`minOccurs`	Mapuje na IsRequired właściwość elementu członkowskiego danych (`IsRequired` ma wartość true, gdy `minOccurs` ma wartość 1).
`nillable`	Wpływa na mapowanie typów. Zobacz Mapowanie typu/pierwotnego.

<xs:element> z wartością maxOccurs>1 w obrębie <xs:sequence> (kolekcje)

Mapuje na element CollectionDataContractAttribute.
W typach kolekcji tylko jeden element xs:element jest dozwolony w sekwencji xs:sequence.

Kolekcje mogą być następującymi typami:

Regularne kolekcje (na przykład tablice).
Kolekcje słowników (mapowanie jednej wartości na inną, na przykład ).Hashtable
Jedyną różnicą między słownikiem a tablicą typu pary klucz/wartość jest wygenerowany model programowania. Istnieje mechanizm adnotacji schematu, który może służyć do wskazania, że dany typ jest kolekcją słowników.

Reguły atrybutów ref, block, , defaultfixed, formi id są takie same jak w przypadku niezwiązanych z kolekcją. Inne atrybuty obejmują te w poniższej tabeli.

Atrybut	Schemat
`name`	Obsługiwane mapowanie na ItemName właściwość w atrybucie `CollectionDataContractAttribute` .
`type`	Obsługiwane mapowanie na typ przechowywany w kolekcji.
`maxOccurs`	Większe niż 1 lub "bez ruchu". Schemat kontrolera domeny powinien używać "bez ruchu".
`minOccurs`	Ignorowane.
`nillable`	Wpływa na mapowanie typów. Ten atrybut jest ignorowany dla kolekcji słowników.

<xs:element> w deklaracji elementu globalnego <xs:schema>

Deklaracja elementu globalnego (GED), która ma taką samą nazwę i przestrzeń nazw, jak typ w schemacie, lub definiuje anonimowy typ wewnątrz siebie, mówi się, że jest skojarzony z typem.
Eksport schematu: skojarzone dyski GED są generowane dla każdego wygenerowanego typu, zarówno prostego, jak i złożonego.
Deserializacja/serializacja: skojarzone dyski GED są używane jako elementy główne dla typu.
Importowanie schematu: skojarzone dyski GED nie są wymagane i są ignorowane, jeśli są zgodne z następującymi regułami (chyba że definiują typy).

Atrybut	Schemat
`abstract`	Musi być fałszem dla skojarzonych dysków GED.
`block`	Zabronione w skojarzonych gedach.
`default`	Zabronione w skojarzonych gedach.
`final`	Musi być fałszem dla skojarzonych dysków GED.
`fixed`	Zabronione w skojarzonych gedach.
`id`	Ignorowane.
`name`	Obsługiwane. Zobacz definicję skojarzonych dysków GED.
`nillable`	Musi mieć wartość true dla skojarzonych dysków GED.
`substitutionGroup`	Zabronione w skojarzonych gedach.
`type`	Obsługiwane i muszą być zgodne ze skojarzonym typem skojarzonych dysków GED (chyba że element zawiera typ anonimowy).

<xs:element>: zawartość

Zawartość	Schemat
`simpleType`	Obsługiwane.*
`complexType`	Obsługiwane.*
`unique`	Ignorowane.
`key`	Ignorowane.
`keyref`	Ignorowane.
(puste)	Obsługiwane.

* W przypadku używania mapowania simpleType i complexType, dla typów anonimowych jest taka sama jak w przypadku typów innych niż anonimowe, z tą różnicą, że nie ma żadnych anonimowych kontraktów danych, a więc tworzony jest nazwa nazwany kontrakt danych z wygenerowaną nazwą elementu. Reguły typów anonimowych znajdują się na następującej liście:

Szczegóły implementacji programu WCF: jeśli xs:element nazwa nie zawiera kropki, typ anonimowy mapuje na wewnętrzny typ zewnętrznego typu kontraktu danych. Jeśli nazwa zawiera kropki, wynikowy typ kontraktu danych jest niezależny (a nie typ wewnętrzny).
Wygenerowana nazwa kontraktu danych typu wewnętrznego to nazwa kontraktu danych typu zewnętrznego, po którym następuje kropka, nazwa elementu i ciąg "Typ".
Jeśli kontrakt danych o takiej nazwie już istnieje, nazwa jest unikatowa, dołączając ciąg "1", "2", "3", itd. do momentu utworzenia unikatowej nazwy.

Proste typy — <xs:simpleType>

<xs:simpleType>: atrybuty

Atrybut	Schemat
`final`	Ignorowane.
`id`	Ignorowane.
`name`	Obsługiwane mapuje nazwę kontraktu danych.

<xs:simpleType>: zawartość

Zawartość	Schemat
`restriction`	Obsługiwane. Mapuje na kontrakty danych wyliczenia. Ten atrybut jest ignorowany, jeśli nie jest zgodny ze wzorcem wyliczenia. Zobacz sekcję `xs:simpleType` ograniczenia.
`list`	Obsługiwane. Mapuje na flagę kontrakty danych wyliczania. Zobacz sekcję `xs:simpleType` listy.
`union`	Zakazane.

<xs:restriction>

Ograniczenia typu złożonego są obsługiwane tylko dla base="xs:anyType".
Proste ograniczenia typu, które nie mają żadnych aspektów ograniczeń xs:string innych niż xs:enumeration są mapowane na kontrakty danych wyliczenia.
Wszystkie inne ograniczenia typu prostego są mapowane na ograniczone typy. Na przykład ograniczenie map do liczby całkowitej xs:int , tak samo jak xs:int sama. Aby uzyskać więcej informacji na temat mapowania typów pierwotnych, zobacz Mapowanie typu/pierwotnego.

<xs:restriction>: attributes

Atrybut	Schemat
`base`	Musi być obsługiwanym prostym typem lub `xs:anyType`.
`id`	Ignorowane.

<xs:ograniczenie> dla wszystkich innych przypadków: zawartość

Zawartość	Schemat
`simpleType`	Jeśli istnieje, musi pochodzić z obsługiwanego typu pierwotnego.
`minExclusive`	Ignorowane.
`minInclusive`	Ignorowane.
`maxExclusive`	Ignorowane.
`maxInclusive`	Ignorowane.
`totalDigits`	Ignorowane.
`fractionDigits`	Ignorowane.
`length`	Ignorowane.
`minLength`	Ignorowane.
`maxLength`	Ignorowane.
`enumeration`	Ignorowane.
`whiteSpace`	Ignorowane.
`pattern`	Ignorowane.
(puste)	Obsługiwane.

Wyliczenie

<xs:ograniczenie> dla wyliczenia: atrybuty

Atrybut	Schemat
`base`	Jeśli jest obecny, musi mieć wartość `xs:string`.
`id`	Ignorowane.

<xs:restriction> for enumerations: contents

Zawartość	Schemat
`simpleType`	Jeśli istnieje, musi być ograniczeniem wyliczenia obsługiwanym przez kontrakt danych (ta sekcja).
`minExclusive`	Ignorowane.
`minInclusive`	Ignorowane.
`maxExclusive`	Ignorowane.
`maxInclusive`	Ignorowane.
`totalDigits`	Ignorowane.
`fractionDigits`	Ignorowane.
`length`	Zakazane.
`minLength`	Zakazane.
`maxLength`	Zakazane.
`enumeration`	Obsługiwane. Wyliczenie "id" jest ignorowane, a wartość jest mapowana na nazwę wartości w kontrakcie danych wyliczania.
`whiteSpace`	Zakazane.
`pattern`	Zakazane.
(puste)	Obsługiwane mapowanie na pusty typ wyliczenia.

Poniższy kod przedstawia klasę wyliczenia języka C#.

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

Ta klasa jest mapowany na następujący schemat za pomocą elementu DataContractSerializer. Jeśli wartości wyliczenia zaczynają się od 1, xs:annotation bloki nie są generowane.

<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 mapuje typy wyliczeń oznaczone System.FlagsAttribute jako xs:list pochodzące z xs:stringelementu . Nie są obsługiwane żadne inne xs:list odmiany.

<xs:list>: atrybuty

Atrybut	Schemat
`itemType`	Zakazane.
`id`	Ignorowane.

<xs:list>: zawartość

Zawartość	Schemat
`simpleType`	Musi być ograniczeniem używania `xs:stringxs:enumeration` aspektów.

Jeśli wartość wyliczenia nie ma mocy 2 progresji (wartość domyślna dla flag), wartość jest przechowywana w elemecie xs:annotation/xs:appInfo/ser:EnumerationValue .

Na przykład poniższy kod flaguje typ wyliczenia.

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

Ten typ jest mapowy na następujący schemat.

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

Dziedziczenie

Reguły ogólne

Kontrakt danych może dziedziczyć z innego kontraktu danych. Takie kontrakty danych są mapowane na bazę i są tworzone przez typy rozszerzeń przy użyciu konstrukcji schematu <xs:extension> XML.

Kontrakt danych nie może dziedziczyć z kontraktu danych zbierania.

Na przykład poniższy kod jest kontraktem danych.

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

Ten kontrakt danych jest mapowy na następującą deklarację typu schematu XML.

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

Atrybut	Schemat
`id`	Ignorowane.
`mixed`	Wartość musi być fałszem.

<xs:complexContent>: zawartość

Zawartość	Schemat
`restriction`	Zabronione, z wyjątkiem sytuacji, gdy base="`xs:anyType`". Drugi element jest odpowiednikiem umieszczania zawartości obiektu `xs:restriction` bezpośrednio pod kontenerem obiektu `xs:complexContent`.
`extension`	Obsługiwane. Mapuje na dziedziczenie kontraktu danych.

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

Atrybut	Schemat
`id`	Ignorowane.
`base`	Obsługiwane. Mapuje na podstawowy typ kontraktu danych dziedziczony przez ten typ.

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

Reguły są takie same jak w przypadku <xs:complexType> zawartości.

Jeśli element <xs:sequence> jest podany, jego elementy członkowskie są mapowane na dodatkowe elementy członkowskie danych, które znajdują się w kontraktie danych pochodnych.

Jeśli typ pochodny zawiera element o takiej samej nazwie jak element w typie podstawowym, deklaracja zduplikowanego elementu jest mapowana na element członkowski danych o nazwie, która jest generowana jako unikatowa. Dodatnie liczby całkowite są dodawane do nazwy składowej danych ("member1", "member2" itd.), dopóki nie zostanie znaleziona unikatowa nazwa. Odwrotnie:

Jeśli kontrakt danych pochodnych ma element członkowski danych o tej samej nazwie i typie co element członkowski danych w kontrakcie danych podstawowych, DataContractSerializer generuje ten odpowiedni element w typie pochodnym.
Jeśli kontrakt danych pochodnych ma element członkowski danych o tej samej nazwie co element członkowski danych w kontrakcie danych podstawowych, ale inny typ, DataContractSerializer importuje schemat z elementem typu xs:anyType zarówno w deklaracjach typu podstawowego, jak i pochodnego. Oryginalna nazwa typu jest zachowywana w pliku xs:annotations/xs:appInfo/ser:ActualType/@Name.

Obie odmiany mogą prowadzić do schematu z niejednoznacznym modelem zawartości, który zależy od kolejności odpowiednich elementów członkowskich danych.

Mapowanie typu/pierwotnego

Używa DataContractSerializer następującego mapowania dla typów pierwotnych schematu XML.

Typ XSD	Typ platformy .NET
`anyType`	Object.
`anySimpleType`	String.
`duration`	TimeSpan.
`dateTime`	DateTime.
`dateTimeOffset`	DateTime i TimeSpan dla przesunięcia. Zobacz serializację DateTimeOffset poniżej.
`time`	String.
`date`	String.
`gYearMonth`	String.
`gYear`	String.
`gMonthDay`	String.
`gDay`	String.
`gMonth`	String.
`boolean`	Boolean
`base64Binary`	Byte Tablicy.
`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.

Mapowanie typów ISerializable

W .NET Framework wersji 1.0 ISerializable wprowadzono ogólny mechanizm serializacji obiektów na potrzeby trwałości lub transferu danych. Istnieje wiele typów .NET Framework, które implementują ISerializable i które mogą być przekazywane między aplikacjami. DataContractSerializer naturalnie zapewnia obsługę ISerializable klas. Typy DataContractSerializer schematów implementacji map ISerializable różniące się tylko nazwą QName (kwalifikowaną nazwą) typu i są efektywnie kolekcjami właściwości. Na przykład mapuje DataContractSerializerException na następujący typ XSD w http://schemas.datacontract.org/2004/07/System przestrzeni nazw.

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

Opcjonalny atrybut ser:FactoryType zadeklarowany w schemacie serializacji kontraktu danych odwołuje się do klasy fabryki, która może deserializować typ. Klasa fabryki musi być częścią znanej kolekcji typów używanego DataContractSerializer wystąpienia. Aby uzyskać więcej informacji na temat znanych typów, zobacz Znane typy kontraktów danych.

Schemat serializacji DataContract

Wiele schematów wyeksportowanych przez DataContractSerializer typy, elementy i atrybuty użycia ze specjalnej przestrzeni nazw serializacji kontraktu danych:

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

Poniżej znajduje się kompletna deklaracja schematu serializacji kontraktu danych.

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

Należy zauważyć następujące kwestie:

ser:char Jest wprowadzany do reprezentowania znaków Unicode typu Char.
Element valuespace jest zredukowany do uporządkowanego zestawu, aby można go było zamapować na element TimeSpan.xs:duration
FactoryType jest używany w schematach wyeksportowanych z typów, które pochodzą z ISerializableklasy .

Importowanie schematów innych niż DataContract

DataContractSerializerImportXmlTypes Program ma opcję zezwalania na importowanie schematów, które nie są zgodne z DataContractSerializer profilem XSD (zobacz Options właściwość ). Ustawienie tej opcji w celu true umożliwienia akceptacji niezgodnych typów schematów i mapowanie ich na następującą implementację, IXmlSerializable opakowywanie tablicy XmlNode (różni się tylko nazwa klasy).

[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;
  }
}

Serializacja DateTimeOffset

Element DateTimeOffset nie jest traktowany jako typ pierwotny. Zamiast tego jest serializowany jako złożony element z dwiema częściami. Pierwsza część reprezentuje datę i godzinę, a druga część reprezentuje przesunięcie od daty i godziny. Przykład zserializowanej wartości DateTimeOffset jest wyświetlany w poniższym kodzie.

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

Schemat jest następujący.

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

Odwołanie do schematu kontraktu danych

Mapowania elementu DataContractSerializer

Poziomy obsługi

Informacje ogólne

<xs:schema>: atrybuty

<xs:schema>: zawartość

Typy złożone — <xs:complexType>

Informacje ogólne

<xs:complexType>: atrybuty

<xs:complexType>: zawartość

<xs:sequence> w typie złożonym: atrybuty

<xs:sequence> w typie złożonym: zawartość

Elements — <xs:element>

Informacje ogólne

<xs:element> with maxOccurs=1 within an <xs:sequence> (Data Members)

<xs:element> z wartością maxOccurs>1 w obrębie <xs:sequence> (kolekcje)

<xs:element> w deklaracji elementu globalnego <xs:schema>

<xs:element>: zawartość

Proste typy — <xs:simpleType>

<xs:simpleType>: atrybuty

<xs:simpleType>: zawartość

<xs:restriction>

<xs:restriction>: attributes

<xs:ograniczenie> dla wszystkich innych przypadków: zawartość

Wyliczenie

<xs:ograniczenie> dla wyliczenia: atrybuty

<xs:restriction> for enumerations: contents

<xs:list>

<xs:list>: atrybuty

<xs:list>: zawartość

Dziedziczenie

Reguły ogólne

<xs:complexContent>: atrybuty

<xs:complexContent>: zawartość

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

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

Mapowanie typu/pierwotnego

Mapowanie typów ISerializable

Schemat serializacji DataContract

Importowanie schematów innych niż DataContract

Serializacja DateTimeOffset

Zobacz też

Dodatkowe zasoby