tema 10. ado.net y xml 10.1. xml y .net framework xml … · también podríamos haber escrito este...

10.1Programación .NET (II). ADO.NET y XML

TEMA 10. ADO.NET Y XML

10.1. XML Y .NET FRAMEWORK

XML

Ya comentamos en el primer tema

que el lenguaje XML (Lenguaje

extensible de marcado o, en inglés,

Extensible Markup Language) es un

metalenguaje basado en etiquetas que va a permitir representar datosde forma estructurada, con formato de texto.

Los datos se delimitan con etiquetas, las cuales pueden llevar el nombre que

queramos, y serán nodos. Por ejemplo, a continuación puedes ver un archivo

XML (muy simple) que contiene tres registros de nuestra famosa agenda.

<?xml version="1.0" encoding="utf-8" standalone="yes"?>



<Agenda>

<Persona>

<NIF>1000000A</NIF>

<Nombre>Antonio</Nombre>

<Apellidos>Gutierrez Velasco</Apellidos>

<Telefono>91111111</Telefono>

</Persona>

<Persona>

<NIF>2000000B</NIF>

<Nombre>Ana</Nombre>

<Apellidos>Sánchez Blanco</Apellidos>


</Persona>

<Persona>

<NIF>3000000C</NIF>

<Nombre>Felipe</Nombre>

<Apellidos>López Fernández</Apellidos>


</Persona>

</Agenda>

Programación .NET (II). ADO.NET y XML10.2

Podemos crear un archivo XML con cualquier editor de textos, como el bloc de

notas, por ejemplo. Si abrimos o creamos el archivo desde el IDE de Visual

Basic 2008, éste nos ayudará tabulando los elementos y resaltando las

etiquetas con otro color, lo cual no es imprescindible, pero proporcionará una

lectura más cómoda de los datos.

Existe un estándar del W3C (Consorcio World Wide Web) que define el modo

de acceso y manipulación de datos XML: es el estándar XML DOM (Document

Object Model). Este estándar forma parte del estándar DOM, compuesto

por Core DOM (para cualquier documento estructurado), XML DOM (para

documentos XML) y HTML DOM (para documentos HTML).

El archivo XML del ejemplo comienza con la siguiente línea:

Esta línea se llama prólogo y sirve para declarar que se trata de un documento

XML, así como la versión a la que se somete.

En la tercera línea tenemos: <Agenda> Esta etiqueta va a ser el elemento onodo raíz del documento o entidad de documento del documento. Un

documento XML sólo puede tener un nodo raíz y tras la etiqueta de cierre de

este nodo (</Agenda>) no puede haber nada, pues debe englobar todo lo

demás. Se trata de una jerarquía en forma de árbol de nodos, en la que todos

los nodos son accesibles recorriendo el árbol.

Dentro del nodo <Agenda> hay tres nodos <Persona>, que, a su vez, se

componen de <NIF> <Nombre> <Apellidos> y <Telefono>. Observa que todos

estos nodos tienen su correspondiente etiqueta de cierre </nombre>.

En el caso de que algún nodo no contuviera nada, tendríamos que poner

<NIF></NIF> o, abreviando, <NIF/>.

Como ves, los datos se organizan estructuradamente, la agenda contiene

personas y cada persona cuenta con NIF, nombre, apellidos y teléfono.



El archivo de datos XML puede acompañarse de un esquema que defina su

estructura en un archivo de definición de esquema XML (XSD). En el caso

de nuestro ejemplo podríamos tener un archivo “agenda.xsd” que defina la

estructura de los datos XML. En tal caso, deberíamos referenciar el esquema

en el archivo XML:

A contnuación puedes ver un ejemplo de esquema de definición para los datos

XML anteriores.


<agenda xmlns=”http://espaciodenombres/agenda”

xmlns:xsi=”http://espaciodenombres/agenda”

xsi:schemaLocation="agenda.xsd">

<?xml version="1.0" encoding="utf-8"?>

<xsd:schema xmlns:xsd=http://www.w3.org/2001/XMLSchema

targetNamespace="agenda.xsd">

<xsd:element name="persona">

<xsd:complexType>

<xsd:sequence>

<xsd:element name="NIF" type="xsd:string"/>

<xsd:element name="Nombre" type="xsd:string"/>

<xsd:element name="Apellidos" type="xsd:string"/>

<xsd:element name="Telefono" type="xsd:long"/>

</xsd:sequence>

</xsd:complexType>

</xsd:element>

</xsd:schema>


¿Cómo trabajar con XML en .Net Framework?

El espacio de nombres de .Net Framework que proporcionará las clases para

leer, escribir y manipular documentos XML es el espacio System.Xml.

Este espacio cuenta con clases que tratan los datos XML de distintas formas:

XmlDocument

XmlDocument es una clase que permite representar en memoria caché un

documento XML completo, según el XML DOM, pudiendo recorrer y editar el

documento.

XmlDataDocument

Extiende a XmlDocument permitiendo un acceso relacional al documento XML

a través de su propio DataSet.

XMLReader

XMLReader representa un lector de datos de sólo avance. Es similar al lector

DataReader del espacio Syste.Data. Ofrece el modo de acceso más rápido, pues

no carga en memoria el documento entero sólo la posición actual.

Esta clase es una clase abstracta de la que derivan otras clases más específicas

(XMLTextReader,XMLNodeReader, XMLDictionaryReader, XMLValidatingReader).

XMLWriter

XMLWriter proporciona una forma rápida de escritura de documentos XML. De

igual forma que XMLReader, el modo de escritura será secuencial, de sólo

avance.

Esta clase es una clase abstracta de la que derivan otras clases más específicas

(XMLTextWriter, XMLDictionaryWriter).

Desde hace algún tiempo, los espacios de nombres System.Data y System.XML

han empezado a entremezclar su funcionalidad, estando cada vez más

relacionados. Las clases de System.Data incluyen ahora tambiénmétodos para trabajar con XML.

En este sentido vamos a estudiar el caso de la clase XmlDataDocument, muy

vinculada a la clase DataSet de System.Data.


XmlDataDocument

Observa e siguientel esquema. En él puedes ver las diferentes asociaciones

que los datos XML pueden tener con DataSet y XmlDataDocument.

Sabemos que el objeto DataSet proporciona una representación relacional de

los datos. Para una representación jerárquica existe el objeto

XmlDataDocument del espacio System.XML.

XmlDataDocument extiende a XmlDocument, permitiendo almacenar,

recuperar y manipular los datos estructurados mediante un DataSet relacional.

Todo esto sin perder sus capacidades para recorrer y manipular datos XML del

estándar XML DOM.

Dicho de otra forma, XmlDataDocument proporciona un “puente” entredatos jerárquicos y relacionales. No tendremos que elegir entre las dos

formas de representación de los datos porque tendremos ambas.

El hecho de disponer de ambas vistas de los datos ofrece ventajas, como poder

navegar y manipular los datos XML contra una estructura relacional de una

forma más eficiente que si los tuviéramos almacenados en un XmlDocument.

Además, podemos almacenar en el DataSet sólo una porción de los datos XML

para manipular únicamente la parte que nos interesa.

Si volvemos a fijarnos en el esquema veremos los datos XML pueden ser

cargados directamente en un Dataset, para ser manipulados “de manera

relacional”.


Por otro lado, los datos pueden ser cargados en la clase XmlDataDocument,

derivada del DOM, y, a su vez, cargados y sincronizados con el DataSet. Así,

con DataSet y XmlDataDocument sincronizados sobre el mismoconjunto de datos, los cambios realizados en uno se reflejanautomáticamente en el otro.

Veremos ahora varias formas de manejar datos XML según ambos métodos.

10.2. CREACIóN DEL CONjuNTO DE DATOS A PARTIR DEL DOCuMENTO XML

Los conjuntos de datos o DataSet cuentan con el método ReadXml para leer

datos XML directamente desde un archivo, una secuencia o un XmlReader.

Los argumentos para este método son:

El origen de XML.

Este origen puede ser una cadena con la ruta a un archivo XML, una cadena

con el código XML cargado en un StingReader, o un objeto XmlReader.


un argumento de tipo XMLReadMode, opcional.

ReadXml creará el esquema relacional del DataSet dependiendo de lo indicado

en este argumento y de si ya existe un esquema relacional. Podremos indicar

que se ignore el esquema de los datos XML en favor de la estructura del

conjunto de datos, o que por el contrario determine la estructura examinando

los datos XML, entre otras opciones.

Lo ilustramos con un ejemplo:

Hemos creado una aplicación de formulario Windows y, en el evento Load del

formulario principal, hemos colocado el código que ves a continuación:

Private Sub Form1_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.Load

'Creamos un conjunto de datos

Dim ds As DataSet = New DataSet

'y una tabla para el conjunto de datos

Dim dt As New DataTable("la_tabla")

'con una columna

dt.Columns.Add("col1", Type.GetType("System.String"))

ds.Tables.Add(dt)

'En una cadena de texto escribimos el código XML que describe una

'pequeña estructura de datos de ejemplo

Dim texto_Xml As String

texto_Xml = "<datos><la_tabla><col1>Valor 1</col1></la_tabla>" _

& "<la_tabla><col1>Valor 2</col1></la_tabla></datos>"

'La guardamos en un StringReader

Dim SR_text_Xml As New System.IO.StringReader(texto_Xml)

'Con ReadXml se cargarán los datos XML en el conjunto de datos

ds.ReadXml(SR_text_Xml, XmlReadMode.IgnoreSchema)

'Tenemos una lista desplegable en nuestro formulario.

'Usamos para él el DataSet (su tabla "la_tabla") como fuente de

'datos.

Me.ComboBox1.DataSource = ds.Tables("la_tabla")

Me.ComboBox1.DisplayMember = "col1" 'columna que se muestra

Me.ComboBox1.ValueMember = "col1"

End Sub


Lo que hace este código es cargar un DataSet con datos XML contenidos

directamente en un StringReader. Estos son los datos XML, organizados más

claramente:

<datos>

<la_tabla>

<col1>

Valor 1

</col1>

</la_tabla>

<la_tabla>

<col1>

Valor 2

</col1>

</la_tabla>

</datos>

También podríamos haber escrito este código en un archivo XML y pasar su ruta

a ReadXml como primer parámetro, en una cadena de texto.

Antes de leer los datos con ReadXml hemos definido una tabla con una columna

para el conjunto de datos. Como ves los datos XML tienen esta misma

estructura (nodo “la_tabla” que contiene al nodo “col1”). Es necesario en este

caso, pues al leer los datos con ReadXml indicamos el modo IgnoreSchema,

el cual pasa por alto el esquema de los datos XML y los carga en el esquema

existente en el DataSet, esto es, la estructura de tabla y columna que hemos

definido.

Cambiamos ahora el modo de lectura a InferSchema.


Este modo deduce el esquema por la estructura de los datos XML. Por eso, no

necesitamos definir ninguna tabla en el conjunto de datos, el esquema se

creará en función de los datos XML.

Observa que, al vincular la fuente de datos de la lista desplegable con el

DataSet, vinculamos a la tabla “la_tabla”, obtenida de la estructura XML.

Con los datos XML cargados en un DataSet será posible manipularlos de forma

relacional, tal y como vimos en temas anteriores.



'Creamos un conjunto de datos

Dim ds As DataSet = New DataSet

'En una cadena de texto escribimos el código XML que describe una

'pequeña estructura de datos de ejemplo

Dim texto_Xml As String

texto_Xml = "<datos><la_tabla><col1>Valor 1</col1></la_tabla>" _

& "<la_tabla><col1>Valor 2</col1></la_tabla></datos>"

'La guardamos en un StringReader

Dim SR_text_Xml As New System.IO.StringReader(texto_Xml)

'Con ReadXml se cargarán los datos XML en el conjunto de datos

ds.ReadXml(SR_text_Xml, XmlReadMode.InferSchema)

'Tenemos una lista desplegable en nuestro formulario.

'Usamos para él el DataSet (su tabla "la_tabla") como fuente de

'datos.

Me.ComboBox1.DataSource = ds.Tables("la_tabla")

Me.ComboBox1.DisplayMember = "col1" 'columna que se muestra

Me.ComboBox1.ValueMember = "col1"

End Sub


10.3. GENERACIóN DEL DOCuMENTO XML A PARTIR DE uN CONjuNTO DE DATOS

ADO.NET permite generar una representación con formato XML de losdatos de un DataSet, con o sin esquema. El esquema generado contendrá

las definiciones de las tablas, relaciones y restricciones del DataSet.

La representación XML se podrá escribir en un archivo, como un objetoSystem.IO.Stream, una cadena de texto o en un objeto XmlWriter.

Si queremos la representación XML como una cadena de textoutilizaremos el método GetXml del DataSet. Este método no generará el

esquema, para obtenerlo (también en una cadena) deberemos usar

GetXmlSchema.

Si queremos los datos XML en un archivo, flujo (Stream) o un XmlWriter,utilizaremos el método WriteXml del conjunto de datos.

Como primer parámetro del método WriteXml habrá que suministrar el destino

de los datos XML (una cadena con la ruta a una archivo de destino o un objeto

XmlWriter…) y como segundo, opcionalmente, un argumento de tipo

XmlWriteMode para indicar cómo se va a escribir el resultado.


Observa el código que se muestra a continuación:

Lo que hace es lo siguiente:

Tomamos un DataSet, lleno con los datos de la base de datos que guardamos

en el archivo “nueva.mdf”. Esta base de datos contiene una tabla llamada

“Agenda”.



Dim conexion As New SqlConnection

conexion.ConnectionString = "Data Source=.\SQLEXPRESS;" _

& "AttachDbFilename=C:\nueva.mdf;" _

& "Integrated Security=True;" _

& "Connect Timeout=30;" _

& "User Instance=True"

Dim consulta As String = "SELECT * FROM Agenda"

Dim conjunto_datos As New DataSet("ConjuntoDatos")

Dim adaptador As New SqlDataAdapter()

'Definimos el comando de selección de datos.

adaptador.SelectCommand = New SqlCommand(consulta, conexion)

'Llenamos el DataSet con el método Fill del adaptador.

adaptador.Fill(conjunto_datos, "Agenda")

'Escribimos el DataSet en formato XML

conjunto_datos.WriteXml("c:\agenda.xml",XmlWriteMode.WriteSchema)

conjunto_datos.Dispose()

adaptador.Dispose()

End Sub


Usamos el método WriteXml de nuestro DataSet para crear la versión XML de

los datos que contiene. Mediante una cadena de texto especificamos el nombre

y ruta del archivo de destino, y elegimos el modo WriteSchema para que crear

también el esquema de los datos.

Si, tras ejecutar este código, abrimos el archivo XML generado veremos que la

primera parte del documento corresponde al esquema, delimitada por

<xs:schema>…</xs:schema> y, a continuación están los datos del DataSet, más

concretamente los de la tabla “Agenda”, representados según el formato XML.

En la página siguiente puedes ver el documento XML que generó el fragmento

de código anterior.


<?xml version="1.0" standalone="yes"?>

<ConjuntoDatos>

<xs:schema id="ConjuntoDatos" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema"

xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">

<xs:element name="ConjuntoDatos" msdata:IsDataSet="true"

msdata:UseCurrentLocale="true">

<xs:complexType>

<xs:choice minOccurs="0" maxOccurs="unbounded">

<xs:element name="Agenda">

<xs:complexType>

<xs:sequence>

<xs:element name="NIF" type="xs:string" minOccurs="0" />

<xs:element name="Nombre" type="xs:string" minOccurs="0" />

<xs:element name="Apellidos" type="xs:string" minOccurs="0" />

<xs:element name="Telefono" type="xs:string" minOccurs="0" />

</xs:sequence>

</xs:complexType>

</xs:element>

</xs:choice>

</xs:complexType>

</xs:element>

</xs:schema>

<Agenda>

<NIF>1000000A</NIF>




</Agenda>

<Agenda>

<NIF>2000000B</NIF>




</Agenda>

<Agenda>

<NIF>3000000C</NIF>




</Agenda>

</ConjuntoDatos>


Podemos comprobar que la representación XML de los datos se corresponde

con el modelo relacional del que se originó.

Añadimos código al ejemplo que cargue otro DataSet con los datos del archivo

XML previamente generado. Finalmente vinculamos ese conjunto de datos

como fuente de datos de un control DataGridView (rejilla).










Dim conjunto_datos As New DataSet






'Escribimos el DataSet en formato XML

conjunto_datos.WriteXml("c:\agenda.xml",XmlWriteMode.WriteSchema)


adaptador.Dispose()

'Ahora realizamos el paso inverso: cargamos los datos XML en un dataset

Dim ds2 As New DataSet

ds2.ReadXml("c:\agenda.xml", XmlReadMode.InferSchema)

'Mostramos los datos en un control DataGridView

'previamente añadido al formulario

Me.DataGridView1.DataSource = ds2.Tables("Agenda")

End Sub


Si probamos la aplicación veremos en la rejilla los datos que contiene el archivo

XML, eso sí, representados de forma relacional a través del conjunto de datos

“ds2”.

Como ves, hemos tenido que crear un conjunto de datos para asociarlos datos XML a la rejilla. Si hubiésemos usado un objeto de la claseXmlDataDocument, hubiésemos podido vincular directamente sucontenido a la rejilla, pues, como ya hemos dicho, cuenta con su propiavista relacional de los datos.

Además, si desde la rejilla o de cualquier otra forma, hiciésemos cambios en

los datos del DataSet éstos no se reflejarían en los datos XML, pues son

independientes. Sin embargo, esto sí ocurriría con un objeto XmlDataDocument

sincronizado con un DataSet.

10.6. SINCRONIZACIóN DE DATASET Y XMLDATADOCuMENT

.Net Framework nos va a permitir el acceso síncrono en tiempo real tantoa la representación relacional como a la representación jerárquica delos datos mediante la sincronización de DataSet y XmlDataDocument.

un Dataset y un XmlDataDocument sincronizados trabajan con unúnico conjunto de datos. Esto implica, como ya se ha comentado, que los

cambios realizados en uno de los objetos se reflejarán instantáneamente en el

otro.


Esta estrecha relación entre DataSet y XmlDataDocument permite que unaúnica aplicación, con un único conjunto de datos, disponga de todas las

propiedades y funcionalidades de DataSet (vínculos con controles de

formulario…), y, a la vez, de las que ofrece todo el conjunto de servicios XML

heredado de XMLDocument.

Podemos sincronizar un DataSet y XmlDataDocument de varias formas.

A continuación presentamos un ejemplo que llena el DataSet “conjunto_datos”

con datos de una base de datos (datos relacionales) y después lo sincroniza

con un nuevo XmlDataDocument llamado “xmlDoc”.










Dim conjunto_datos As New DataSet("ConjuntoDatos")






'Crea un XmlDataDocument sincronizado "con conjunto_datos".

Dim xmlDoc As New Xml.XmlDataDocument(conjunto_datos)

'Genera un archivo XML con los datos que contiene.

xmlDoc.Save("c:\xml_generado.xml")


adaptador.Dispose()

End Sub


Este modo nos proporciona una vista jerárquica de datos relacionalesexistentes.

Lo comprobamos generando un archivo XML con los datos que contiene el

XmlDataDocument una vez sincronizado. De esto se encarga el método Savede XmlDataDocument, al que pasamos como argumento el nombre del archivo

de destino. Observa cómo se ha creado una estructura XML de los datos de la

base de datos, sin esquema en esta ocasión:

Ahora vamos a llenar un DataSet sólo con el esquema, sincronizarlo con un

XmlDataDocument y después cargaremos el XmlDataDocument con los datos

de un archivo XML. Utilizaremos el archivo XML que acabamos de generar en

el ejemplo anterior.

Este ejemplo nos proporcionará una vista relacional a partir de datosjerárquicos (XML) existentes.

<DataSetAgenda>

<Agenda>

<NIF>1000000A</NIF>




</Agenda>

<Agenda>

<NIF>2000000B</NIF>




</Agenda>

<Agenda>

<NIF>3000000C</NIF>




</Agenda>

</DataSetAgenda>


Como hemos comentado, creamos una tabla que define el esquema para elDataSet. En este esquema es necesario que coincidan los elementosdel documento XML que se desea exponer a la vista relacional. En

nuestro caso, hemos dejado fuera deliberadamente el campo “Telefono” para

comprobar que es posible obtener una vista parcial de los datos, dejandofuera los que no nos interese mostrar o manipular en ese momento.



Dim conjunto_datos As New DataSet()

'Creamos la estructura de la tabla "Agenda" en el conjunto de 'datos

'(¡Ojo con las mayúculas, deben coincidir!)

Dim tabla As New DataTable("Agenda")

Dim campo1 As New DataColumn("NIF")

Dim campo2 As New DataColumn("Nombre")

Dim campo3 As New DataColumn("Apellidos")

'añadimos los campos a la tabla

tabla.Columns.Add(campo1)



'añadimos la tabla al DataSet

conjunto_datos.Tables.Add(tabla)

'sincronizamos un nuevo XmlDataDocument con el conjunto de

' datos


'cargamos datos XML desde un archivo

xmlDoc.Load("c:\xml_generado.xml")

'Probamos la vista relacional de los datos en un control

'DataGridView

Me.DataGridView1.DataSource = xmlDoc.DataSet.Tables("Agenda")


End Sub


De esta forma, podremos tener un documento XML muy grande yexponer en modo relacional sólo una parte del mismo. Aunque así lohagamos, el objeto XmlDataDocument conserva todo el documentoXML.

Por último, observa cómo la vista relacional de los datos que contiene unXmlDataDocument está disponible a través de su propiedad DataSet.

Podríamos haber definido el esquema en el propio DataSet delXmlDataDocument y nuestro ejemplo seguiría teniendo un funcionamiento

similar. Compruébalo:

Sustituye:

Dim conjunto_datos As New DataSet()

Por:

Dim xmlDoc As New Xml.XmlDataDocument

Dim conjunto_datos As DataSet = xmlDoc.dataset

Y quita la instrucción que sincronizaba el conjunto de datos con el documento

XML:


Así obtenemos una vista relacional de los datos usando únicamente el objeto

XmlDataDocument que, como has comprobado, contiene en sí mismo tanto la

representación jerárquica de los datos como la relacional.

tema 10. ado.net y xml 10.1. xml y .net framework xml … · también podríamos haber escrito este...

Documents