Partilhar via

Tipos XML e ADO.NET em contratos de dados

O modelo de contrato de dados do Windows Communication Foundation (WCF) oferece suporte a determinados tipos que representam XML diretamente. Quando esses tipos são serializados em XML, o serializador grava o conteúdo XML desses tipos sem qualquer processamento adicional. Os tipos suportados são XmlElement, matrizes de XmlNode (mas não o XmlNode tipo em si), bem como tipos que implementam IXmlSerializable. O DataSet e DataTable type, 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 estão listadas no final deste tópico.

Tipos XML

Elemento Xml

O XmlElement tipo é serializado usando seu conteúdo XML. Por exemplo, utilizando o seguinte modelo.

[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 do wrapper ainda está presente. Não é possível remover esse elemento no modelo de contrato de dados. Os serializadores que manipulam esse modelo (o DataContractSerializer e NetDataContractSerializer) podem emitir atributos especiais para esse elemento wrapper. Esses atributos incluem o atributo "nil" padrão da instância do esquema XML (permitindo que o XmlElement seja null) e o atributo "type" (permitindo XmlElement ser usado polimorficamente). Além disso, os seguintes atributos XML são específicos do WCF: "Id", "Ref", "Type" e "Assembly". Esses atributos podem ser emitidos para suportar o uso do XmlElement com o modo de preservação do gráfico de objetos habilitado ou com o NetDataContractSerializer. (Para obter mais informações sobre o modo de preservação do gráfico de objetos, 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 invólucro para toda a coleção e um elemento invólucro separado (semelhante ao <myDataMember> anterior) para cada XmlElement na matriz.

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

Certifique-se de que o fragmento XML que é desserializado para um XmlElement define todos os prefixos que ele usa e não depende de nenhuma definição de prefixo de elementos ancestrais. Esta é uma preocupação apenas 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. Apesar de implementar IEnumerable, um XmlElement não pode ser usado como um tipo de colecção e não pode ser atribuído a um membro de dados IEnumerable. Como em 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 o NetDataContractSerializer, qualquer atribuição polimórfica válida de XmlElement (para Object ou IEnumerable) é suportada.

Não tente usar nenhum dos serializadores com tipos derivados de XmlElement, quer eles sejam atribuídos polimorficamente ou não.

Matriz de XmlNode

Usar matrizes de XmlNode é muito semelhante ao uso de XmlElement. Utilizar arrays de XmlNode oferece mais flexibilidade do que usar XmlElement. Você pode escrever vários elementos dentro do elemento de agrupamento do membro de dados. Além de elementos, você também pode injetar conteúdo como comentários XML dentro do elemento de encapsulamento do membro de dados. Finalmente, você pode adicionar atributos ao elemento de dados de encapsulamento. Tudo isso pode ser alcançado preenchendo a matriz de XmlNode com classes derivadas específicas de XmlNode como XmlAttribute, XmlElement ou XmlComment. Por exemplo, utilizando o seguinte modelo.

[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 de embrulho do membro de dados <myDataMember> contém um atributo, um comentário e dois elementos. Estas são as quatro XmlNode instâncias que foram serializadas.

Uma matriz de XmlNode que resulta em XML inválido não pode ser serializada. Por exemplo, um array de duas XmlNode instâncias onde a primeira é uma XmlElement e a segunda é uma XmlAttribute inválida, porque 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 um array 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 quaisquer atributos no elemento de membro de dados do wrapper, mas excluindo os atributos colocados lá pelos serializadores WCF (como os atributos usados para indicar a atribuição polimórfica). A ressalva sobre a definição de todos os prefixos de namespace no fragmento XML aplica-se à desserialização de arrays de XmlNode da mesma forma que se aplica à desserialização de XmlElement.

Ao usar os serializadores com a preservação de gráficos de objetos ativada, a igualdade de objetos é preservada apenas no nível de XmlNode matrizes, não em instâncias individuais XmlNode .

Não tente serializar uma matriz de XmlNode onde um ou mais dos nós está definido 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 estiver nulo, o elemento de dados do invólucro conterá um atributo especial que indica que está nulo. Na desserialização, todo o membro da matriz também se torna nulo.

Apenas matrizes regulares de XmlNode são tratadas especialmente pelo serializador. Os membros de dados declarados como outros tipos de coleta que contêm XmlNode, ou os membros de dados declarados como matrizes de tipos derivados de XmlNode, não são tratados especialmente. 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> exemplo anterior) para cada array de XmlNode na matriz externa ou coleção.

O preenchimento de um membro de dados do tipo Array de Object ou Array de IEnumerable com instâncias XmlNode não faz com que o membro de dados seja tratado como uma instância Array de XmlNode. Cada membro da matriz é serializado separadamente.

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

Considerações sobre o esquema

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

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

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

Um membro de dados do tipo Array 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 IXmlSerializable

Os tipos que implementam a interface IXmlSerializable são totalmente suportados pelo DataContractSerializer. O XmlSchemaProviderAttribute atributo deve sempre 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 em seu valor padrão de false. Este é o uso mais comum de IXmlSerializable tipos.

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

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

Tipos de conteúdo IXmlSerializable

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

Ao desserializar um membro de dados de um tipo que implemente IXmlSerializable e seja 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 método ReadXml. O método deve ler o elemento inteiro, incluindo as tags start e end. Certifique-se de que seu ReadXml código lida com o caso em que o elemento está vazio. Além disso, sua ReadXml implementação não deve depender do elemento wrapper ser 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. Finalmente, é possível utilizar tipos IXmlSerializable com a preservação do gráfico de objetos ativada e com o NetDataContractSerializer. Todos esses recursos exigem que o serializador WCF anexe certos atributos ao elemento wrapper ("nil" e "type" no namespace XML Schema Instance e "Id", "Ref", "Type" e "Assembly" em um namespace específico do WCF).

Atributos a serem ignorados ao implementar o ReadXml

Antes de passar o controle para o ReadXml código, o desserializador examina o elemento XML, deteta esses atributos XML especiais e age sobre eles. Por exemplo, se "nil" é true, um valor nulo é desserializado e ReadXml não é chamado. Se o polimorfismo for detetado, o conteúdo do elemento será desserializado como se fosse um tipo diferente. A implementação do ReadXml tipo atribuído polimorficamente é chamada. Em qualquer caso, a implementação ReadXml deve ignorar esses atributos especiais, uma vez que são manipulados 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 fornecedor 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 do esquema. Quando o método do provedor de esquema deve adicionar um item ao conjunto de esquemas, ele deve determinar se um XmlSchema com o namespace apropriado já existe no conjunto. Se isso acontecer, o método do provedor de esquema deve adicionar o novo item ao arquivo 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 IXmlSerializable tipo que é exportado como tipo "A" no namespace "B", é possível que, no momento em que o método do provedor de esquema é chamado, o conjunto de esquemas já contenha o esquema para "B" para conter 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 determinado IXmlSerializable tipo. Esse nome qualificado também serve como o nome do contrato de dados e namespace 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 método Export é chamado para todos os tipos relevantes em XsdDataContractExporter e a propriedade Schemas é acessada), o tipo exista no conjunto de esquemas. O acesso à propriedade Schemas antes de todas as chamadas relevantes Export terem sido 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 para o tipo IXmlSerializable é exportado como um tipo anónimo sempre que o tipo IXmlSerializable é usado como membro de dados. O IXmlSerializable tipo ainda tem um nome de contrato de dados e 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. Este caso equivale a devolver 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 do 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 do 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 aplicado são o nome do contrato de dados, um namespace em branco e "nillable" sendo true.

As mesmas regras de declaração de elemento global se aplicam a tipos de conjuntos de dados herdados. Observe que o XmlRootAttribute não pode substituir as declarações de elemento global adicionadas através de código personalizado ao XmlSchemaSet, seja usando o método do provedor de esquema ou através do GetSchema para tipos de conjuntos de dados herdados.

Tipos de elementos IXmlSerializable

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

Serializar e desserializar um tipo de elemento é muito semelhante a serializar e desserializar um tipo de conteúdo. No entanto, existem algumas diferenças importantes:

  • Espera-se que a WriteXml implementação escreva exatamente um elemento (que pode, é claro, conter vários elementos filho). Não deve escrever atributos fora deste ú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 leia o único elemento que WriteXml produz.

  • Ao serializar um tipo de elemento regularmente (por exemplo, como um membro de dados em um contrato de dados), o serializador produz um elemento wrapper antes de chamar WriteXml, como acontece com os tipos de conteúdo. No entanto, ao serializar um tipo de elemento no nível superior, o serializador normalmente não produz nenhum elemento wrapper em torno do elemento que o WriteXml cria, a não ser que um nome de raiz e um namespace sejam especificados explicitamente 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 da raiz e namespace no momento da 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 gráfico de objeto não pode ser ativada e o NetDataContractSerializer não pode ser usado.

  • Ao desserializar um tipo de elemento no nível superior sem especificar o nome da raiz e o namespace no momento da construção, IsStartObject retorna true se puder encontrar o início de qualquer elemento. ReadObject com o parâmetro verifyObjectName definido para 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, tal como descrito numa secção anterior, exceto que o método do fornecedor de esquema pode adicionar qualquer esquema adicional ao XmlSchemaSet, tal como acontece com tipos de conteúdo. O uso do atributo com tipos de XmlRootAttribute elemento não é permitido, e declarações de elemento global nunca são emitidas para esses tipos.

Diferenças do XmlSerializer

A interface IXmlSerializable e os atributos XmlSchemaProviderAttribute e XmlRootAttribute também são compreendidos pelo XmlSerializer. No entanto, existem algumas diferenças na forma como estes são tratados no modelo de contrato de dados. As diferenças importantes são resumidas da seguinte forma:

  • O método do 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 atributo XmlRootAttribute não está presente para tipos de conteúdo ou para conjuntos de dados legados, o XmlSerializer 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.

Esteja ciente dessas diferenças ao criar tipos que são usados com ambas as tecnologias de serialização.

Importando esquema IXmlSerializable

Ao importar um esquema gerado a partir de IXmlSerializable tipos, existem algumas possibilidades:

  • O esquema gerado pode ser um esquema de contrato de dados válido, conforme descrito em 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 esquema que envolve atributos XML que não são suportados no modelo de contrato de dados. Nesse caso, você pode importar o esquema como IXmlSerializable tipos. Este modo de importação não está ativado por padrão, mas pode ser facilmente ativado – por exemplo, com a opção de linha de comando /importXmlTypes para a ServiceModel Metadata Utility Tool (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 ofereça suporte a uma gama mais ampla de esquema – consulte o tópico sobre como usar o XmlSerializer.

  • Você pode querer reutilizar seus tipos existentes IXmlSerializable no proxy em vez de gerar novos. Nesse caso, o recurso de tipos referenciados descrito no tópico Importando esquema para gerar tipos pode ser usado para indicar o tipo a ser reutilizado. Isso corresponde ao uso do interruptor no svcutil.exe, que especifica o conjunto/compilação que contém os tipos a serem reutilizados.

Representando XML arbitrário em contratos de dados

O XmlElement, Array of e XmlNode types permitem que se injete XML arbitrário no modelo de contrato de dados IXmlSerializable. O DataContractSerializer e NetDataContractSerializer passar esse conteúdo XML para o gravador XML em uso, sem interferir no processo. No entanto, os gravadores XML podem impor certas restrições no XML que escrevem. 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 escrita de outro documento. Não é possível pegar um documento XML completo e serializá-lo como um membro de dados Array de XmlNode. Para fazer isso, você tem que remover a declaração do documento ou usar seu próprio esquema de codificação para representá-lo.

  • Todos os gravadores XML fornecidos com WCF rejeitam instruções de processamento XML (<? ... ?>) e definições de tipo de documento (<! ... ), >porque eles não são permitidos 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, poderá escrever um codificador personalizado que use gravadores XML que os suportem.

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

  • Ao implementar WriteXml, evite usar os métodos WriteEntityRef e WriteNmToken que não são suportados pelos escritores XML fornecidos com o WCF.

Usando DataSet, DataSet Tipado e DataTable

O uso desses tipos é totalmente suportado no 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 baixa usabilidade quando usado com essas plataformas. Além disso, o uso do DataSet tipo pode ter implicações de desempenho. Finalmente, pode tornar mais difícil para você fazer a versão do seu aplicativo no futuro. Considere usar tipos de contrato de dados explicitamente definidos em vez de tipos DataSet nos seus contratos.

  • Ao importar DataSet ou DataTable esquema, é importante fazer referência a esses tipos. Com a ferramenta de linha de comando Svcutil.exe, isto pode ser feito passando o nome do assembly System.Data.dll para a opção /reference. Ao importar esquema de conjunto de dados tipado, você deve fazer referência ao tipo do conjunto de dados tipado. Com Svcutil.exe, passe o local da montagem do conjunto de dados digitado para o /reference switch. Para obter mais informações sobre tipos de referência, consulte Importar o esquema para gerar classes.

O suporte para DataSets tipados no modelo de contrato de dados é limitado. DataSets tipados podem ser serializados e deserializados e podem exportar o seu esquema. No entanto, a importação de esquema de Contrato de Dados não consegue gerar novos tipos de DataSet tipados a partir do esquema, pois só pode reutilizar os existentes. Você pode apontar para um DataSet digitado existente usando a /r opção Svcutil.exe. Se tentar usar um Svcutil.exe sem o /r switch num serviço que utilize um conjunto de dados tipado, um serializador alternativo (XmlSerializer) será automaticamente selecionado. Caso tenha de usar o DataContractSerializer e precisar gerar DataSets a partir do esquema, pode seguir o seguinte procedimento: gerar os tipos de DataSet tipados (usando a opção /d na ferramenta Xsd.exe no serviço), compilar os tipos e, em seguida, apontar para eles usando a opção /r na Svcutil.exe.

Ver também

  • Last updated on