Referencia de esquema de contrato de datos

  • Artículo

En este tema se describe el subconjunto del esquema XML (XSD) que DataContractSerializer usa para describir los tipos de Common Language Runtime (CLR) para la serialización XML.

Asignaciones de DataContractSerializer

El objeto DataContractSerializer asigna tipos CLR a XSD cuando los metadatos se exportan desde un servicio Windows Communication Foundation (WCF) mediante un punto de conexión de metadatos o la herramienta ServiceModel Metadata Utility Tool (Svcutil.exe). Para más información, consulte Serializador de contrato de datos.

El DataContractSerializer también asigna XSD a tipos de CLR cuando Svcutil.exe se utiliza para tener acceso al lenguaje de descripción de servicios Web (WSDL) o documentos XSD y para generar contratos de datos para servicios o clientes.

Solo las instancias de esquema XML que cumplen los requisitos mencionados en este documento pueden asignarse a tipos de CLR utilizando DataContractSerializer.

Niveles de compatibilidad

El DataContractSerializer proporciona los niveles siguientes de compatibilidad para una característica de esquema XML determinada:

  • Admitido. Hay asignación explícita desde esta característica a tipos o atributos CLR (o a ambos) mediante DataContractSerializer.

  • Se omite. La característica se permite en esquemas importados por el DataContractSerializer, pero no tiene ningún efecto sobre la generación de código.

  • Se prohíbe. El DataContractSerializer no permite importar un esquema mediante la característica. Por ejemplo, Svcutil.exe, al obtener acceso a un WSDL con un esquema que utiliza esta característica, vuelve a utilizar el XmlSerializer en su lugar. Esto se aplica de manera predeterminada.

Información general

  • El espacio de nombres del esquema se describe en Esquema XML. El prefijo "xs" se utiliza en este documento.

  • Cualquier atributo con un espacio de nombres que no sea del esquema Se ignora.

  • Se omite cualquier anotación (excepto aquellas descritas en este documento).

<xs:schema>: atributos

Atributo DataContract
attributeFormDefault ignorado.
blockDefault ignorado.
elementFormDefault Se debe calificar. Todos los elementos se deben calificar para un esquema para que DataContractSerializerlos admita. Esto puede lograrse estableciendo xs:schema/@elementFormDefault en "qualified" o estableciendo xs:element/@form en "qualified" en cada declaración de elemento individual.
finalDefault ignorado.
Id ignorado.
targetNamespace Admitido y asignado al espacio de nombres del contrato de datos. Si no se especifica este atributo, se utiliza el espacio de nombres en blanco. No puede ser el espacio de nombres reservado http://schemas.microsoft.com/2003/10/Serialization/.
version ignorado.

<xs:schema>: contenido

Contenido Schema
include Compatible. DataContractSerializer admite xs:include y xs:import. Sin embargo, Svcutil.exe restringe las siguientes referencias xs:include/@schemaLocation y xs:import/@location cuando los metadatos se cargan desde un archivo local. La lista de archivos de esquema se debe pasar mediante un mecanismo fuera de banda y no mediante include en este caso; los documentos de esquema includese omiten.
redefine Prohibido. El uso de xs:redefine se prohíbe por parte de DataContractSerializer por razones de seguridad: x:redefine requiere que se siga schemaLocation . En ciertas circunstancias, el uso de DataContract por parte de Svcutil.exe restringe el uso de schemaLocation.
import Compatible. DataContractSerializer admite xs:include y xs:import. Sin embargo, Svcutil.exe restringe las siguientes referencias xs:include/@schemaLocation y xs:import/@location cuando los metadatos se cargan desde un archivo local. La lista de archivos de esquema se debe pasar mediante un mecanismo fuera de banda y no mediante include en este caso; los documentos de esquema includese omiten.
simpleType Compatible. Vea la sección xs:simpleType .
complexType Admitido, se asigna a contratos de datos. Vea la sección xs:complexType .
group ignorado. DataContractSerializer no admite el uso de xs:group, xs:attributeGroupni xs:attribute. Estas declaraciones se ignoran como elementos secundarios de xs:schema, pero no se puede hacer referencia a ellas desde complexType u otras estructuras admitidas.
attributeGroup ignorado. DataContractSerializer no admite el uso de xs:group, xs:attributeGroupni xs:attribute. Estas declaraciones se ignoran como elementos secundarios de xs:schema, pero no se puede hacer referencia a ellas desde complexType u otras estructuras admitidas.
element Compatible. Vea la declaración de elemento global (GED).
attribute ignorado. DataContractSerializer no admite el uso de xs:group, xs:attributeGroupni xs:attribute. Estas declaraciones se ignoran como elementos secundarios de xs:schema, pero no se puede hacer referencia a ellas desde complexType u otras estructuras admitidas.
notation ignorado.

Tipos complejos: <xs:complexType>

Información general

Cada tipo complejo <xs:complexType> se asigna a un contrato de datos.

<xs:complexType>: atributos

Atributo Schema
abstract Debe ser false (valor predeterminado).
block Prohibido.
final ignorado.
id ignorado.
mixed Debe ser false (valor predeterminado).
name Admitido y asignado al nombre del contrato de datos. Si hay puntos en el nombre, se realiza un intento de asignar el tipo a un tipo interno. Por ejemplo, un tipo complejo denominado A.B asigna a un tipo de contrato de datos que es un tipo interno de un tipo con el nombre de contrato de datos A, pero solo si existe este tipo de contrato de datos. Es posible más de un nivel de anidación: por ejemplo, A.B.C puede ser un tipo interno, pero solo si existen A y A.B .

<xs:complexType>: contenido

Contenido Schema
simpleContent Se prohíben las extensiones.

La restricción solo se permite desde anySimpleType.
complexContent Compatible. Vea “Herencia”.
group Prohibido.
all Prohibido.
choice Prohibido
sequence Admitido, asigna a los miembros de datos de un contrato de datos.
attribute Prohibido, aun cuando uso = "prohibido" (con una excepción). Solo se admiten los atributos opcionales del espacio de nombres del esquema de serialización estándar. No asignan a miembros de datos en el modelo de programación del contrato de datos. Actualmente, solo un atributo de este tipo tiene significado y se trata en la sección ISerializable. El resto se pasa por alto.
attributeGroup Prohibido. En la versión v1 de WCF, DataContractSerializer omite la presencia de attributeGroup dentro de xs:complexType.
anyAttribute Prohibido.
(vacío) Se asigna a un contrato de datos sin miembros de datos.

<xs:sequence> en un tipo complejo: atributos

Atributo Schema
id ignorado.
maxOccurs Debe ser 1 (valor predeterminado).
minOccurs Debe ser 1 (valor predeterminado).

<xs:sequence> en un tipo complejo: contenido

Contenido Schema
element Cada instancia asigna a un miembro de datos.
group Prohibido.
choice Prohibido.
sequence Prohibido.
any Prohibido.
(vacío) Se asigna a un contrato de datos sin miembros de datos.

Elements: <xs:element>

Información general

<xs:element> puede aparecer en los contextos siguientes:

  • Puede ocurrir dentro de un <xs:sequence>, que describe un miembro de datos de un contrato de datos normal (no de una colección). En este caso, el atributo maxOccurs debe ser 1. (No se permite un valor de 0).

  • Puede ocurrir dentro de un <xs:sequence>, que describe un miembro de datos de un contrato de datos de colección. En este caso, el atributo maxOccurs debe ser mayor que 1 o "ilimitado".

  • Puede ocurrir dentro de <xs:schema> como una declaración de elemento global (GED).

<xs:element> con maxOccurs=1 dentro de un elemento <xs:sequence> (miembros de datos)

Atributo Schema
ref Prohibido.
name Admitido, asigna al nombre del miembro de datos.
type Admitido, asigna al tipo de miembro de datos. Para obtener más información, vea Asignación de tipo/primitivo. Si no se especifica (y el elemento no contiene un tipo anónimo), se supone xs:anyType .
block ignorado.
default Prohibido.
fixed Prohibido.
form Se debe calificar. Este atributo se puede establecer mediante elementFormDefault en xs:schema.
id ignorado.
maxOccurs 1
minOccurs Se asigna a la propiedad IsRequired de un miembro de datos (IsRequired es true cuando minOccurs es 1).
nillable Afecta a la asignación de tipo. Vea Asignación de tipo/primitivo.

<xs:element> con maxOccurs>1 dentro de un elemento <xs:sequence> (colecciones)

Las colecciones pueden ser de los siguientes tipos:

  • Colecciones normales (por ejemplo, matrices).

  • Colecciones de diccionarios (asignan un valor a otro; por ejemplo, un Hashtable).

  • La única diferencia entre un diccionario y una matriz de un tipo de par clave-valor está en el modelo de programación generado. Hay un mecanismo de anotación de esquema que se puede utilizar para indicar que un tipo determinado es una colección de diccionarios.

Las reglas para los atributos ref, block, default, fixed, forme id son las mismas que para el caso de que no se trate de una colección. Entre otros atributos se incluyen los de la tabla siguiente.

Atributo Schema
name Admitido, asigna a la propiedad ItemName en el atributo CollectionDataContractAttribute .
type Admitido, asigna al tipo almacenado en la colección.
maxOccurs Mayor que 1 o "ilimitado". El esquema de DC debería utilizar "ilimitado."
minOccurs ignorado.
nillable Afecta a la asignación de tipo. Este atributo se omite para las colecciones de diccionarios.

<xs:element> dentro de una declaración de elemento global <xs:schema>

  • Una declaración de elemento global (GED) que tiene el mismo nombre y espacio de nombres que un tipo en esquema o que define un tipo anónimo dentro de sí mismo, se dice que está asociado al tipo.

  • Exportación del esquema: las GED asociadas se generan para cada tipo generado, tanto simple como complejo.

  • Deserialización/serialización: las GED asociadas se utilizan como elementos raíz para el tipo.

  • Importación del esquema: las GED asociadas no se requieren y se omiten si siguen las reglas siguientes (a menos que definan tipos).

Atributo Schema
abstract Debe ser false para GED asociadas.
block Se prohíbe en GED asociadas.
default Se prohíbe en GED asociadas.
final Debe ser false para GED asociadas.
fixed Se prohíbe en GED asociadas.
id ignorado.
name Compatible. Vea la definición de GED asociadas.
nillable Debe ser true para las GED asociadas.
substitutionGroup Se prohíbe en GED asociadas.
type Admitido y debe coincidir con el tipo asociado para las GED asociadas (a menos que el elemento contenga un tipo anónimo).

<xs:element>: contenido

Contenido Schema
simpleType Admitido.*
complexType Admitido.*
unique ignorado.
key ignorado.
keyref ignorado.
(en blanco) Compatible.

* Usar la asignación simpleType y complexType, para los tipos anónimos es igual que para los tipos no anónimos, salvo que no hay ningún contrato de datos anónimo y, por tanto, se crea un contrato de datos con nombre, con un nombre generado derivado del nombre de elemento. Las reglas para los tipos anónimos están en la lista siguiente:

  • Detalle de implementación de WCF: si el nombre de xs:element no contiene puntos, el tipo anónimo se asigna a un tipo interno del tipo de contrato de datos externo. Si el nombre contiene puntos, el tipo de contrato de datos resultante es independiente (no un tipo interno).

  • El nombre de contrato de datos generado del tipo interno es el nombre de contrato de datos del tipo exterior seguido por un punto, el nombre del elemento, y la cadena “Type”.

  • Si un contrato de datos con este tipo de nombre ya existe, el nombre se hace único anexando "1", "2", "3", y así sucesivamente, hasta que se cree un nombre único.

Tipos simples: <xs:simpleType>

<xs:simpleType>: atributos

Atributo Schema
final ignorado.
id ignorado.
name Admitido, asigna al nombre de contrato de datos.

<xs:simpleType>: contenido

Contenido Schema
restriction Compatible. Asigna a contratos de datos de enumeración. Este atributo se omite si no coincide con el patrón de enumeración. Vea la sección de restricciones de xs:simpleType .
list Compatible. Asigna a contratos de datos de enumeración de marcas. Vea la sección de listas de xs:simpleType .
union Prohibido.

<xs:restriction>

  • Las restricciones de tipos complejos solo se admiten para base = "xs:anyType".

  • Las restricciones de tipos simples de xs:string que no tienen facetas de restricciones que no sean xs:enumeration están asignadas a contratos de datos de enumeración.

  • El resto de restricciones de tipos simples se asignan a los tipos que restringen. Por ejemplo, una restricción de xs:int se asigna a un entero, como hace xs:int . Para más información sobre la asignación de tipos primitivos, consulte Asignación de tipos o primitivos.

<xs:restriction>: atributos

Atributo Schema
base Debe ser un tipo simple admitido o xs:anyType.
id ignorado.

<xs:restriction> para el resto de casos: contenido

Contenido Schema
simpleType Si está presente, se debe derivar de un tipo primitivo admitido.
minExclusive ignorado.
minInclusive ignorado.
maxExclusive ignorado.
maxInclusive ignorado.
totalDigits ignorado.
fractionDigits ignorado.
length ignorado.
minLength ignorado.
maxLength ignorado.
enumeration ignorado.
whiteSpace ignorado.
pattern ignorado.
(en blanco) Compatible.

Enumeración

<xs:restriction> para enumeraciones: atributos

Atributo Schema
base Si está presente, debe ser xs:string.
id ignorado.

<xs:restriction> para enumeraciones: contenido

Contenido Schema
simpleType Si está presente, debe ser una restricción de enumeración admitida por el contrato de datos (esta sección).
minExclusive ignorado.
minInclusive ignorado.
maxExclusive ignorado.
maxInclusive ignorado.
totalDigits ignorado.
fractionDigits ignorado.
length Prohibido.
minLength Prohibido.
maxLength Prohibido.
enumeration Compatible. Se omite el "id" de enumeración y "value" se asigna al nombre del valor en el contrato de datos de enumeración.
whiteSpace Prohibido.
pattern Prohibido.
(vacío) Compatible; se asigna a un tipo de enumeración vacío.

En el siguiente código se muestra una clase de enumeración de C#.

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

Esta clase se asigna al esquema siguiente mediante el DataContractSerializer. Si los valores de la enumeración se inician en 1, no se generan bloques xs:annotation .

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

ElDataContractSerializer asigna tipos de enumeración marcados con System.FlagsAttribute a xs:list derivado de xs:string. No se admite ninguna otra variación de xs:list .

<xs:list>: atributos

Atributo Schema
itemType Prohibido.
id ignorado.

<xs:list>: contenido

Contenido Schema
simpleType Debe ser la restricción de xs:string utilizando la faceta xs:enumeration .

Si el valor de enumeración no sigue una progresión de potencia 2 (valor predeterminado para marcas), el valor se almacena en xs:annotation/xs:appInfo/ser:EnumerationValue .

Por ejemplo, el código siguiente marca un tipo de enumeración.

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

Este tipo asigna al esquema siguiente.

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

Herencia

Reglas Generales

Un contrato de datos puede heredar de otro contrato de datos. Tales contratos de datos asignan a una base y son derivados por tipos de extensión mediante la construcción de squema XML <xs:extension> .

Un contrato de datos no puede heredar de un contrato de datos de colección.

Por ejemplo, el código siguiente es un contrato de datos.

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

Este contrato de datos asigna a la declaración de tipos de esquema XML siguiente.

<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 Schema
id ignorado.
mixed Debe ser false.

<xs:complexContent>: contenido

Contenido Schema
restriction Prohibido, excepto cuando base = "xs:anyType". Lo último es equivalente a colocar directamente el contenido de xs:restriction bajo el contenedor de xs:complexContent.
extension Compatible. Asigna a la herencia del contrato de datos.

<xs:extension> en <xs:complexContent>: atributos

Atributo Schema
id ignorado.
base Compatible. Asigna al tipo de contrato de datos base desde el que este tipo hereda.

<xs:extension> en <xs:complexContent>: contenido

Las reglas son la mismas que para el contenido <xs:complexType> .

Si se proporciona un <xs:sequence> , sus elementos de miembro asignan a los miembros de datos adicionales que se encuentran en el contrato de datos derivado.

Si un tipo derivado contiene un elemento con el mismo nombre que un elemento en un tipo base, la declaración de elementos duplicados asigna a un miembro de datos con un nombre que se genera para que sea único. Los números enteros positivos se suman al nombre del miembro de datos ("member1", "member2", etc.) hasta que se encuentre un nombre único. De manera inversa:

  • Si un contrato de datos derivado tiene un miembro de datos con el mismo nombre y tipo que un miembro de datos en un contrato de datos base, DataContractSerializer genera este elemento correspondiente en el tipo derivado.

  • Si un contrato de datos derivado tiene un miembro de datos con el mismo nombre que un miembro de datos en un contrato de datos base pero un tipo diferente, el DataContractSerializer importa un esquema con un elemento del tipo xs:anyType en las declaraciones de tipos base y de tipos derivados. El nombre de tipo original se conserva en xs:annotations/xs:appInfo/ser:ActualType/@Name.

Ambas variaciones pueden conducir a un esquema con un modelo de contenido ambiguo, que depende del orden de los miembros de datos respectivos.

Asignación de tipo/primitivo.

El DataContractSerializer utiliza la asignación siguiente para los tipos primitivos del esquema XML.

Tipo XSD Tipo de .NET
anyType Object.
anySimpleType String.
duration TimeSpan.
dateTime DateTime.
dateTimeOffset DateTime y TimeSpan para el desplazamiento. Vea abajo Serialización de DateTimeOffset.
time String.
date String.
gYearMonth String.
gYear String.
gMonthDay String.
gDay String.
gMonth String.
boolean Boolean
base64Binary Matriz de tipoByte .
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.

Asignación de tipos ISerializable

En .NET Framework 1.0, ISerializable se introdujo como mecanismo general para serializar objetos de cara a la persistencia o la transferencia de datos. Hay muchos tipos de .NET Framework que implementan ISerializable y que pueden pasarse entre aplicaciones. DataContractSerializer proporciona de manera natural compatibilidad para las clases ISerializable . DataContractSerializer asigna tipos de esquema de implementación de ISerializable que solo difieren en cuanto al QName (nombre completo) del tipo y son colecciones de propiedades. Por ejemplo, DataContractSerializer asigna Exception al tipo XSD siguiente en el espacio de nombres 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>

El atributo opcional ser:FactoryType opcional declarado en el esquema de serialización de contrato de datos hace referencia a una clase de generador que puede deserializar el tipo. La clase de generador debe formar parte de la colección de tipos conocidos de la instancia de DataContractSerializer que se está usando. Para más información sobre los tipos conocidos, consulte Tipos conocidos de contrato de datos.

Esquema de serialización de DataContract

Varios esquemas exportados por los tipos de uso, elementos y atributos del DataContractSerializer , desde un espacio de nombres de serialización de contrato de datos especial:

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

A continuación, se muestra una declaración de esquema de serialización de contrato de datos 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>

Se debería tener en cuenta lo siguiente:

  • ser:char se introduce para representar caracteres Unicode de tipo Char.

  • El valuespace de xs:duration se reduce a un conjunto ordenado para que pueda asignarse a un TimeSpan.

  • FactoryType se utiliza en esquemas exportados a partir de tipos que se derivan de ISerializable.

Importación de esquemas no DataContract

DataContractSerializer tiene la opción ImportXmlTypes para permitir la importación de esquemas que no cumplen el perfil XSD DataContractSerializer (vea la propiedad Options ). Establecer esta opción en true habilita la aceptación de tipos de esquema no conformes y la asignación de ellos a la implementación siguiente, IXmlSerializable ajuste de una matriz de XmlNode (solo difiere el nombre de la clase).

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

Serialización de DateTimeOffset

DateTimeOffset no se trata como un tipo primitivo. En su lugar, se serializa como un elemento complejo con dos partes. La primera parte representa la fecha y hora, y la segunda parte representa el desplazamiento de la fecha y hora. En el siguiente código se muestra un ejemplo de un 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>

El esquema es de la siguiente manera.

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

Vea también