Compartir a través de

Tipos XML y ADO.NET en contratos de datos

El modelo de contrato de datos de Windows Communication Foundation (WCF) admite determinados tipos que representan XML directamente. Cuando estos tipos se serializan en XML, el serializador escribe el contenido XML de estos tipos sin ningún procesamiento adicional. Los tipos admitidos son XmlElement, matrices de XmlNode (pero no del XmlNode propio tipo), así como tipos que implementan IXmlSerializable. DataSet y el tipo DataTable, así como los conjuntos de datos con tipo, se utilizan normalmente en programación de base de datos. Estos tipos implementan la IXmlSerializable interfaz y, por tanto, son serializables en el modelo de contrato de datos. Algunas consideraciones especiales para estos tipos se enumeran al final de este tema.

Tipos XML

Elemento Xml

El XmlElement tipo se serializa mediante su contenido XML. Por ejemplo, utilizando el siguiente 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

Esto se serializa en XML de la siguiente manera:

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

Fíjese en que un elemento contenedor de miembro de datos <myDataMember> todavía está presente. No hay forma de quitar este elemento en el modelo de contrato de datos. Los serializadores que manejan este modelo (el DataContractSerializer y NetDataContractSerializer) pueden emitir atributos especiales en este elemento de envoltura. Estos atributos incluyen el atributo "nil" estándar de la instancia de esquema XML (lo que permite XmlElement que sea null) y el atributo "type" (lo que permite XmlElement usarse polimórficamente). Además, los siguientes atributos XML son específicos de WCF: "Id", "Ref", "Type" y "Assembly". Estos atributos se pueden utilizar para admitir el uso de XmlElement con el modo de preservación del gráfico de objetos habilitado o con NetDataContractSerializer. (Para obtener más información sobre el modo de conservación del grafo de objetos, vea Serialización y deserialización).

Se permiten matrices o colecciones de XmlElement y se controlan como cualquier otra matriz o colección. Es decir, hay un elemento contenedor para toda la colección y un elemento contenedor independiente (similar al <myDataMember> del ejemplo anterior) para cada XmlElement uno de la matriz.

En la deserialización, el deserializador crea un objeto XmlElement a partir del XML entrante. El deserializador proporciona un elemento primario XmlDocument válido.

Asegúrese de que el fragmento XML deserializado en un XmlElement define todos los prefijos que usa y no se basa en ninguna definición de prefijo de elementos antecesores. Se trata de una preocupación solo cuando se usa el DataContractSerializer para acceder a XML desde un origen diferente (no DataContractSerializer).

Cuando se usa con DataContractSerializer, XmlElement se puede asignar polimórficamente, pero solo a un miembro de datos de tipo Object. Aunque implementa IEnumerable, XmlElement no se puede usar como un tipo de colección y no se puede asignar a un IEnumerable miembro de datos. Al igual que con todas las asignaciones polimórficas, emite DataContractSerializer el nombre del contrato de datos en el XML resultante. En este caso, es "XmlElement" en el espacio de nombres http://schemas.datacontract.org/2004/07/System.Xml.

Con el NetDataContractSerializer, se admite cualquier asignación polimórfica válida de XmlElement (a Object o IEnumerable).

No intente usar ninguno de los serializadores con tipos derivados de XmlElement, ya sean asignados de forma polimórfica o no.

Matriz de XmlNode

El uso de matrices de XmlNode es muy similar al uso de XmlElement. El uso de matrices de XmlNode proporciona más flexibilidad que el uso de XmlElement. Puede escribir varios elementos dentro del elemento de ajuste de miembro de datos. También puede insertar contenido distinto a los elementos dentro del elemento contenedor del miembro de datos, como comentarios XML. Por último, puede poner atributos en el elemento de miembro de datos de ajuste. Todo esto se puede lograr rellenando la matriz de XmlNode con clases derivadas específicas de XmlNode como XmlAttribute, XmlElement o XmlComment. Por ejemplo, utilizando el siguiente 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

Cuando se serializa, el XML resultante es similar al código siguiente.

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

Tenga en cuenta que el elemento contenedor de miembro de datos <myDataMember> incluye un atributo, un comentario y dos elementos. Estas son las cuatro XmlNode instancias que se serializaron.

No se puede serializar una matriz de XmlNode que da como resultado XML no válido. Por ejemplo, una matriz de dos instancias XmlNode en la que la primera es un XmlElement y la segunda es un XmlAttribute no es válida, ya que esta secuencia no corresponde a ninguna instancia XML válida (no hay un lugar para asignar el atributo).

En la deserialización de una matriz de XmlNode, los nodos se crean y rellenan con información del XML entrante. El deserializador proporciona un elemento primario XmlDocument válido. Todos los nodos se deserializan, incluidos los atributos del elemento miembro de datos contenedor, pero excluyendo los atributos colocados allí por los serializadores WCF (como los atributos usados para indicar la asignación polimórfica). La advertencia sobre cómo definir todos los prefijos de espacio de nombres en el fragmento XML se aplica a la deserialización de matrices de XmlNode simplemente como se hace al deserializar XmlElement.

Cuando se usan los serializadores con la preservación de grafos de objetos activada, la igualdad de objetos solo se conserva a nivel de XmlNode arrays, no en las instancias individuales XmlNode.

No intente serializar una matriz de XmlNode donde uno o varios de los nodos está establecido en null. Se permite que todo el elemento de la matriz sea null, pero no para ningún elemento XmlNode contenido en la matriz. Si todo el miembro de la matriz es NULL, el elemento de miembro de datos contenedor contiene un atributo especial que indica que es NULL. En la deserialización, todo el miembro de matriz también se convierte en NULL.

Solo el serializador trata especialmente matrices normales de XmlNode . Los miembros de datos declarados como otros tipos de colección que contienen XmlNode, o miembros de datos declarados como matrices de tipos derivados de XmlNode, no se tratan especialmente. Por lo tanto, normalmente no se pueden serializar a menos que también cumplan uno de los otros criterios para la serialización.

Se permiten matrices o colecciones de matrices de XmlNode . Hay un elemento contenedor para toda la colección y un elemento contenedor independiente (similar al <myDataMember> del ejemplo anterior) para cada matriz de XmlNode en la matriz o colección externa.

Rellenar un miembro de datos de tipo Array de Object, o Array de IEnumerable, con instancias XmlNode no produce el miembro de datos tratado como una Array de instancias XmlNode. Cada miembro de matriz se serializa por separado.

Cuando se usa con DataContractSerializer, las matrices de XmlNode se pueden asignar polimórficamente, pero solo a un miembro de dato de tipo Object. Aunque se implemente IEnumerable, una matriz de XmlNode no se puede usar como un tipo de colección ni se puede asignar a un miembro de datos IEnumerable. Al igual que con todas las asignaciones polimórficas, DataContractSerializer emite el nombre del contrato de datos en el XML resultante; en este caso, es "ArrayOfXmlNode" en el http://schemas.datacontract.org/2004/07/System.Xml espacio de nombres. Cuando se usa con NetDataContractSerializer, se admite cualquier asignación válida de una XmlNode matriz.

Consideraciones de esquema

Para obtener más información sobre la asignación de esquemas de tipos XML, consulte Referencia de esquema de contrato de datos. En esta sección se proporciona un resumen de los puntos importantes.

Un miembro de datos de tipo XmlElement se asigna a un elemento definido mediante el siguiente tipo anónimo.

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

Un miembro de datos de tipo Array de XmlNode se asigna a un elemento definido mediante el siguiente 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 implementan la interfaz IXmlSerializable

Los tipos que implementan la IXmlSerializable interfaz son totalmente compatibles con .DataContractSerializer El XmlSchemaProviderAttribute atributo siempre debe aplicarse a estos tipos para controlar su esquema.

Hay tres variedades de tipos que implementan IXmlSerializable: tipos que representan contenido arbitrario, tipos que representan un solo elemento y tipos heredados DataSet .

  • Los tipos de contenido usan un método de proveedor de esquema especificado por el XmlSchemaProviderAttribute atributo . El método no devuelve nully la IsAny propiedad del atributo se deja en su valor predeterminado de false. Este es el uso más común de IXmlSerializable tipos.

  • Los tipos de elemento se usan cuando un IXmlSerializable tipo debe controlar su propio nombre de elemento raíz. Para marcar un tipo como un tipo de elemento, establezca la propiedad IsAny en el atributo XmlSchemaProviderAttribute en true, o devuelva null utilizando el método del proveedor de esquemas. Tener un método de proveedor de esquemas es opcional para los tipos de elemento: puede especificar null en lugar del nombre del método en .XmlSchemaProviderAttribute Sin embargo, si IsAny es true y se especifica un método de proveedor de esquemas, el método debe devolver nulo.

  • Los tipos heredados DataSet son IXmlSerializable tipos que no están marcados con el XmlSchemaProviderAttribute atributo. En su lugar, se basan en el GetSchema método para la generación de esquemas. Este patrón se usa para el tipo DataSet y su conjunto de datos tipado deriva una clase en versiones anteriores de .NET Framework, pero ahora está obsoleto y solo se admite por motivos de compatibilidad con versiones anteriores. No confíe en este patrón y aplique siempre el XmlSchemaProviderAttribute a sus tipos IXmlSerializable.

Tipos de contenido de IXmlSerializable

Al serializar un miembro de datos de un tipo que implementa IXmlSerializable y es un tipo de contenido tal como se definió anteriormente, el serializador escribe el elemento contenedor para el miembro de datos y pasa el control al WriteXml método . La WriteXml implementación puede escribir cualquier XML, incluida la adición de atributos al elemento contenedor. Una vez WriteXml hecho, el serializador cierra el elemento.

Al deserializar un miembro de datos de un tipo que implementa `IXmlSerializable` y es un tipo de contenido como se definió anteriormente, el deserializador coloca el lector XML en el elemento contenedor para el miembro de datos y pasa el control al método `ReadXml`. El método debe leer todo el elemento, incluidas las etiquetas start y end. Asegúrese de que el código ReadXml controla el caso en el que el elemento está vacío. Además, su implementación ReadXml no debería confiar en el elemento contenedor denominado de una manera determinada. El nombre elegido por el serializador puede variar.

Se permite asignar IXmlSerializable tipos de contenido polimórficamente, por ejemplo, a miembros de datos de tipo Object. También se permite que las instancias de tipo sean NULL. Finalmente, es posible utilizar los tipos IXmlSerializable con preservación de gráfico de objetos habilitado y con NetDataContractSerializer. Todas estas características requieren que el serializador WCF asocie determinados atributos al elemento contenedor ("nil" y "type" en el espacio de nombres de instancia de esquema XML y "Id", "Ref", "Type" y "Assembly" en un espacio de nombres específico de WCF).

Atributos que se omitirán al implementar ReadXml

Antes de pasar el control al ReadXml código, el deserializador examina el elemento XML, detecta estos atributos XML especiales y actúa sobre ellos. Por ejemplo, si "nil" es true, se deserializa un valor nulo y no se llama a ReadXml. Si se detecta polimorfismo, el contenido del elemento se deserializa como si fuera un tipo diferente. Se llama a la implementación del tipo asignado polimórficamente ReadXml. En cualquier caso, una ReadXml implementación debe omitir estos atributos especiales porque los controla el deserializador.

Consideraciones del esquema para los tipos de contenido de IXmlSerializable

Al exportar un IXmlSerializable tipo de contenido, se invoca el método del proveedor de esquemas. XmlSchemaSet se pasa al método de proveedor de esquema. El método puede agregar cualquier esquema válido al conjunto de esquemas. El conjunto de esquemas contiene el esquema que ya se conoce en el momento en que se produce la exportación de esquemas. Cuando el método del proveedor de esquemas debe agregar un elemento al conjunto de esquemas, debe determinar si ya existe un XmlSchema con el espacio de nombres adecuado en el conjunto. Si lo hace, el método de proveedor de esquemas debe agregar el nuevo elemento a lo existente XmlSchema. De lo contrario, debe crear una nueva XmlSchema instancia. Esto es importante si se usan matrices de IXmlSerializable tipos. Por ejemplo, si tiene un tipo IXmlSerializable que se exporta como tipo "A" en el espacio de nombres "B", es posible que cuando al llamar al método de proveedor de esquema, el conjunto de esquemas ya contenga el esquema para que "B" incluya el tipo "ArrayOfA."

Además de agregar tipos al XmlSchemaSet, el método de proveedor de esquema para los tipos de contenido debe devolver un valor distinto de NULL. Puede devolver un XmlQualifiedName que especifica el nombre del tipo de esquema que se va a usar para el tipo especificado IXmlSerializable . Este nombre completo también actúa como el nombre de contrato de datos y el espacio de nombres del tipo. Se permite devolver un tipo que no existe en el esquema establecido inmediatamente cuando vuelve el método del proveedor de esquema. Sin embargo, se espera que en el momento en que se exportan todos los tipos relacionados (se llama el método Export para todos los tipos pertinentes en XsdDataContractExporter y se accede a la propiedad Schemas), el tipo existe en el conjunto de esquemas. Teniendo acceso a la propiedad Schemas antes de que se hayan realizado todas las llamadas Export pertinentes puede producir XmlSchemaException. Para obtener más información sobre el proceso de exportación, vea Exportar esquemas desde clases.

El método de proveedor de esquema también puede devolver el XmlSchemaType que se va a utilizar. El tipo puede ser o no anónimo. Si es anónimo, el esquema del IXmlSerializable tipo se exporta como un tipo anónimo cada vez que el IXmlSerializable tipo se usa como miembro de datos. El tipo IXmlSerializable aún tiene un nombre de contrato de datos y un espacio de nombres. (Esto se determina como se describe en Nombres de contrato de datos , excepto que el DataContractAttribute atributo no se puede usar para personalizar el nombre). Si no es anónimo, debe ser uno de los tipos de XmlSchemaSet. Este caso es equivalente a la devolución del XmlQualifiedName del tipo.

Además, se exporta una declaración de elemento global para el tipo . Si el tipo no tiene aplicado el XmlRootAttribute atributo , el elemento tiene el mismo nombre y espacio de nombres que el contrato de datos, y su propiedad "nillable" es true. La única excepción a esto es el espacio de nombres de esquema (http://www.w3.org/2001/XMLSchema); si el contrato de datos del tipo está en este espacio de nombres, el elemento global correspondiente está en el espacio de nombres en blanco porque está prohibido agregar nuevos elementos al espacio de nombres de esquema. Si el tipo tiene aplicado el XmlRootAttribute atributo , la declaración de elemento global se exporta mediante las siguientes propiedades: ElementName, Namespacey IsNullable. Los valores predeterminados con XmlRootAttribute aplicado son el nombre de contrato de datos, un espacio de nombres en blanco y "nillable" con el valor true.

Las mismas reglas de declaración de elementos globales se aplican a los tipos de conjunto de datos heredados. Tenga en cuenta que XmlRootAttribute no puede invalidar las declaraciones de elementos globales agregadas a través de código personalizado, ya sea añadidas a XmlSchemaSet usando el método del proveedor de esquemas o a través de GetSchema para los tipos de conjunto de datos heredados.

Tipos de elemento de IXmlSerializable

Los tipos de elemento IXmlSerializable hacen que la propiedad IsAny se establezca en true o hacen que su método de proveedor de esquema se vuelva null.

Serializar y deserializar un tipo de elemento es muy similar a serializar y deserializar un tipo de contenido. Sin embargo, hay algunas diferencias importantes:

  • Se espera que la WriteXml implementación escriba exactamente un elemento (que por supuesto podría contener varios elementos secundarios). No debería estar escribiendo los atributos fuera de este elemento único, varios elementos del mismo nivel o contenido mixto. El elemento puede estar vacío.

  • La ReadXml implementación no debe leer el elemento contenedor. Se espera que lea el un elemento que WriteXml genera.

  • Al serializar un tipo de elemento regularmente (por ejemplo, como miembro de datos en un contrato de datos), el serializador genera un elemento contenedor antes de llamar a WriteXml, como con los tipos de contenido. Sin embargo, al serializar un tipo de elemento en el nivel superior, el serializador normalmente no genera un elemento contenedor alrededor del elemento que WriteXml escribe, a menos que se haya especificado explícitamente un nombre raíz y un espacio de nombres al construir el serializador en los constructores DataContractSerializer o NetDataContractSerializer. Para obtener más información, consulte Serialización y deserialización.

  • Al serializar un tipo de elemento en el nivel superior sin especificar el nombre raíz y el espacio de nombres en tiempo de construcción, WriteStartObject y WriteEndObject básicamente no realiza nada y WriteObjectContent llama a WriteXml. En este modo, el objeto que se serializa no puede ser NULL y no se puede asignar polimórficamente. Además, la conservación del grafo de objetos no se puede habilitar y NetDataContractSerializer no se puede usar.

  • Al deserializar un tipo de elemento en el nivel superior sin especificar el nombre raíz y el espacio de nombres en tiempo de construcción, IsStartObject devuelve true si puede encontrar el inicio de cualquier elemento. ReadObject con el parámetro verifyObjectName establecido en true se comporta de la misma manera que IsStartObject antes de que realmente se lea el objeto. ReadObject a continuación, pasa el control al ReadXml método .

El esquema exportado para los tipos de elementos es el mismo que para el XmlElement tipo descrito en una sección anterior, excepto que el método de proveedor de esquemas puede agregar cualquier esquema adicional al XmlSchemaSet igual que con los tipos de contenido. No se permite el uso del XmlRootAttribute atributo con tipos de elemento y nunca se emiten declaraciones de elementos globales para estos tipos.

Diferencias con XmlSerializer

La interfaz IXmlSerializable y los atributos XmlSchemaProviderAttribute y XmlRootAttribute también son entendidos por XmlSerializer. Sin embargo, hay algunas diferencias en cómo se tratan en el modelo de contrato de datos. Las diferencias importantes se resumen en lo siguiente:

  • El método del proveedor de esquemas debe ser público para poder usarse en XmlSerializer, pero no tiene que ser público para poder usarse en el modelo de contrato de datos.

  • Se llama al método del proveedor de esquema cuando IsAny es verdadero en el modelo de contrato de datos, pero no con XmlSerializer.

  • Cuando el XmlRootAttribute atributo no está presente para los tipos de conjunto de datos heredados o de contenido, XmlSerializer exporta una declaración de elemento global en el espacio de nombres en blanco. En el modelo de contrato de datos, el espacio de nombres usado suele ser el espacio de nombres del contrato de datos, tal como se describió anteriormente.

Tenga en cuenta estas diferencias al crear tipos que se usan con ambas tecnologías de serialización.

Importar el esquema de IXmlSerializable

Al importar un esquema generado a partir de IXmlSerializable tipos, hay algunas posibilidades:

  • El esquema generado puede ser un esquema de contrato de datos válido, tal como se describe en Referencia del esquema del contrato de datos. En este caso, se puede importar el esquema como de costumbre y se generan tipos de contrato de datos normales.

  • Es posible que el esquema generado no sea un esquema de contrato de datos válido. Por ejemplo, el método del proveedor de esquemas puede generar un esquema que implique atributos XML que no se admiten en el modelo de contrato de datos. En este caso, puede importar el esquema como tipos IXmlSerializable. Este modo de importación no está activado de forma predeterminada, pero se puede habilitar fácilmente, por ejemplo, con la /importXmlTypes opción de línea de comandos a la Herramienta de metadatos de ServiceModel (Svcutil.exe). Esto se describe con detalle en el esquema de importación para generar clases. Tenga en cuenta que debe trabajar directamente con XML para sus instancias de tipo. También puede considerar el uso de una tecnología de serialización diferente que admita una gama más amplia de esquemas; vea el tema sobre el uso de XmlSerializer.

  • Es posible que quiera volver a usar los tipos existentes IXmlSerializable en el proxy en lugar de generar nuevos. En este caso, la característica de tipos referenciada, descrita en el tema de Importar esquema para generar tipos, se puede utilizar para indicar el tipo que se va a reutilizar. Esto se corresponde con el uso del modificador /reference en svcutil.exe, que especifica el ensamblado que contiene los tipos que se van a volver a usar.

Representar XML arbitrario en contratos de datos

XmlElement, Matriz de XmlNode y los tipos IXmlSerializable le permite insertar XML arbitrario en el modelo del contrato de datos. DataContractSerializer y NetDataContractSerializer pasan este contenido XML al escritor XML en uso, sin interferir en el proceso. Sin embargo, los escritores XML pueden aplicar ciertas restricciones en el XML que escriben. En concreto, estos son algunos ejemplos importantes:

  • Los escritores XML no suelen permitir una declaración de documento XML (por ejemplo, <?xml version='1.0' ?>) en medio de escribir otro documento. No puede tomar un documento XML completo y serializarlo como un Array de un miembro de datos de XmlNode. Para ello, debe quitar la declaración del documento o usar su propio esquema de codificación para representarlo.

  • Todos los escritores XML proporcionados con WCF rechazan las instrucciones de procesamiento XML (<? ... ?>) y las definiciones de tipo de documento (<! ... >), porque no se permiten en los mensajes SOAP. De nuevo, puede usar su propio mecanismo de codificación para evitar esta restricción. Si debe incluirlos en el XML resultante, puede escribir un codificador personalizado que use escritores XML que los admitan.

  • Al implementar WriteXml, evite llamar al método WriteRaw en el escritor XML. WCF utiliza una variedad de codificaciones XML (incluidas las binarias); es muy difícil o imposible usar WriteRaw de tal manera que el resultado sea utilizable en cualquier codificación.

  • Al implementar WriteXml, evite usar los WriteEntityRef métodos y WriteNmToken que no son compatibles con los escritores XML proporcionados con WCF.

Utilizar DataSet, DataSet con tipo y DataTable

El uso de estos tipos es totalmente compatible con el modelo de contrato de datos. Al usar estos tipos, tenga en cuenta los siguientes puntos:

  • El esquema de estos tipos (especialmente DataSet y sus clases derivadas tipadas) puede no ser interoperable con algunas plataformas que no son WCF, o puede dar lugar a una mala facilidad de uso cuando se usa con estas plataformas. Además, el uso del DataSet tipo puede tener implicaciones de rendimiento. Por último, puede dificultar la gestión de las versiones de tu aplicación en el futuro. Considere usar tipos de contrato de datos definidos explícitamente en lugar de los tipos DataSet en tus contratos.

  • Al importar DataSet o DataTable esquema, es importante hacer referencia a estos tipos. Con la herramienta de línea de comandos Svcutil.exe, esto se logra pasando el nombre del ensamblado System.Data.dll al conmutador /reference. Si importa el esquema del conjunto de datos con tipo, debe hacer referencia al tipo del conjunto de datos con tipo. Con Svcutil.exe, pase la ubicación del ensamblado del conjunto de datos con tipo al modificador /reference. Para obtener más información sobre cómo hacer referencia a tipos, vea el tema sobre la importación de esquemas para generar clases.

La compatibilidad con DataSets tipados en el modelo de contrato de datos es limitada. Los DataSets tipados se pueden serializar y deserializar, además de poder exportar su esquema. Sin embargo, la importación del esquema del contrato de datos no puede generar nuevos tipos de Conjunto de Datos tipificados a partir del esquema, ya que solo puede reutilizar los existentes. Puede señalar a un conjunto de datos con tipo existente mediante el modificador /r en Svcutil.exe. Si intenta usar una Svcutil.exe sin el modificador /r en un servicio que usa un conjunto de datos con tipo, se selecciona automáticamente un serializador alternativo (XmlSerializer). Si necesita usar DataContractSerializer y generar conjuntos de datos a partir del esquema, puede usar el procedimiento siguiente: genere los tipos DataSet con tipo (mediante la herramienta Xsd.exe con el modificador /d en el servicio), compile los tipos y, a continuación, señale a ellos mediante el uso del modificador /r en Svcutil.exe.

Consulte también