Compartilhar via

Referência de esquema de contrato de dados

  • Artigo

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

Mapeamentos de DataContractSerializer

O DataContractSerializer mapeia tipos CLR para XSD quando os metadados são exportados de um serviço do WCF (Windows Communication Foundation) usando um ponto de extremidade de metadados ou a Ferramenta de Utilitário de Metadados do ServiceModel (Svcutil.exe). Para saber mais, confira Serializador de contrato de dados.

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

Somente instâncias de esquema XML que estejam de acordo com os requisitos declarados neste documento podem ser mapeadas para tipos CLR usando DataContractSerializer.

Níveis de suporte

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

  • Com suporte. Há um 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 nenhum efeito sobre a geração de código.

  • Proibido. O DataContractSerializer não dá suporte à importação de um esquema usando o recurso. Por exemplo, Svcutil.exe, ao acessar uma 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 de esquema é descrito no Esquema XML. O prefixo "xs" é usado neste documento.

  • Todos os atributos com um namespace não 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 Deve ser qualificado. Todos os elementos devem ser qualificados para que um esquema tenha suporte de 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:schema>: contents

Sumário Esquema
include Com suporte. DataContractSerializer dá suporte a xs:include e xs:import. No entanto, Svcutil.exe restringe as seguintes referências xs:include/@schemaLocation e xs:import/@location quando os metadados são carregados de um arquivo local. A lista de arquivos de esquema deve ser passada por um mecanismo fora de banda e não por include nesse caso; included documentos de esquema são ignorados.
redefine Negado. O uso de xs:redefine é proibido por DataContractSerializer por motivos de segurança: x:redefine requer schemaLocation para ser seguido. Em determinadas circunstâncias, Svcutil.exe usando DataContract restringe o uso de schemaLocation.
import Com suporte. DataContractSerializer dá suporte a xs:include e xs:import. No entanto, Svcutil.exe restringe as seguintes referências xs:include/@schemaLocation e xs:import/@location quando os metadados são carregados de um arquivo local. A lista de arquivos de esquema deve ser passada por um mecanismo fora de banda e não por include nesse caso; included documentos de esquema são ignorados.
simpleType Com suporte. Consulte a seção xs:simpleType.
complexType Com suporte, mapeia para contratos de dados. Consulte a seção xs:complexType.
group Ignorado. DataContractSerializer não dá suporte ao uso de xs:group, xs:attributeGroup e xs:attribute. Essas declarações são ignoradas como filhos de xs:schema, mas não podem ser referenciadas a partir de complexType ou de outros constructos com suporte.
attributeGroup Ignorado. DataContractSerializer não dá suporte ao uso de xs:group, xs:attributeGroup e xs:attribute. Essas declarações são ignoradas como filhos de xs:schema, mas não podem ser referenciadas a partir de complexType ou de outros constructos com suporte.
element Com suporte. Consulte a GED (Declaração de Elemento Global).
attribute Ignorado. DataContractSerializer não dá suporte ao uso de xs:group, xs:attributeGroup e xs:attribute. Essas declarações são ignoradas como filhos de xs:schema, mas não podem ser referenciadas a partir de complexType ou de outros constructos com suporte.
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 Deve ser falso (padrão).
block Negado.
final Ignorado.
id Ignorado.
mixed Deve ser falso (padrão).
name Com suporte e mapeado para o nome do contrato de dados. Se houver pontos no nome, será 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 do contrato de dados A, mas somente se esse tipo de contrato de dados existir. Mais de um nível de aninhamento é possível: por exemplo, A.B.C pode ser um tipo interno, mas somente se A e A.B existirem.

<xs:complexType>: contents

Sumário Esquema
simpleContent Extensões são proibidas.

A restrição é permitida somente de anySimpleType.
complexContent Com suporte. Consulte "Herança".
group Negado.
all Negado.
choice Proibido
sequence Com suporte, mapeia para membros de dados de um contrato de dados.
attribute Proibido, mesmo que use="prohibited" (com uma exceção). Há suporte apenas para atributos opcionais do namespace Standard Serialization Schema. Eles não são mapeados para membros de dados no modelo de programação do contrato de dados. Atualmente, apenas um desses atributos tem significado e é discutido na seção ISerializable. Todos os outros são ignorados.
attributeGroup Negado. Na versão WCF v1, DataContractSerializer ignora a presença de attributeGroup dentro de xs:complexType.
anyAttribute Negado.
(vazio) Mapeia para um contrato de dados sem membros de dados.

<xs:sequence> em um tipo complexo: atributos

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

<xs:sequence> em um tipo complexo: conteúdo

Sumário Esquema
element Cada instância mapeia para um membro de dados.
group Negado.
choice Negado.
sequence Negado.
any Negado.
(vazio) Mapeia para um contrato de dados sem membros de dados.

Elements – <xs:element>

Informações gerais

<xs:element> pode ocorrer nos seguintes contextos:

  • Ele pode ocorrer dentro de um <xs:sequence>, que descreve um membro de dados de um contrato de dados regular (não coleta). Nesse caso, o atributo maxOccurs deve ser 1. (Um valor de 0 não é permitido).

  • Ele pode ocorrer dentro de um <xs:sequence>, que descreve um membro de dados de um contrato de dados de coleta. Nesse caso, o atributo maxOccurs deve ser maior que 1 ou "não associado".

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

<xs:element> with maxOccurs=1 em um <xs:sequence> (Membros de Dados)

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

<xs:element> com maxOccurs>1 em um <xs:sequence> (Coleções)

As coleções podem ser de um dos seguintes tipos:

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

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

  • A única diferença entre um dicionário e uma matriz de um tipo de par de 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ários.

As regras para os atributos ref, block, default, fixed, form e id são as mesmas para o caso de não coleção. Outros atributos incluem aqueles na tabela a seguir.

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

<xs:element> em uma Declaração de elemento global <xs:schema>

  • Uma GED (Declaração de elemento global) que tem os mesmos nome e namespace que um tipo no esquema ou que define um tipo anônimo dentro de si é considerada associada ao tipo.

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

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

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

Atributo Esquema
abstract Deve ser falso para GEDs associadas.
block Proibido em GEDs associadas.
default Proibido em GEDs associadas.
final Deve ser falso para GEDs associadas.
fixed Proibido em GEDs associadas.
id Ignorado.
name Com suporte. Consulte a definição de GEDs associadas.
nillable Deve ser verdadeiro para GEDs associadas.
substitutionGroup Proibido em GEDs associadas.
type Com suporte e deve corresponder ao tipo associado para GEDs associadas (a menos que o elemento contenha um tipo anônimo).

<xs:element>: contents

Sumário Esquema
simpleType Com suporte.*
complexType Com suporte.*
unique Ignorado.
key Ignorado.
keyref Ignorado.
(blank) Com suporte.

* Ao usar o e complexType, o simpleType 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 seguinte lista:

  • Detalhes da implementação do WCF: se o nome xs:element não contiver períodos, 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 um contrato de dados com esse nome já existir, o nome será exclusivo acrescentando "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>: contents

Sumário Esquema
restriction Com suporte. Mapeia para contratos de dados de enumeração. Esse atributo será ignorado se não corresponder ao padrão de enumeração. Consulte a seção de restrições xs:simpleType.
list Com suporte. Mapeia para sinalizar contratos de dados de enumeração. Consulte a seção de listas xs:simpleType.
union Negado.

<xs:restriction>

  • Há suporte para restrições de tipo complexas somente para base="xs:anyType".

  • Restrições de tipo simples de xs:string que não têm nenhuma faceta de restrição diferente de xs:enumeration são 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 mapeia para um inteiro, assim como a própria xs:int faz. Para obter mais informações sobre mapeamento de tipo primitivo, consulte Mapeamento de tipo/primitivo.

<xs:restriction>: atributos

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

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

Sumário Esquema
simpleType Se presente, deve ser derivado de um tipo primitivo com suporte.
minExclusive Ignorado.
minInclusive Ignorado.
maxExclusive Ignorado.
maxInclusive Ignorado.
totalDigits Ignorado.
fractionDigits Ignorado.
length Ignorado.
minLength Ignorado.
maxLength Ignorado.
enumeration Ignorado.
whiteSpace Ignorado.
pattern Ignorado.
(blank) Com suporte.

Enumeração

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

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

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

Sumário Esquema
simpleType Se presente, deve ser uma restrição de enumeração com suporte pelo contrato de dados (esta seção).
minExclusive Ignorado.
minInclusive Ignorado.
maxExclusive Ignorado.
maxInclusive Ignorado.
totalDigits Ignorado.
fractionDigits Ignorado.
length Negado.
minLength Negado.
maxLength Negado.
enumeration Com suporte. A enumeração "id" é ignorada, e "value" mapeia para o nome do valor no contrato de dados de enumeração.
whiteSpace Negado.
pattern Negado.
(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
}

Essa classe mapeia para o esquema a seguir pelo DataContractSerializer. Se os valores de enumeração começarem em 1, os blocos xs:annotation 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 há suporte para outras variações de xs:list.

<xs:list>: atributos

Atributo Esquema
itemType Negado.
id Ignorado.

<xs:list>: conteúdo

Sumário Esquema
simpleType Deve ser uma restrição de xs:string usando a faceta xs:enumeration.

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

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 o constructo do esquema XML <xs:extension>.

Um contrato de dados não pode herdar de um contrato de dados de coleção.

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

Esse 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 false.

<xs:complexContent>: contents

Sumário Esquema
restriction Proibido, exceto quando base="xs:anyType". Este último é equivalente a colocar o conteúdo de xs:restriction diretamente sob o contêiner de xs:complexContent.
extension Com suporte. Mapeia para a herança do contrato de dados.

<xs:extension> em <xs:complexContent>: atributos

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

<xs:extension> em <xs:complexContent>: conteúdo

As regras são iguais às do conteúdo <xs:complexType>.

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

Se um tipo derivado contiver um elemento com o mesmo nome que um elemento em um tipo base, a declaração de elemento duplicado mapeará 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 derivados tiver um membro de dados com o mesmo nome e tipo que um membro de dados em um contrato de dados base, DataContractSerializer gerará esse elemento correspondente no tipo derivado.

  • Se um contrato de dados derivados tiver um membro de dados com o mesmo nome que um membro de dados em um contrato de dados base, mas um tipo diferente, 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 respectivos membros de dados.

Mapeamento de tipo/primitivo

DataContractSerializer usa o mapeamento a seguir para tipos primitivos de esquema XML.

Tipo XSD Tipo .NET
anyType Object.
anySimpleType String.
duration TimeSpan.
dateTime DateTime.
dateTimeOffset DateTime e TimeSpan para o deslocamento. Consulte a Serialização DateTimeOffset abaixo.
time String.
date String.
gYearMonth String.
gYear String.
gMonthDay String.
gDay String.
gMonth String.
boolean Boolean
base64Binary Matriz Byte.
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 classes ISerializable. DataContractSerializer mapeia os tipos de esquema de implementação ISerializable que diferem apenas pelo QName (nome qualificado) do tipo e são coleções de propriedades efetivamente. Por exemplo, DataContractSerializer mapeia Exception para o tipo XSD a seguir no namespace http://schemas.datacontract.org/2004/07/System.

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

Esquema de serialização de DataContract

Vários esquemas exportados por DataContractSerializer usam tipos, elementos e atributos de um namespace especial de Serialização de contrato de dados:

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

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

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

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

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

Importando 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 perfil XSD DataContractSerializer (consulte a propriedade Options). Definir essa opção como true permite a aceitação de tipos de esquema não compatíveis e o seu mapeamento para a implementação a seguir, IXmlSerializable encapsulando uma matriz de XmlNode (somente 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 abaixo

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, e a segunda, 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>

Confira também