Compartilhar via

Tipos XML e ADO.NET em contratos de dados

O modelo de contrato de dados do WCF (Windows Communication Foundation) dá suporte a determinados tipos que representam o XML diretamente. Quando esses tipos são serializados para XML, o serializador grava o conteúdo XML desses tipos sem nenhum processamento adicional. Os tipos com suporte são XmlElement, matrizes de XmlNode (mas não o tipo XmlNode em si), bem como tipos que implementam IXmlSerializable. DataSet e DataTable tipo, bem como conjuntos de dados tipados, são comumente usados na programação de banco de dados. Esses tipos implementam a IXmlSerializable interface e, portanto, são serializáveis no modelo de contrato de dados. Algumas considerações especiais para esses tipos são listadas no final deste tópico.

Tipos XML

Elemento Xml

O XmlElement tipo é serializado usando seu conteúdo XML. Por exemplo, usando o tipo a seguir.

[DataContract(Namespace=@"http://schemas.contoso.com")]
public class MyDataContract
{
    [DataMember]
    public XmlElement myDataMember;
    public void TestClass()
    {
        XmlDocument xd = new XmlDocument();
        myDataMember = xd.CreateElement("myElement");
        myDataMember.InnerText = "myContents";
        myDataMember.SetAttribute
         ("myAttribute","myValue");
    }
}

<DataContract([Namespace]:="http://schemas.contoso.com")> _
Public Class MyDataContract
    <DataMember()> _
    Public myDataMember As XmlElement

    Public Sub TestClass()
        Dim xd As New XmlDocument()
        myDataMember = xd.CreateElement("myElement")
        myDataMember.InnerText = "myContents"
        myDataMember.SetAttribute("myAttribute", "myValue")

    End Sub
End Class

Isso é serializado para XML da seguinte maneira:

<MyDataContract xmlns="http://schemas.contoso.com">  
    <myDataMember>  
        <myElement xmlns="" myAttribute="myValue">  
            myContents  
        </myElement>  
    </myDataMember>  
</MyDataContract>

Observe que um elemento <myDataMember> de membro de dados wrapper ainda está presente. Não há como remover esse elemento no modelo de contrato de dados. Os serializadores que lidam com esse modelo (o DataContractSerializer e NetDataContractSerializer) podem emitir atributos especiais nesse elemento wrapper. Esses atributos incluem o atributo "nil" da Instância de Esquema XML padrão (permitindo que ele XmlElement seja null) e o atributo "type" (permitindo XmlElement que seja usado polimorficamente). Além disso, os seguintes atributos XML são específicos para WCF: "Id", "Ref", "Type" e "Assembly". Esses atributos podem ser emitidos para dar suporte ao uso do XmlElement com o modo de preservação do grafo de objeto habilitado ou com o NetDataContractSerializer. (Para obter mais informações sobre o modo de preservação do grafo de objeto, consulte Serialização e Desserialização.)

Matrizes ou coleções de XmlElement são permitidas e são tratadas como qualquer outra matriz ou coleção. Ou seja, há um elemento wrapper para toda a coleção e um elemento wrapper separado (semelhante ao <myDataMember> no exemplo anterior) para cada XmlElement na matriz.

Na desserialização, um XmlElement é criado pelo desserializador do XML de entrada. Um pai XmlDocument válido é fornecido pelo desserializador.

Verifique se o fragmento XML desserializado em um XmlElement define todos os prefixos que ele usa e não depende de definições de prefixo de elementos ancestrais. Essa é uma preocupação somente ao usar o DataContractSerializer para acessar XML de uma fonte diferente (não DataContractSerializer).

Quando usado com o DataContractSerializer, o XmlElement pode ser atribuído polimorficamente, mas apenas a um membro de dados do tipo Object. Mesmo que ele implemente IEnumerable, um XmlElement não pode ser usado como um tipo de coleção e não pode ser atribuído a um IEnumerable membro de dados. Assim como acontece com todas as atribuições polimórficas, o DataContractSerializer emite o nome do contrato de dados no XML resultante. Nesse caso, é "XmlElement" no http://schemas.datacontract.org/2004/07/System.Xml namespace.

Com a NetDataContractSerializer, qualquer atribuição polimórfica válida de XmlElement (para Object ou IEnumerable) é suportada.

Não tente usar nenhum dos serializadores com os tipos derivados de XmlElement, independentemente de serem atribuídos polimorficamente ou não.

Matriz de XmlNode

Usar matrizes de XmlNode é muito semelhante a usar XmlElement. Usar matrizes de XmlNode oferece mais flexibilidade do que usar XmlElement. Você pode escrever vários elementos dentro do elemento de encapsulamento do membro de dados. Você também pode injetar conteúdo diferente de elementos dentro do elemento de encapsulamento do membro de dados, como comentários XML. Por fim, você pode colocar atributos no elemento de membro de dados de encapsulamento. Tudo isso pode ser alcançado ao se povoar o array de XmlNode com classes derivadas específicas de XmlNode, como XmlAttribute, XmlElement ou XmlComment. Por exemplo, usando o tipo a seguir.

[DataContract(Namespace="http://schemas.contoso.com")]
public class MyDataContract
{
    [DataMember]
    public XmlNode[] myDataMember = new XmlNode[4];
    public void TestClass()
    {
        XmlDocument xd = new XmlDocument();
        XmlElement xe = xd.CreateElement("myElement");
        xe.InnerText = "myContents";
        xe.SetAttribute
         ("myAttribute","myValue");
    
        XmlAttribute atr = xe.Attributes[0];
        XmlComment cmnt = xd.CreateComment("myComment");
        
      myDataMember[0] = atr;
      myDataMember[1] = cmnt;
      myDataMember[2] = xe;
      myDataMember[3] = xe;
    }
}

<DataContract([Namespace]:="http://schemas.contoso.com")> _
Public Class MyDataContract
    <DataMember()> _
    Public myDataMember(3) As XmlNode

    Public Sub TestClass()
        Dim xd As New XmlDocument()
        Dim xe As XmlElement = xd.CreateElement("myElement")
        xe.InnerText = "myContents"
        xe.SetAttribute("myAttribute", "myValue")

        Dim atr As XmlAttribute = xe.Attributes(0)
        Dim cmnt As XmlComment = xd.CreateComment("myComment")

        myDataMember(0) = atr
        myDataMember(1) = cmnt
        myDataMember(2) = xe
        myDataMember(3) = xe

    End Sub

End Class

Quando serializado, o XML resultante é semelhante ao código a seguir.

<MyDataContract xmlns="http://schemas.contoso.com">  
  <myDataMember myAttribute="myValue">  
     <!--myComment-->  
     <myElement xmlns="" myAttribute="myValue">  
 myContents  
     </myElement>  
     <myElement xmlns="" myAttribute="myValue">  
       myContents  
     </myElement>  
  </myDataMember>  
</MyDataContract>

Observe que o elemento wrapper do membro de dados <myDataMember> contém um atributo, um comentário e dois elementos. Estas são as quatro instâncias XmlNode que foram serializadas.

Uma matriz de XmlNode que resulta em XML inválido não pode ser serializada. Por exemplo, uma matriz de duas XmlNode instâncias em que a primeira é uma XmlElement e a segunda é XmlAttribute inválida, pois essa sequência não corresponde a nenhuma instância XML válida (não há lugar para anexar o atributo).

Na desserialização de uma matriz de XmlNode, os nós são criados e preenchidos com informações do XML de entrada. Um pai XmlDocument válido é fornecido pelo desserializador. Todos os nós são desserializados, incluindo todos os atributos no elemento membro de dados wrapper, mas excluindo os atributos colocados lá pelos serializadores do WCF (como os atributos usados para indicar a atribuição polimórfica). A ressalva sobre definir todos os prefixos de namespace no fragmento XML aplica-se também à desserialização de matrizes de XmlNode, assim como na desserialização de XmlElement.

Ao usar os serializadores com a preservação do grafo de objetos ativada, a igualdade de objetos só é preservada no nível de matrizes XmlNode, não em instâncias individuais XmlNode.

Não tente serializar uma matriz de XmlNode onde um ou mais dos nós estão definidos como null. É permitido que todo o membro da matriz seja null, mas não para qualquer indivíduo XmlNode contido na matriz. Se todo o membro da matriz for nulo, o elemento membro de dados wrapper conterá um atributo especial que indica que ele é nulo. Na desserialização, todo o membro da matriz também se torna nulo.

Somente matrizes regulares de XmlNode são tratadas especialmente pelo serializador. Os membros de dados declarados como outros tipos de coleção que contêm XmlNode, ou membros de dados declarados como matrizes de tipos derivados de XmlNode, não são tratados de maneira especial. Assim, eles normalmente não são serializáveis, a menos que também atendam a um dos outros critérios para serialização.

Matrizes ou coleções de matrizes de XmlNode são permitidas. Há um elemento wrapper para toda a coleção e um elemento wrapper separado (semelhante ao <myDataMember> no exemplo anterior) para cada conjunto de XmlNode na matriz ou coleção externa.

Preencher um membro de dados do tipo Array de Object ou Array de IEnumerable com instâncias XmlNode não resulta no membro de dados sendo tratado como instâncias Array de XmlNode. Cada membro da matriz é serializado separadamente.

Quando usado com o DataContractSerializer, as matrizes de XmlNode podem ser atribuídas polimorficamente, mas apenas a um membro de dados do tipo Object. Embora implemente IEnumerable, um array de XmlNode não pode ser usado como tipo de coleção nem ser atribuído a um membro de dados IEnumerable. Assim como acontece com todas as atribuições polimórficas, o DataContractSerializer emite o nome do contrato de dados no XML resultante – nesse caso, é "ArrayOfXmlNode" no http://schemas.datacontract.org/2004/07/System.Xml namespace. Quando usado com NetDataContractSerializer, há suporte para qualquer atribuição válida de uma matriz XmlNode.

Considerações sobre esquema

Para obter detalhes sobre o mapeamento de esquema de tipos XML, consulte Referência de esquema de contrato de dados. Esta seção fornece um resumo dos pontos importantes.

Um membro de dados do tipo XmlElement é mapeado para um elemento definido usando o tipo anônimo a seguir.

<xsd:complexType>  
   <xsd:sequence>  
      <xsd:any minOccurs="0" processContents="lax" />  
   </xsd:sequence>  
</xsd:complexType>

Um membro de dados do tipo Matriz de XmlNode é mapeado para um elemento definido usando o seguinte tipo anônimo.

<xsd:complexType mixed="true">  
   <xsd:sequence>  
      <xsd:any minOccurs="0" maxOccurs="unbounded" processContents="lax" />  
   </xsd:sequence>  
   <xsd:anyAttribute/>  
</xsd:complexType>

Tipos que implementam a interface IXmlSerialable

Os tipos que implementam a IXmlSerializable interface são totalmente compatíveis com o DataContractSerializer. O XmlSchemaProviderAttribute atributo sempre deve ser aplicado a esses tipos para controlar seu esquema.

Há três variedades de tipos que implementam IXmlSerializable: tipos que representam conteúdo arbitrário, tipos que representam um único elemento e tipos herdados DataSet .

  • Os tipos de conteúdo usam um método de provedor de esquema especificado pelo XmlSchemaProviderAttribute atributo. O método não retorna nulle a IsAny propriedade no atributo é deixada no valor padrão de false. Esse é o uso mais comum de IXmlSerializable tipos.

  • Os tipos de elemento são usados quando um IXmlSerializable tipo deve controlar seu próprio nome de elemento raiz. Para marcar um tipo como um tipo de elemento, defina a propriedade IsAny no atributo XmlSchemaProviderAttribute para true, ou retorne nulo no método do provedor de esquema. Ter um método de provedor de esquema é opcional para tipos de elementos– você pode especificar nulo em vez do nome do método no XmlSchemaProviderAttribute. No entanto, se IsAny for true e um método de provedor de esquema for especificado, o método deverá retornar nulo.

  • Tipos herdados DataSet são tipos IXmlSerializable que não são marcados com o atributo XmlSchemaProviderAttribute. Em vez disso, eles dependem do GetSchema método para a geração de esquema. Esse padrão é usado para o tipo DataSet e seu conjunto de dados tipado deriva uma classe em versões anteriores do .NET Framework, mas agora está obsoleto e tem compatibilidade apenas por motivos herdados. Não confie nesse padrão e sempre aplique o XmlSchemaProviderAttribute aos seus tipos de IXmlSerializable.

Tipos de conteúdo IXmlSerializable

Ao serializar um membro de dados de um tipo que implementa IXmlSerializable e é um tipo de conteúdo conforme definido anteriormente, o serializador grava o elemento de envoltório para o membro de dados e passa o controle para o método WriteXml. A WriteXml implementação pode gravar qualquer XML, incluindo a adição de atributos ao elemento wrapper. Depois que WriteXml é concluído, o serializador fecha o elemento.

Ao desserializar um membro de dados de um tipo que implementa IXmlSerializable e é um tipo de conteúdo conforme definido anteriormente, o desserializador posiciona o leitor XML no elemento wrapper do membro de dados e passa o controle para o ReadXml método. O método deve ler todo o elemento, incluindo as marcas inicial e final. Verifique se o ReadXml código manipula o caso em que o elemento está vazio. Além disso, sua implementação de ReadXml não deve depender do elemento wrapper que está sendo nomeado de uma maneira específica. O nome escolhido pelo serializador pode variar.

É permitido atribuir IXmlSerializable tipos de conteúdo polimorficamente, por exemplo, a membros de dados do tipo Object. Também é permitido que as instâncias de tipo sejam nulas. Por fim, é possível usar tipos IXmlSerializable com a preservação do grafo de objetos habilitada e com o NetDataContractSerializer. Todos esses recursos exigem que o serializador WCF anexe determinados atributos ao elemento de invólucro ("nil" e "type" no namespace da Instância de Esquema XML e "Id", "Ref", "Type" e "Assembly" em um namespace específico do WCF).

Atributos a serem ignorados ao implementar ReadXml

Antes de passar o controle para o código ReadXml, o desserializador examina o elemento XML, detecta esses atributos XML especiais e atua neles. Por exemplo, se "nil" for true, um valor nulo será desserializado e ReadXml não será chamado. Se o polimorfismo for detectado, o conteúdo do elemento será desserializado como se fosse um tipo diferente. A implementação do tipo atribuído polimorficamente de ReadXml é chamada. De qualquer forma, uma ReadXml implementação deve ignorar esses atributos especiais porque eles são tratados pelo desserializador.

Considerações de esquema para tipos de conteúdo IXmlSerializable

Ao exportar o esquema de um tipo de conteúdo IXmlSerializable, o método do provedor de esquema é chamado. Um XmlSchemaSet é passado para o método do provedor de esquema. O método pode adicionar qualquer esquema válido ao conjunto de esquemas. O conjunto de esquemas contém o esquema que já é conhecido no momento em que ocorre a exportação de esquema. Quando o método do provedor de esquema deve adicionar um item ao conjunto de esquemas, ele deve determinar se já existe um XmlSchema namespace com o namespace apropriado no conjunto. Se isso acontecer, o método do provedor de esquema deverá adicionar o novo item ao existente XmlSchema. Caso contrário, ele deve criar uma nova XmlSchema instância. Isso é importante se matrizes de IXmlSerializable tipos estiverem sendo usadas. Por exemplo, se você tiver um tipo IXmlSerializable exportado como tipo "A" no namespace "B", é possível que, quando o método do provedor de esquema for chamado, o esquema já contenha o esquema de "B" para manter o tipo "ArrayOfA".

Além de adicionar tipos ao XmlSchemaSet, o método do provedor de esquema para tipos de conteúdo deve retornar um valor não nulo. Ele pode retornar um XmlQualifiedName que especifica o nome do tipo de esquema a ser usado para o tipo fornecido IXmlSerializable . Esse nome qualificado também serve como o nome e o namespace do contrato de dados para o tipo. É permitido retornar um tipo que não existe no conjunto de esquemas imediatamente quando o método do provedor de esquema retorna. No entanto, espera-se que, no momento em que todos os tipos relacionados são exportados (o Export método é chamado para todos os tipos relevantes no XsdDataContractExporter e a Schemas propriedade é acessada), o tipo existe no conjunto de esquemas. Acessar a propriedade Schemas antes que todas as chamadas Export relevantes sejam feitas pode resultar em um XmlSchemaException. Para obter mais informações sobre o processo de exportação, consulte Exportando esquemas de classes.

O método do provedor de esquema também pode retornar o XmlSchemaType para usar. O tipo pode ou não ser anônimo. Se for anônimo, o esquema do IXmlSerializable tipo será exportado como um tipo anônimo sempre que o IXmlSerializable tipo for usado como um membro de dados. O tipo IXmlSerializable ainda tem um nome de contrato de dados e um namespace. (Isso é determinado conforme descrito em Nomes de Contrato de Dados , exceto que o DataContractAttribute atributo não pode ser usado para personalizar o nome.) Se não for anônimo, deve ser um dos tipos no XmlSchemaSet. Esse caso é equivalente a retornar o XmlQualifiedName do tipo.

Além disso, uma declaração de elemento global é exportada para o tipo. Se o tipo não tiver o XmlRootAttribute atributo aplicado a ele, o elemento terá o mesmo nome e namespace que o contrato de dados e sua propriedade "nillable" será true. A única exceção a isso é o namespace de esquema (http://www.w3.org/2001/XMLSchema); se o contrato de dados do tipo estiver nesse namespace, o elemento global correspondente estará no namespace em branco porque é proibido adicionar novos elementos ao namespace de esquema. Se o tipo tiver o XmlRootAttribute atributo aplicado a ele, a declaração de elemento global será exportada usando as seguintes propriedades: ElementName, Namespacee IsNullable. Os padrões com XmlRootAttribute aplicados são o nome do contrato de dados, um namespace em branco e "nillable" sendo verdadeiro.

As mesmas regras de declaração de elemento global se aplicam aos tipos de conjunto de dados herdados. Observe que o XmlRootAttribute não pode substituir as declarações de elementos globais adicionadas por meio de código personalizado, seja utilizando o método do provedor de esquema no XmlSchemaSet ou através do GetSchema para tipos de conjuntos de dados legados.

Tipos de elemento IXmlSerializable

os tipos de elemento IXmlSerializable têm a propriedade IsAny definida como true ou têm o método de provedor de esquema retornado null.

Serializar e desserializar um tipo de elemento é muito semelhante à serialização e desserialização de um tipo de conteúdo. No entanto, há algumas diferenças importantes:

  • Espera-se que a implementação de WriteXml grave exatamente um elemento (que, naturalmente, poderia conter vários elementos filho). Ele não deve escrever atributos fora desse único elemento, vários elementos irmãos ou conteúdo misto. O elemento pode estar vazio.

  • A ReadXml implementação não deve ler o elemento wrapper. Espera-se que ele leia o único elemento que WriteXml produz.

  • Ao serializar um tipo de elemento com frequência (por exemplo, como um membro de dados em um contrato de dados), o serializador gera um elemento envoltório antes de chamar WriteXml, tal como ocorre com tipos de conteúdo. No entanto, ao serializar um tipo de elemento no nível superior, o serializador normalmente não gera um elemento wrapper em torno do elemento que WriteXml grava, a menos que um nome raiz e namespace tenham sido explicitamente especificados ao construir o serializador nos construtores DataContractSerializer ou NetDataContractSerializer. Para obter mais informações, consulte Serialização e Desserialização.

  • Ao serializar um tipo de elemento no nível superior sem especificar o nome raiz e o namespace em tempo de construção, WriteStartObject e WriteEndObject essencialmente não faz nada e WriteObjectContent chama WriteXml. Nesse modo, o objeto que está sendo serializado não pode ser nulo e não pode ser atribuído polimorficamente. Além disso, a preservação do grafo de objetos não pode ser habilitada e o NetDataContractSerializer não pode ser usado.

  • Ao desserializar um tipo de elemento no nível superior sem especificar o nome raiz e o namespace durante a construção, IsStartObject retorna true se puder encontrar o início de qualquer elemento. ReadObject com o parâmetro verifyObjectName configurado como true comporta-se da mesma maneira que IsStartObject antes de realmente ler o objeto. ReadObject em seguida, passa o controle para o ReadXml método.

O esquema exportado para tipos de elemento é o mesmo que para o tipo XmlElement, conforme descrito em uma seção anterior, exceto que o método do provedor de esquema pode adicionar qualquer esquema adicional ao XmlSchemaSet, assim como acontece com tipos de conteúdo. O uso do XmlRootAttribute atributo com tipos de elemento não é permitido e declarações de elemento global nunca são emitidas para esses tipos.

Diferenças do XmlSerializer

A IXmlSerializable interface e os XmlSchemaProviderAttributeXmlRootAttribute atributos também são compreendidos pelo XmlSerializer . No entanto, há algumas diferenças na forma como elas são tratadas no modelo de contrato de dados. As diferenças importantes são resumidas no seguinte:

  • O método de provedor de esquema deve ser público para ser utilizável no XmlSerializer, mas não precisa ser público para ser utilizável no modelo de contrato de dados.

  • O método do provedor de esquema é chamado quando IsAny é verdadeiro no modelo de contrato de dados, mas não com o XmlSerializer.

  • Quando o XmlRootAttribute atributo não está presente para tipos de conteúdo ou conjunto de dados herdados, o XmlSerializer elemento exporta uma declaração de elemento global no namespace em branco. No modelo de contrato de dados, o namespace usado normalmente é o namespace do contrato de dados, conforme descrito anteriormente.

Lembre-se dessas diferenças ao criar tipos usados com ambas as tecnologias de serialização.

Importando esquema IXmlSerializable

Ao importar um esquema gerado de IXmlSerializable tipos, há algumas possibilidades:

  • O esquema gerado pode ser um esquema de contrato de dados válido, conforme descrito na Referência de Esquema de Contrato de Dados. Nesse caso, o esquema pode ser importado como de costume e tipos de contrato de dados regulares são gerados.

  • O esquema gerado pode não ser um esquema de contrato de dados válido. Por exemplo, seu método de provedor de esquema pode gerar um esquema que envolve atributos XML que não têm suporte no modelo de contrato de dados. Nesse caso, você pode importar o esquema como IXmlSerializable tipos. Esse modo de importação não está ativado por padrão, mas pode ser facilmente habilitado– por exemplo, com a opção /importXmlTypes de linha de comando para a Ferramenta de Utilitário de Metadados do ServiceModel (Svcutil.exe). Isso é descrito em detalhes no esquema de importação para gerar classes. Observe que você deve trabalhar diretamente com o XML para suas instâncias de tipo. Você também pode considerar o uso de uma tecnologia de serialização diferente que dá suporte a uma gama mais ampla de esquemas – consulte o tópico sobre como usar o XmlSerializer.

  • Talvez você queira reutilizar seus tipos existentes IXmlSerializable no proxy em vez de gerar novos. Nesse caso, o recurso de tipos referenciados descrito no tópico Importar Esquema para Gerar Tipos pode ser usado para indicar o tipo a ser reutilizado. Isso corresponde ao uso da opção /reference no svcutil.exe, que especifica o assembly que contém os tipos a serem reutilizados.

Representando XML arbitrário em contratos de dados

O XmlElement, a matriz XmlNode e os tipos IXmlSerializable permitem injetar XML arbitrário no modelo de contrato de dados. DataContractSerializer e NetDataContractSerializer passam este conteúdo XML para o gravador XML em uso, sem interferir no processo. No entanto, os gravadores XML podem impor certas restrições ao XML que eles gravam. Especificamente, aqui estão alguns exemplos importantes:

  • Os gravadores XML normalmente não permitem uma declaração de documento XML (por exemplo, <?xml version='1.0' ?>) no meio da gravação de outro documento. Você não pode pegar um documento XML completo e serializá-lo como um Array do membro de dados XmlNode. Para fazer isso, você precisa remover a declaração do documento ou usar seu próprio esquema de codificação para representá-la.

  • Todos os gravadores XML fornecidos com WCF rejeitam instruções de processamento XML (<? ... ?>) e definições de tipo de documento (<! ... >), porque elas não são permitidas em mensagens SOAP. Novamente, você pode usar seu próprio mecanismo de codificação para contornar essa restrição. Se você precisar incluí-los em seu XML resultante, você poderá escrever um codificador personalizado que usa gravadores XML que dão suporte a eles.

  • Ao implementar WriteXml, evite chamar o método WriteRaw no gravador XML. O WCF usa uma variedade de codificações XML (incluindo binárias), é muito difícil ou impossível usar WriteRaw de modo que o resultado seja utilizável em qualquer codificação.

  • Ao implementar WriteXml, evite usar os métodos WriteEntityRef e WriteNmToken que não têm suporte nos gravadores XML fornecidos pelo WCF.

Usando DataSet, DataSet Digitado e DataTable

O uso desses tipos é totalmente compatível com o modelo de contrato de dados. Ao usar esses tipos, considere os seguintes pontos:

  • O esquema para esses tipos (especialmente DataSet e suas classes derivadas tipadas) pode não ser interoperável com algumas plataformas não WCF ou pode resultar em pouca usabilidade quando utilizadas nessas plataformas. Além disso, o uso do DataSet tipo pode ter implicações de desempenho. Por fim, isso pode dificultar a versão do aplicativo no futuro. Considere usar tipos de contrato de dados definidos explicitamente em vez de DataSet tipos em seus contratos.

  • Ao importar DataSet ou DataTable esquema, é importante referenciar esses tipos. Com a ferramenta de linha de comando Svcutil.exe, isso pode ser feito passando o nome do assembly System.Data.dll para a opção /reference. Se estiver importando o esquema de conjunto de dados tipado, você deverá referenciar o tipo do conjunto de dados tipado. Com Svcutil.exe, passe o local do assembly do conjunto de dados tipado para a opção /reference . Para obter mais informações sobre tipos de referência, consulte o esquema de importação para gerar classes.

O suporte para Conjuntos de Dados digitados no modelo de contrato de dados é limitado. Os Conjuntos de Dados Tipados podem ser serializados e desserializados e podem exportar seu esquema. No entanto, a importação de esquema do Contrato de Dados não pode gerar novos tipos tipados de DataSet a partir do esquema, já que apenas pode reutilizar os existentes. Você pode apontar para um DataSet tipado existente usando a opção /r no Svcutil.exe. Se você tentar usar um Svcutil.exe sem a opção /r em um serviço que usa um conjunto de dados tipado, um serializador alternativo (XmlSerializer) será selecionado automaticamente. Se você precisar usar o DataContractSerializer e gerar DataSets do esquema, poderá usar o seguinte procedimento: gerar os tipos de DataSets tipado (usando a ferramenta Xsd.exe com a opção /d no serviço), compilar os tipos e, em seguida, apontá-los usando a opção /r no Svcutil.exe.

Consulte também

  • Last updated on