Partilhar via

Referência do Esquema do Contrato de Dados

  • Artigo

Este tópico descreve o subconjunto do Esquema XML (XSD) utilizado por DataContractSerializer para descrever tipos comuns de runtime de linguagem (CLR) para serialização XML.

Mapeamentos de DataContractSerializer

O DataContractSerializer mapeia tipos de CLR para XSD quando os metadados são exportados de um serviço do Windows Communication Foundation (WCF) com um ponto final de metadados ou a ServiceModel Metadata Utility Tool (Svcutil.exe). Para obter mais informações, veja Serializador de Contratos de Dados.

O DataContractSerializer também mapeia os tipos de XSD para CLR quando Svcutil.exe é utilizado para aceder a documentos WSDL (Web Services Description Language) ou XSD e gerar contratos de dados para serviços ou clientes.

Apenas as instâncias de Esquema XML em conformidade com os requisitos indicados neste documento podem ser mapeadas para tipos de CLR com DataContractSerializer.

Níveis de Suporte

O DataContractSerializer fornece os seguintes níveis de suporte para uma determinada funcionalidade de Esquema XML:

  • Suportado. Existe um mapeamento explícito desta funcionalidade para tipos ou atributos CLR (ou ambos) com DataContractSerializer.

  • Ignorado. A funcionalidade é permitida em esquemas importados pelo DataContractSerializer, mas não tem qualquer efeito na geração de código.

  • Proibido. O DataContractSerializer não suporta a importação de um esquema com a funcionalidade. Por exemplo, Svcutil.exe, ao aceder a um WSDL com um esquema que utiliza essa funcionalidade, volta a utilizar o XmlSerializer . Isto é por predefinição.

Informações Gerais

  • O espaço de nomes do esquema está descrito em Esquema XML. O prefixo "xs" é utilizado neste documento.

  • Todos os atributos com um espaço de nomes sem esquema são ignorados.

  • Todas as anotações (exceto as descritas neste documento) são ignoradas.

<xs:schema>: atributos

Atributo DataContract
attributeFormDefault Ignorado.
blockDefault Ignorado.
elementFormDefault Tem de ser qualificado. Todos os elementos têm de ser qualificados para que um esquema seja suportado pelo DataContractSerializer. Isto pode ser feito ao definir xs:schema/@elementFormDefault como "qualificado" ou ao definir xs:element/@form como "qualificado" em cada declaração de elemento individual.
finalDefault Ignorado.
Id Ignorado.
targetNamespace Suportado e mapeado para o espaço de nomes do contrato de dados. Se este atributo não for especificado, é utilizado o espaço de nomes em branco. Não pode ser o espaço de nomes http://schemas.microsoft.com/2003/10/Serialization/reservado .
version Ignorado.

<xs:schema>: conteúdo

Conteúdos Esquema
include Suportado. DataContractSerializer suporta xs:include e xs:import. No entanto, Svcutil.exe restringe o seguinte xs:include/@schemaLocation e xs:import/@location as referências quando os metadados são carregados a partir de um ficheiro local. A lista de ficheiros de esquema tem de ser transmitida através de um mecanismo fora de banda e não através include deste caso; include os documentos de esquema d são ignorados.
redefine Proibido. A utilização de xs:redefine é proibida por DataContractSerializer motivos de segurança: x:redefine tem de schemaLocation ser seguida. Em determinadas circunstâncias, Svcutil.exe a utilização do DataContract restringe a utilização de schemaLocation.
import Suportado. DataContractSerializer suporta xs:include e xs:import. No entanto, Svcutil.exe restringe o seguinte xs:include/@schemaLocation e xs:import/@location as referências quando os metadados são carregados a partir de um ficheiro local. A lista de ficheiros de esquema tem de ser transmitida através de um mecanismo fora de banda e não através include deste caso; include os documentos de esquema d são ignorados.
simpleType Suportado. Veja a xs:simpleType secção .
complexType Suportado, mapeia para contratos de dados. Veja a xs:complexType secção .
group Ignorado. DataContractSerializer não suporta a utilização de xs:group, xs:attributeGroupe xs:attribute. Estas declarações são ignoradas como subordinadas de xs:schema, mas não podem ser referenciadas a partir de construções suportadas ou de outras complexType .
attributeGroup Ignorado. DataContractSerializer não suporta a utilização de xs:group, xs:attributeGroupe xs:attribute. Estas declarações são ignoradas como subordinadas de xs:schema, mas não podem ser referenciadas a partir de construções suportadas ou de outras complexType .
element Suportado. Veja Declaração de Elemento Global (GED).
attribute Ignorado. DataContractSerializer não suporta a utilização de xs:group, xs:attributeGroupe xs:attribute. Estas declarações são ignoradas como subordinadas de xs:schema, mas não podem ser referenciadas a partir de construções suportadas ou de outras complexType .
notation Ignorado.

Tipos Complexos – <xs:complexType>

Informações Gerais

Cada tipo <complexo xs:complexType> mapeia para um contrato de dados.

<xs:complexType>: atributos

Atributo Esquema
abstract Tem de ser falso (predefinição).
block Proibido.
final Ignorado.
id Ignorado.
mixed Tem de ser falso (predefinição).
name Suportado e mapeado para o nome do contrato de dados. Se existirem períodos no nome, é feita uma tentativa de mapear o tipo para um tipo interno. Por exemplo, um tipo complexo denominado A.B mapas para um tipo de contrato de dados que é um tipo interno de um tipo com o nome Ado contrato de dados , mas apenas se esse tipo de contrato de dados existir. É possível aninhar mais do que um nível: por exemplo, A.B.C pode ser um tipo interno, mas apenas se A e A.B ambos existirem.

<xs:complexType>: conteúdo

Conteúdos Esquema
simpleContent As extensões são proibidas.

A restrição só é permitida a partir de anySimpleType.
complexContent Suportado. Veja "Herança".
group Proibido.
all Proibido.
choice Proibido
sequence Suportado, mapeia para os membros de dados de um contrato de dados.
attribute Proibido, mesmo que utilize="proibido" (com uma exceção). Apenas são suportados atributos opcionais do espaço de nomes de Esquema de Serialização Padrão. Não mapeiam para os membros de dados no modelo de programação de contratos de dados. Atualmente, apenas um desses atributos tem significado e é discutido na secção ISerializable. Todos os outros são ignorados.
attributeGroup Proibido. Na versão WCF v1, DataContractSerializer ignora a presença de dentro xs:complexTypede attributeGroup .
anyAttribute Proibido.
(vazio) Mapeia para um contrato de dados sem membros de dados.

<xs:sequence> num tipo complexo: atributos

Atributo Esquema
id Ignorado.
maxOccurs Tem de ser 1 (predefinição).
minOccurs Tem de ser 1 (predefinição).

<xs:sequence> num tipo complexo: conteúdo

Conteúdos Esquema
element Cada instância mapeia para um membro de dados.
group Proibido.
choice Proibido.
sequence Proibido.
any Proibido.
(vazio) Mapeia para um contrato de dados sem membros de dados.

Elementos – <xs:element>

Informações Gerais

<xs:element> pode ocorrer nos seguintes contextos:

  • Pode ocorrer dentro de um <xs:sequence>, que descreve um membro de dados de um contrato de dados regular (não coleção). Neste caso, o maxOccurs atributo tem de ser 1. (Não é permitido um valor de 0).

  • Pode ocorrer dentro de um <xs:sequence>, que descreve um membro de dados de um contrato de dados de recolha. Neste caso, o maxOccurs atributo tem de ser superior a 1 ou "não vinculado".

  • Pode ocorrer numa <xs:schema> Declaração de Elemento Global (GED).

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

Atributo Esquema
ref Proibido.
name Suportado, mapeia para o nome do membro de dados.
type Suportado, mapeia para o tipo de membro de dados. Para obter mais informações, veja Mapeamento tipo/primitivo. Se não for especificado (e o elemento não contiver um tipo anónimo), xs:anyType é assumido.
block Ignorado.
default Proibido.
fixed Proibido.
form Tem de ser qualificado. Este atributo pode ser definido em elementFormDefaultxs:schema.
id Ignorado.
maxOccurs 1
minOccurs Mapeia para a IsRequired propriedade de um membro de dados (IsRequired é verdadeiro quando minOccurs é 1).
nillable Afeta o mapeamento de tipos. Veja Mapeamento tipo/primitivo.

<xs:element> with maxOccurs>1 within an <xs:sequence> (Collections)

As coleções podem ser dos seguintes tipos:

  • Coleções regulares (por exemplo, matrizes).

  • Coleções de dicionários (mapeamento de um valor para outro; por exemplo, um Hashtable).

  • A única diferença entre um dicionário e uma matriz de um tipo de par chave/valor é no modelo de programação gerado. Existe um mecanismo de anotação de esquema que pode ser utilizado para indicar que um determinado tipo é uma coleção de dicionários.

As regras para os refatributos , block, default, fixed, forme id são as mesmas que para o caso não coleção. Outros atributos incluem os da tabela seguinte.

Atributo Esquema
name Suportado, mapeia para a ItemName propriedade no CollectionDataContractAttribute atributo.
type Suportado, mapeia para o tipo armazenado na coleção.
maxOccurs Maior que 1 ou "não vinculado". O esquema DC deve utilizar "não vinculado".
minOccurs Ignorado.
nillable Afeta o mapeamento de tipos. Este atributo é ignorado para coleções de dicionários.

<xs:element> within an <xs:schema Global Element Declaration (Declaração de Elemento Global xs:schema> )

  • Uma Declaração de Elemento Global (GED) que tenha o mesmo nome e espaço de nomes que um tipo no esquema ou que defina um tipo anónimo dentro de si, diz-se que está associada ao tipo.

  • Exportação de esquema: os GEDs associados são gerados para cada tipo gerado, simples e complexo.

  • Deserialização/serialização: os GEDs associados são utilizados como elementos de raiz para o tipo.

  • Importação de esquema: os GEDs associados não são necessários e são ignorados se seguirem as seguintes regras (a menos que definam tipos).

Atributo Esquema
abstract Tem de ser falso para GEDs associados.
block Proibido em GEDs associados.
default Proibido em GEDs associados.
final Tem de ser falso para GEDs associados.
fixed Proibido em GEDs associados.
id Ignorado.
name Suportado. Veja a definição de GEDs associados.
nillable Tem de ser verdadeiro para GEDs associados.
substitutionGroup Proibido em GEDs associados.
type Suportado e tem de corresponder ao tipo associado para GEDs associados (a menos que o elemento contenha um tipo anónimo).

<xs:element>: contents

Conteúdos Esquema
simpleType Suportado.*
complexType Suportado.*
unique Ignorado.
key Ignorado.
keyref Ignorado.
(em branco) Suportado.

* Quando utilizar o e complexType, mapeamento simpleType para tipos anónimos é o mesmo que para tipos não anónimos, exceto que não existem contratos de dados anónimos, pelo que é criado um contrato de dados com nome, com um nome gerado derivado do nome do elemento. As regras para tipos anónimos estão na lista seguinte:

  • Detalhes de implementação do WCF: se o xs:element nome não contiver períodos, o tipo anónimo mapeia para um tipo interno do tipo de contrato de dados externo. Se o nome contiver períodos, o tipo de contrato de dados resultante é independente (não um tipo interno).

  • O nome do contrato de dados gerado do tipo interno é o nome do contrato de dados do tipo externo seguido de um período, o nome do elemento e a cadeia "Tipo".

  • Se já existir um contrato de dados com esse nome, o nome será tornado exclusivo ao acrescentar "1", "2", "3" e assim sucessivamente até que seja criado um nome exclusivo.

Tipos Simples - <xs:simpleType>

<xs:simpleType>: atributos

Atributo Esquema
final Ignorado.
id Ignorado.
name Suportado, mapeia para o nome do contrato de dados.

<xs:simpleType>: conteúdo

Conteúdos Esquema
restriction Suportado. Mapeia para enumerar contratos de dados. Este atributo é ignorado se não corresponder ao padrão de enumeração. Veja a xs:simpleType secção restrições.
list Suportado. Mapas para sinalizar contratos de dados de enumeração. Veja a xs:simpleType secção de listas.
union Proibido.

<xs:restriction>

  • As restrições de tipos complexos são suportadas apenas para base="xs:anyType".

  • As restrições de tipo simples não xs:string têm quaisquer facetas de restrição que xs:enumeration não sejam mapeadas para contratos de dados de enumeração.

  • Todas as outras restrições de tipo simples são mapeadas para os tipos que restringem. Por exemplo, uma restrição de xs:int mapas a um número inteiro, tal como xs:int acontece. Para obter mais informações sobre o mapeamento de tipos primitivos, veja Mapeamento tipo/primitivo.

<xs:restriction>: atributos

Atributo Esquema
base Tem de ser um tipo simples suportado ou xs:anyType.
id Ignorado.

<xs:restriction> para todos os outros casos: conteúdo

Conteúdos Esquema
simpleType Se estiver presente, tem de ser derivado de um tipo primitivo suportado.
minExclusive Ignorado.
minInclusive Ignorado.
maxExclusive Ignorado.
maxInclusive Ignorado.
totalDigits Ignorado.
fractionDigits Ignorado.
length Ignorado.
minLength Ignorado.
maxLength Ignorado.
enumeration Ignorado.
whiteSpace Ignorado.
pattern Ignorado.
(em branco) Suportado.

Enumeração

<xs:restriction> para enumerações: atributos

Atributo Esquema
base Se estiver presente, tem de ser xs:string.
id Ignorado.

<xs:restriction> para enumerações: conteúdo

Conteúdos Esquema
simpleType Se estiver presente, tem de ser uma restrição de enumeração suportada pelo contrato de dados (esta secção).
minExclusive Ignorado.
minInclusive Ignorado.
maxExclusive Ignorado.
maxInclusive Ignorado.
totalDigits Ignorado.
fractionDigits Ignorado.
length Proibido.
minLength Proibido.
maxLength Proibido.
enumeration Suportado. A enumeração "id" é ignorada e o "valor" mapeia para o nome do valor no contrato de dados de enumeração.
whiteSpace Proibido.
pattern Proibido.
(vazio) Suportado, mapeia para o tipo de enumeração vazio.

O código seguinte mostra uma classe de enumeração C#.

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

Esta classe mapeia para o seguinte esquema pelo DataContractSerializer. Se os valores de enumeração começarem a partir de 1, xs:annotation os blocos não serão gerados.

<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 mapeia tipos de enumeração marcados com System.FlagsAttribute para xs:list derivados de xs:string. Não são suportadas outras xs:list variações.

<xs:list>: atributos

Atributo Esquema
itemType Proibido.
id Ignorado.

<xs:list>: conteúdo

Conteúdos Esquema
simpleType Tem de ser uma restrição da utilização xs:enumeration da xs:string faceta.

Se o valor de enumeração não seguir uma potência de 2 progressão (predefinição para Sinalizadores), o valor é armazenado no xs:annotation/xs:appInfo/ser:EnumerationValue elemento.

Por exemplo, o seguinte código sinaliza um tipo de enumeração.

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

Este tipo mapeia para o seguinte esquema.

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

Herança

Regras gerais

Um contrato de dados pode herdar de outro contrato de dados. Esses contratos de dados mapeiam para uma base e são derivados por tipos de extensão com a <xs:extension> construção de Esquema XML.

Um contrato de dados não pode herdar de um contrato de dados de recolha.

Por exemplo, o seguinte código é um contrato de dados.

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

Este contrato de dados mapeia para a seguinte declaração de tipo de esquema 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>: atributos

Atributo Esquema
id Ignorado.
mixed Tem de ser falso.

<xs:complexContent>: conteúdo

Conteúdos Esquema
restriction Proibido, exceto quando base="xs:anyType". Este último é equivalente a colocar o conteúdo do xs:restriction diretamente no contentor do xs:complexContent.
extension Suportado. Mapeia para herança de contratos de dados.

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

Atributo Esquema
id Ignorado.
base Suportado. Mapeia para o tipo de contrato de dados base do qual este tipo herda.

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

As regras são as mesmas que para <xs:complexType> os conteúdos.

Se for fornecido um <xs:sequence> , os respetivos elementos membros são mapeados para membros de dados adicionais que estão presentes no contrato de dados derivado.

Se um tipo derivado contiver um elemento com o mesmo nome que um elemento num tipo de base, a declaração de elemento duplicado mapeia para um membro de dados com um nome que é gerado para ser exclusivo. Os números inteiros positivos são adicionados ao nome do membro de dados ("member1", "member2", etc.) até ser encontrado um nome exclusivo. Por outro lado:

  • Se um contrato de dados derivado tiver um membro de dados com o mesmo nome e tipo que um membro de dados num contrato de dados base, DataContractSerializer gera este elemento correspondente no tipo derivado.

  • Se um contrato de dados derivado tiver um membro de dados com o mesmo nome que um membro de dados num contrato de dados base, mas com um tipo diferente, o DataContractSerializer importa um esquema com um elemento do tipo no tipo xs:anyType base e declarações de tipo derivado. O nome do tipo original é preservado em xs:annotations/xs:appInfo/ser:ActualType/@Name.

Ambas as variações podem levar a um esquema com um modelo de conteúdo ambíguo, que depende da ordem dos respetivos membros de dados.

Mapeamento tipo/primitivo

O DataContractSerializer utiliza o seguinte mapeamento para tipos primitivos de Esquema XML.

Tipo XSD Tipo de .NET
anyType Object.
anySimpleType String.
duration TimeSpan.
dateTime DateTime.
dateTimeOffset DateTime e TimeSpan para o desvio. Veja DateTimeOffset Serialization abaixo.
time String.
date String.
gYearMonth String.
gYear String.
gMonthDay String.
gDay String.
gMonth String.
boolean Boolean
base64Binary Byte matriz.
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.

Mapeamento de tipos ISerializáveis

No .NET Framework versão 1.0, ISerializable foi introduzido como um mecanismo geral para serializar objetos para persistência ou transferência de dados. Existem muitos tipos de .NET Framework que implementam ISerializable e que podem ser transmitidos entre aplicações. DataContractSerializer fornece naturalmente suporte para ISerializable turmas. Os DataContractSerializer tipos de esquema de implementação de mapas ISerializable que diferem apenas pelo QName (nome qualificado) do tipo e são efetivamente coleções de propriedades. Por exemplo, o DataContractSerializer mapeia Exception para o seguinte tipo XSD no http://schemas.datacontract.org/2004/07/System espaço de nomes.

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

O atributo ser:FactoryType opcional declarado no esquema de Serialização de Contratos de Dados referencia uma classe de fábrica que pode anular a serialização do tipo. A classe de fábrica tem de fazer parte da coleção de tipos conhecidos da instância que está a DataContractSerializer ser utilizada. Para obter mais informações sobre tipos conhecidos, veja Tipos Conhecidos do Contrato de Dados.

Esquema de Serialização dataContract

Vários esquemas exportados pelos DataContractSerializer tipos de utilização, elementos e atributos de um espaço de nomes especial de Serialização de Contratos de Dados:

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

Segue-se uma declaração de esquema de Serialização de Contratos de Dados completa.

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

Deve ser indicado o seguinte:

  • ser:char é introduzido para representar carateres Unicode do tipo Char.

  • O valuespace de xs:duration é reduzido para um conjunto ordenado para que possa ser mapeado para um TimeSpan.

  • FactoryType é utilizado em esquemas exportados de tipos derivados de ISerializable.

Importar esquemas não DataContract

DataContractSerializer tem a opção ImportXmlTypes de permitir a importação de esquemas que não estão em conformidade com o DataContractSerializer perfil XSD (ver a Options propriedade). Definir esta opção para permitir a true aceitação de tipos de esquema não conformes e mapeá-los para a implementação seguinte, IXmlSerializable encapsulando uma matriz de XmlNode (apenas o nome da classe difere).

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

Serialização DateTimeOffset

O DateTimeOffset não é tratado como um tipo primitivo. Em vez disso, é serializado como um elemento complexo com duas partes. A primeira parte representa a data/hora e a segunda parte representa o desvio da data/hora. No código seguinte, é apresentado um exemplo de um valor DateTimeOffset serializado.

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

O esquema é o seguinte.

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

Ver também