Tipos XML e ADO.NET em contratos de dados

Artigo
03/05/2024

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, usando o seguinte tipo.

[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 wrapper para toda a coleção e um elemento wrapper separado (semelhante ao <myDataMember> exemplo anterior) para cada XmlElement um 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 para acessar XML DataContractSerializer 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. Embora implemente o , 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 IEnumerabledados. 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 é muito semelhante ao uso XmlElementde XmlNode . O uso de arrays de oferece mais flexibilidade do que o uso XmlElementdo XmlNode . Você pode escrever vários elementos dentro do elemento de encapsulamento de 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. Finalmente, você pode colocar atributos no elemento de membro 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, usando o seguinte tipo.

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

Uma matriz que XmlNode 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 é uma é inválida XmlAttribute , 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 uma matriz de nós , os nós são criados e preenchidos XmlNodecom 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 matrizes da XmlNode mesma forma que se aplica à desserialização 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 for null, o elemento wrapper data member conterá um atributo especial que indica que ele é null. 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 XmlNode instâncias não resulta no tratamento do membro de dados como uma Array das XmlNode instâncias. 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 IEnumerableo , uma matriz de não pode ser usada como um tipo de coleção e ser atribuída a um IEnumerable membro de XmlNode dados. 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 of é mapeado XmlNode 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 implementando a interface IXmlSerializable

Os tipos que implementam a IXmlSerializable interface são totalmente suportados DataContractSerializerpelo . 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 deve controlar seu próprio nome de IXmlSerializable elemento raiz. Para marcar um tipo como um tipo de elemento, defina a IsAny XmlSchemaProviderAttribute propriedade no atributo como true ou retorne 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 para a geração do GetSchema 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 e é um tipo de IXmlSerializable conteúdo conforme definido anteriormente, o serializador grava o elemento wrapper para o membro de dados e passa o controle para o WriteXml método. A WriteXml implementação pode escrever qualquer XML, incluindo a adição de atributos ao elemento wrapper. Depois WriteXml de concluído, o serializador fecha o elemento.

Ao desserializar um membro de dados de um tipo que implementa e é um tipo de IXmlSerializable conteúdo conforme definido anteriormente, o desserializador posiciona o leitor XML no elemento wrapper para o membro de dados e passa o controle para o ReadXml método. 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 usar IXmlSerializable tipos com a preservação de gráficos 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" for true, um valor nulo será desserializado e ReadXml não será 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, uma ReadXml implementação deve ignorar esses atributos especiais porque eles são manipulados pelo desserializador.

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

Ao exportar um IXmlSerializable tipo de conteúdo de esquema, 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 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 Export método é chamado para todos os tipos relevantes no e a XsdDataContractExporter Schemas propriedade é acessada), o tipo existe no conjunto de esquemas. O acesso à propriedade antes de Schemas todas as chamadas relevantes Export terem sido feitas pode resultar em um XmlSchemaExceptionarquivo . 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 tipo será exportado IXmlSerializable como um tipo anônimo toda vez que o IXmlSerializable tipo for usado como membro de dados. O IXmlSerializable tipo ainda tem um nome de contrato de dados e namespace. (Isto é 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 declarações de elemento global adicionadas por meio de código personalizado, adicionado ao XmlSchemaSet usando o método de provedor de esquema ou através de tipos de GetSchema conjunto 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 um elemento wrapper em torno do elemento que escreve, a menos que WriteXml um nome de raiz e namespace foram explicitamente especificados ao construir o DataContractSerializer serializador nos construtores or 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 verifyObjectName parâmetro definido para true se comportar 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 XmlElement tipo descrito em uma seção anterior, exceto que o método de provedor de esquema pode adicionar qualquer esquema adicional ao XmlSchemaSet como 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 IXmlSerializable interface e os XmlSchemaProviderAttribute atributos e XmlRootAttribute também são compreendidos XmlSerializer pelo . 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 é true 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 exporta XmlSerializer 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. Esse modo de importação não está ativado por padrão, mas pode ser facilmente habilitado – por exemplo, com a opção de /importXmlTypes linha de comando 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 /reference svcutil.exe de ativação, que especifica o assembly que contém os tipos a serem reutilizados.

Representando XML arbitrário em contratos de dados

O XmlElement, Array of e IXmlSerializable types permitem que você injete XML arbitrário no modelo de contrato de XmlNode dados. 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 sobre o XML que eles 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 Array membro de XmlNode dados. 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 WriteXmlo , evite chamar WriteRaw o método 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 WriteXmlo , evite usar os WriteEntityRef métodos e WriteNmToken que não são suportados nos gravadores 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 o uso de tipos de contrato de dados explicitamente definidos em vez de DataSet tipos em seus contratos.
Ao importar DataSet ou DataTable esquema, é importante fazer referência a esses tipos. Com a ferramenta de linha de comando Svcutil.exe, isso pode ser feito passando o nome do assembly System.Data.dll para o /reference switch. 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 Importando esquema para gerar classes.

O suporte para DataSets tipados no modelo de contrato de dados é limitado. DataSets tipados podem ser serializados e desserializados e podem exportar 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 você tentar usar um Svcutil.exe sem a /r opção em um serviço que usa um conjunto de dados tipado, um serializador alternativo (XmlSerializer) será selecionado automaticamente. Se você deve usar o DataContractSerializer e deve gerar DataSets a partir do esquema, você pode usar o seguinte procedimento: gerar os tipos de DataSet tipados (usando a ferramenta Xsd.exe com a /d opção no serviço), compilar os tipos e, em seguida, apontar para eles usando o /r switch on Svcutil.exe.

Partilhar via