Partilhar via

Referência de esquema de contrato de dados

  • Artigo

Este tópico descreve o subconjunto do esquema XML (XSD) usado para DataContractSerializer descrever tipos CLR (Common Language Runtime) para serialização XML.

Mapeamentos DataContractSerializer

O DataContractSerializer mapeia tipos CLR para XSD quando os metadados são exportados de um serviço WCF (Windows Communication Foundation) usando um ponto de extremidade de metadados ou a ServiceModel Metadata Utility Tool (Svcutil.exe). Para obter mais informações, consulte Data Contract Serializer.

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

Somente instâncias de esquema XML que estão em conformidade com os requisitos declarados neste documento podem ser mapeadas para tipos CLR usando DataContractSerializer.

Níveis de Suporte

O DataContractSerializer fornece os seguintes níveis de suporte para um determinado recurso de esquema XML:

  • Suportado. Há mapeamento explícito desse recurso para tipos ou atributos CLR (ou ambos) usando DataContractSerializer.

  • Ignorado. O recurso é permitido em esquemas importados pelo DataContractSerializer, mas não tem efeito na geração de código.

  • Proibido. O DataContractSerializer não suporta a importação de um esquema usando o recurso. Por exemplo, Svcutil.exe, ao acessar um WSDL com um esquema que usa esse recurso, volta a usar o XmlSerializer em vez disso. Isso ocorre por padrão.

Informações Gerais

  • O namespace do esquema é descrito em Esquema XML. O prefixo "xs" é usado neste documento.

  • Todos os atributos com um namespace que não seja de esquema são ignorados.

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

<xs:esquema>: atributos

Atributo DataContract
attributeFormDefault Ignorado.
blockDefault Ignorado.
elementFormDefault Deve ser qualificado. Todos os elementos devem ser qualificados para que um esquema seja suportado pelo DataContractSerializer. Isso pode ser feito definindo xs:schema/@elementFormDefault como "qualificado" ou definindo xs:element/@form como "qualificado" em cada declaração de elemento individual.
finalDefault Ignorado.
Id Ignorado.
targetNamespace Com suporte e mapeado para o namespace do contrato de dados. Se esse atributo não for especificado, o namespace em branco será usado. Não pode ser o namespace http://schemas.microsoft.com/2003/10/Serialization/reservado .
version Ignorado.

<xs:esquema>: conteúdo

Conteúdos Esquema
include Suportado. DataContractSerializer suporta xs:include e xs:import. No entanto, Svcutil.exe restringe o seguimento xs:include/@schemaLocation e xs:import/@location as referências quando os metadados são carregados de um arquivo local. A lista de arquivos de esquema deve ser passada através de um mecanismo fora de banda e não através include neste caso; included documentos de esquema são ignorados.
redefine Proibido. O uso de é proibido por razões de xs:redefine segurança: x:redefine requer schemaLocation ser seguido.DataContractSerializer Em determinadas circunstâncias, Svcutil.exe usando DataContract restringe o uso do schemaLocation.
import Suportado. DataContractSerializer suportes xs:include e xs:import. No entanto, Svcutil.exe restringe o seguimento xs:include/@schemaLocation e xs:import/@location as referências quando os metadados são carregados de um arquivo local. A lista de arquivos de esquema deve ser passada através de um mecanismo fora de banda e não através include neste caso; included documentos de esquema são ignorados.
simpleType Suportado. Consulte a xs:simpleType secção.
complexType Suportado, mapas para contratos de dados. Consulte a xs:complexType secção.
group Ignorado. DataContractSerializer não suporta a utilização de xs:group, xs:attributeGroupe xs:attribute. Essas declarações são ignoradas como filhos de xs:schema, mas não podem ser referenciadas de dentro complexType ou de outras construções suportadas.
attributeGroup Ignorado. DataContractSerializer não suporta a utilização de xs:group, xs:attributeGroupe xs:attribute. Essas declarações são ignoradas como filhos de xs:schema, mas não podem ser referenciadas de dentro complexType ou de outras construções suportadas.
element Suportado. Consulte Declaração Global de Elementos (GED).
attribute Ignorado. DataContractSerializer não suporta a utilização de xs:group, xs:attributeGroupe xs:attribute. Essas declarações são ignoradas como filhos de xs:schema, mas não podem ser referenciadas de dentro complexType ou de outras construções suportadas.
notation Ignorado.

Tipos complexos – <xs:complexType>

Informações Gerais

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

<xs:complexType>: atributos

Atributo Esquema
abstract Deve ser falso (padrão).
block Proibido.
final Ignorado.
id Ignorado.
mixed Deve ser falso (padrão).
name Suportado e mapeado para o nome do contrato de dados. Se houver pontos no nome, é feita uma tentativa de mapear o tipo para um tipo interno. Por exemplo, um tipo complexo chamado A.B mapeia para um tipo de contrato de dados que é um tipo interno de um tipo com o nome Ado contrato de dados, mas somente se esse tipo de contrato de dados existir. Mais de um nível de nidificação é possí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 Extensões são proibidas.

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

<xs:sequência> em um tipo complexo: atributos

Atributo Esquema
id Ignorado.
maxOccurs Deve ser 1 (padrão).
minOccurs Deve ser 1 (padrão).

<xs:sequência> em um tipo complexo: conteúdo

Conteúdos Esquema
element Cada instância é mapeada 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 coleta). Neste caso, o maxOccurs atributo deve 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 coleta. Neste caso, o maxOccurs atributo deve ser maior que 1 ou "ilimitado".

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

<xs:element> com maxOccur=1 dentro de um <xs:sequence> (Membros de Dados)

Atributo Esquema
ref Proibido.
name Com suporte, mapeia para o nome do membro de dados.
type Com suporte, mapeia para o tipo de membro de dados. Para obter mais informações, consulte Mapeamento de tipo/primitivo. Se não especificado (e o elemento não contém um tipo anônimo), xs:anyType é assumido.
block Ignorado.
default Proibido.
fixed Proibido.
form Deve ser qualificado. Este atributo pode ser definido através de elementFormDefault xs:schema.
id Ignorado.
maxOccurs 1
minOccurs Mapeia para a IsRequired propriedade de um membro de dados (IsRequired é true quando minOccurs é 1).
nillable Afeta o mapeamento de tipos. Consulte Mapeamento de tipo/primitivo.

<xs:elemento> com maxOccurs>1 dentro de um <xs:sequence> (Coleções)

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 está no modelo de programação gerado. Há um mecanismo de anotação de esquema que pode ser usado para indicar que um determinado tipo é uma coleção de dicionário.

As regras para os refatributos , , blockdefault, fixed, form, e id são as mesmas que para o caso de não cobrança. Outros atributos incluem os da tabela a seguir.

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

<xs:element> dentro de uma <declaração de elemento global xs:schema>

  • Uma Declaração de Elemento Global (GED) que tem o mesmo nome e namespace que um tipo no esquema, ou que define um tipo anônimo dentro de si mesmo, é considerada associada ao tipo.

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

  • Desserialização/serialização: GEDs associados são usados como elementos raiz para o tipo.

  • Importação de esquema: 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 Deve ser falso para GEDs associados.
block Proibido em GEDs associados.
default Proibido em GEDs associados.
final Deve ser falso para GEDs associados.
fixed Proibido em GEDs associados.
id Ignorado.
name Suportado. Ver a definição de GED associado.
nillable Deve ser verdadeiro para GEDs associados.
substitutionGroup Proibido em GEDs associados.
type Suportado e deve corresponder ao tipo associado para GEDs associados (a menos que o elemento contenha um tipo anônimo).

<xs:elemento>: conteúdo

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

* Ao usar o simpleType e complexType, o mapeamento para tipos anônimos é o mesmo que para tipos não anônimos, exceto que não há contratos de dados anônimos e, portanto, um contrato de dados nomeado é criado, com um nome gerado derivado do nome do elemento. As regras para tipos anônimos estão na lista a seguir:

  • Detalhe da implementação do WCF: Se o xs:element nome não contiver pontos, o tipo anônimo será mapeado para um tipo interno do tipo de contrato de dados externo. Se o nome contiver pontos, o tipo de contrato de dados resultante será 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 por um ponto, o nome do elemento e a cadeia de caracteres "Type".

  • Se já existir um contrato de dados com esse nome, o nome torna-se exclusivo anexando "1", "2", "3" e assim por diante até que um nome exclusivo seja criado.

Tipos simples - <xs:simpleType>

<xs:simpleType>: atributos

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

<xs:simpleType>: conteúdo

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

<xs:restrição>

  • Restrições de tipo complexo são suportadas apenas para base="xs:anyType".

  • Restrições de tipo simples que não têm nenhuma faceta de restrição além de xs:enumeration serem mapeadas para contratos de dados de xs:string enumeração.

  • Todas as outras restrições de tipo simples são mapeadas para os tipos que elas restringem. Por exemplo, uma restrição de xs:int mapas a um inteiro, assim como xs:int ele mesmo. Para obter mais informações sobre mapeamento de tipo primitivo, consulte Mapeamento de tipo/primitivo.

<xs:restrição>: atributos

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

<xs:restrição> para todos os outros casos: conteúdo

Conteúdos Esquema
simpleType Se presente, deve 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:restrição> para enumerações: atributos

Atributo Esquema
base Se presente, deve ser xs:string.
id Ignorado.

<xs:restrição> para enumerações: conteúdo

Conteúdos Esquema
simpleType Se presente, deve ser uma restrição de enumeração suportada pelo contrato de dados (esta seçã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 "value" mapeia para o nome do valor no contrato de dados de enumeração.
whiteSpace Proibido.
pattern Proibido.
(vazio) Com suporte, mapeia para o tipo de enumeração vazio.

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

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

Esta classe é mapeada DataContractSerializerpara o esquema a seguir pelo . 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:lista>

DataContractSerializer Mapeia tipos de enumeração marcados com System.FlagsAttribute a xs:list derivada de xs:string. Nenhuma outra xs:list variação é suportada.

<xs:lista>: atributos

Atributo Esquema
itemType Proibido.
id Ignorado.

<xs:lista>: conteúdo

Conteúdos Esquema
simpleType Deve ser restrição de uso xs:enumeration de xs:string faceta.

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

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

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

Esse tipo é mapeado para o esquema a seguir.

<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 são mapeados para uma base e são derivados por tipos de extensão usando a construção do <xs:extension> esquema XML.

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

Por exemplo, o código a seguir é 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 é mapeado 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 Deve ser falso.

<xs:complexContent>: conteúdo

Conteúdos Esquema
restriction Proibido, exceto quando base="xs:anyType". Este último equivale a colocar o xs:restriction conteúdo do diretamente sob o recipiente do xs:complexContent.
extension Suportado. Mapeia para herança de contrato de dados.

<xs:extensão> em <xs:complexContent>: atributos

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

<xs:extensão> em <xs:complexContent>: conteúdo

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

Se um <xs:sequence> for fornecido, seus elementos de membro serão mapeados para membros de dados adicionais que estão presentes no contrato de dados derivados.

Se um tipo derivado contiver um elemento com o mesmo nome de um elemento em um tipo base, a declaração de elemento duplicado será mapeada para um membro de dados com um nome gerado para ser exclusivo. Números inteiros positivos são adicionados ao nome do membro de dados ("member1", "member2" e assim por diante) até que um nome exclusivo seja encontrado. Inversamente:

  • Se um contrato de dados derivado tiver um membro de dados com o mesmo nome e tipo que um membro de dados em um contrato de dados de base, DataContractSerializer gerará esse 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 em um contrato de dados base, mas um tipo diferente, o DataContractSerializer importará um esquema com um elemento do tipo xs:anyType em declarações de tipo base e 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 de tipo/primitivo

O DataContractSerializer usa o seguinte mapeamento para tipos primitivos de esquema XML.

Tipo XSD Tipo .NET
anyType Object.
anySimpleType String.
duration TimeSpan.
dateTime DateTime.
dateTimeOffset DateTime e TimeSpan para a compensação. Consulte Serialização DateTimeOffset 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 ISerializable

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. Há muitos tipos de .NET Framework que implementam ISerializable e que podem ser passados entre aplicativos. DataContractSerializer naturalmente fornece suporte para ISerializable as aulas. 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 namespace.

<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 contrato de dados faz referência a uma classe de fábrica que pode desserializar o tipo. A classe de fábrica deve fazer parte da coleção de tipos conhecidos da instância que está sendo DataContractSerializer usada. Para obter mais informações sobre tipos conhecidos, consulte Tipos conhecidos de contrato de dados.

Esquema de serialização DataContract

Vários esquemas exportados pelos DataContractSerializer tipos de uso, elementos e atributos de um namespace especial de Serialização de Contrato de Dados:

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

A seguir está uma declaração completa de esquema de serialização de contrato de dados.

<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 notar-se o seguinte:

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

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

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

Importando esquemas não-DataContract

DataContractSerializer tem a opção de permitir a ImportXmlTypes importação de esquemas que não estão em conformidade com o DataContractSerializer perfil XSD (consulte a Options propriedade). Definir essa opção para permitir a true aceitação de tipos de esquema não conformes e mapeá-los para a implementação a seguir, IXmlSerializable encapsulando uma matriz de (somente o nome da XmlNode 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, ele é serializado como um elemento complexo com duas partes. A primeira parte representa a data hora e a segunda parte representa o deslocamento da data hora. Um exemplo de um valor DateTimeOffset serializado é mostrado no código a seguir.

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

Consulte também