Importação e exportação de esquemas

  • Artigo

O WCF (Windows Communication Foundation) inclui um novo mecanismo de serialização, o DataContractSerializer. O DataContractSerializer converte entre objetos .NET Framework e XML (em ambas as direções). Além do serializador em si, o WCF inclui mecanismos associados de importação e exportação de esquema. OEsquema é uma descrição formal, precisa e legível por máquina da forma do XML que o serializador produz ou que o desserializador pode acessar. O WCF usa a XSD (linguagem de definição de esquema XML) do W3C (World Wide Web Consortium) como sua representação de esquema, que é amplamente interoperável com várias plataformas de terceiros.

O componente de importação de esquema, XsdDataContractImporter, usa um documento de esquema XSD e gera classes do .NET Framework (normalmente classes de contrato de dados) de modo que os formulários serializados correspondam ao esquema especificado.

Por exemplo, o seguinte fragmento de esquema:

XsdDataContractImporter importer = new XsdDataContractImporter();
importer.Options.Namespaces.Add(new KeyValuePair<string, string>("http://schemas.contoso.com/carSchema", "Contoso.Cars"));

Dim importer As New XsdDataContractImporter
importer.Options.Namespaces.Add(New KeyValuePair(Of String, String)("http://schemas.contoso.com/carSchema", "Contoso.Cars"))

gera o tipo a seguir (simplificado ligeiramente para melhor legibilidade).

[DataContract]
public partial class Vehicle : IExtensibleDataObject
{
    private int yearField;
    private string colorField;

    [DataMember]
    public int year
    {
        get { return this.yearField; }
        set { this.yearField = value; }
    }
    [DataMember]
    public string color
    {
        get { return this.colorField; }
        set { this.colorField = value; }
    }

    private ExtensionDataObject extensionDataField;
    public ExtensionDataObject ExtensionData
    {
        get { return this.extensionDataField; }
        set { this.extensionDataField = value; }
    }
}

Partial Class Vehicle
    Implements IExtensibleDataObject

    Private yearField As Integer
    Private colorField As String

    <DataMember()> _
    Public Property year() As Integer
        Get
            Return Me.yearField
        End Get
        Set
            Me.yearField = value
        End Set
    End Property

    <DataMember()> _
    Public Property color() As String
        Get
            Return Me.colorField
        End Get
        Set
            Me.colorField = value
        End Set
    End Property
    Private extensionDataField As ExtensionDataObject

    Public Property ExtensionData() As ExtensionDataObject _
        Implements IExtensibleDataObject.ExtensionData
        Get
            Return Me.extensionDataField
        End Get
        Set(ByVal value As ExtensionDataObject)
            Me.extensionDataField = value
        End Set
    End Property
End Class

Observe que o tipo gerado segue várias práticas recomendadas do contrato de dados (encontradas em Práticas recomendadas: controle de versão do contrato de dados):

O XsdDataContractExporter permite que você faça o contrário, usar tipos serializáveis com o DataContractSerializer e gerar um documento de Esquema XSD.

A fidelidade não é garantida

Não é garantido que o esquema ou os tipos façam uma viagem de ida e volta com fidelidade total. (Uma viagem de ida e volta significa importar um esquema para criar um conjunto de classes e exportar o resultado para criar um esquema novamente.) O mesmo esquema poderá não ser retornado. A reversão do processo também não é garantia de preservação da fidelidade. (Exportar um tipo para gerar seu esquema e importar o tipo de volta. É improvável que o mesmo tipo seja retornado.)

Tipos com suporte

O modelo de contrato de dados dá suporte apenas a um subconjunto limitado do esquema WC3. Os esquemas que não estiverem em conformidade com esse subconjunto causarão uma exceção durante o processo de importação. Por exemplo, não há como especificar que um membro de dados de um contrato de dados deve ser serializado como um atributo XML. Portanto, esquemas que exigem o uso de atributos XML não têm suporte e causarão exceções durante a importação, pois é impossível gerar um contrato de dados com a projeção XML correta.

Por exemplo, o fragmento de esquema a seguir não pode ser importado com as configurações de importação padrão.

<xs:complexType name="Vehicle">
  <xs:sequence>
    <xs:element name="year" type="xs:int" />
    <xs:element name="color" type="xs:string" />
  </xs:sequence>
  <xs:attribute name="engineHorsePower" type="xs:int" />
</xs:complexType>

Para saber mais, confira Referência de esquema de contrato de dados. Se um esquema não estiver em conformidade com as regras do contrato de dados, use um mecanismo de serialização diferente. Por exemplo, o XmlSerializer usa seu próprio mecanismo de importação de esquema separado. Além disso, há um modo de importação especial no qual o intervalo de esquema com suporte é expandido. Para saber mais, confira a seção sobre como gerar tipos IXmlSerializable em Importando esquema para gerar classes.

O XsdDataContractExporter dá suporte a qualquer tipo de .NET Framework que possa ser serializado com o DataContractSerializer. Para saber mais, confira Tipos compatíveis com o Serializador de Contrato de Dados. Observe que o esquema gerado usando o XsdDataContractExporter é normalmente feito de dados válidos que o XsdDataContractImporter pode usar (a menos que XmlSchemaProviderAttribute seja usado para personalizar o esquema).

Para saber mais sobre como usar o XsdDataContractImporter, confira Importando esquema para gerar classes.

Para saber mais sobre como usar o XsdDataContractExporter, confira Exportando esquemas de classes.

Confira também