Post on 12-Oct-2018
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"?>
<!-- Esto es un comentario -->
<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>
<Telefono>92222222</Telefono>
</Persona>
<Persona>
<NIF>3000000C</NIF>
<Nombre>Felipe</Nombre>
<Apellidos>López Fernández</Apellidos>
<Telefono>93333333</Telefono>
</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.
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
10.3Programación .NET (II). ADO.NET y XML
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.
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<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>
Programación .NET (II). ADO.NET y XML10.4
¿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.
10.5Programación .NET (II). ADO.NET y XML
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”.
Programación .NET (II). ADO.NET y XML10.6
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.
10.7Programación .NET (II). ADO.NET y XML
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
Programación .NET (II). ADO.NET y XML10.8
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.
10.9Programación .NET (II). ADO.NET y XML
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.
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
'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
Programación .NET (II). ADO.NET y XML10.10
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.
10.11Programación .NET (II). ADO.NET y XML
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”.
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
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
Programación .NET (II). ADO.NET y XML10.12
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.
10.13Programación .NET (II). ADO.NET y XML
<?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>
<Nombre>Antonio</Nombre>
<Apellidos>Gutierrez Velasco</Apellidos>
<Telefono>911111111</Telefono>
</Agenda>
<Agenda>
<NIF>2000000B</NIF>
<Nombre>Ana</Nombre>
<Apellidos>Sánchez Blanco</Apellidos>
<Telefono>922222222</Telefono>
</Agenda>
<Agenda>
<NIF>3000000C</NIF>
<Nombre>Felipe</Nombre>
<Apellidos>López Fernández</Apellidos>
<Telefono>933333333</Telefono>
</Agenda>
</ConjuntoDatos>
Programación .NET (II). ADO.NET y XML10.14
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).
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
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
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()
'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
10.15Programación .NET (II). ADO.NET y XML
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.
Programación .NET (II). ADO.NET y XML10.16
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”.
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
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")
'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")
conjunto_datos.Dispose()
adaptador.Dispose()
End Sub
10.17Programación .NET (II). ADO.NET y XML
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>
<Nombre>Antonio</Nombre>
<Apellidos>Gutierrez Velasco</Apellidos>
<Telefono>911111111</Telefono>
</Agenda>
<Agenda>
<NIF>2000000B</NIF>
<Nombre>Ana</Nombre>
<Apellidos>Sánchez Blanco</Apellidos>
<Telefono>922222222</Telefono>
</Agenda>
<Agenda>
<NIF>3000000C</NIF>
<Nombre>Felipe</Nombre>
<Apellidos>López Fernández</Apellidos>
<Telefono>933333333</Telefono>
</Agenda>
</DataSetAgenda>
Programación .NET (II). ADO.NET y XML10.18
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.
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
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)
tabla.Columns.Add(campo2)
tabla.Columns.Add(campo3)
'añadimos la tabla al DataSet
conjunto_datos.Tables.Add(tabla)
'sincronizamos un nuevo XmlDataDocument con el conjunto de
' datos
Dim xmlDoc As New Xml.XmlDataDocument(conjunto_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")
conjunto_datos.Dispose()
End Sub
10.19Programación .NET (II). ADO.NET y XML
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:
Dim xmlDoc As New Xml.XmlDataDocument(conjunto_datos)
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.