El Blog de Óscar Sotorrío Sánchez - MCP Application Development Foundation - C#

Todo lo que vaya aprendiendo de .NET, C#, ASP.NET, SQL Server, etc, lo compartiré con vosotros.

El autor:

Óscar Sotorrío Sánchez
Contacto Send mail

Encuéntralo

Álguien dijo...


Ojo por ojo, y el mundo terminará ciego.

Mahatma Gandhi

Modificar y borrar datos XML

En los artículos anteriores vimos como leer, escribir e insertar datos en un archivo XML. Aquí veremos como modificar (o remplazar) y borrar un nodo de nuestro XML.

De esta forma quedan cubiertas todas las acciones que se pueden realizar sobre nuestros registros en documentos XML. Recordaros como siempre que el código hace referencia al archivo XML que utilizamos en el primer artículo de esta serie.

El código que aquí veremos se puede utilizar tanto para modicar un nodo como para borrarlo, tan solo con una leve diferencia. Cuando sea el momento, veremos en que consiste esta pequeña diferencia.

Pasemos a las explicaciones. Los objetos XmlDocument, XmlElement y XmlNode disponen de dos métodos que nos permitirán realizar la modificación y la eliminación del nodo deseado. Estos métodos son:

  • ReplaceChild(nodoNew, nodoOld). Reemplaza el nodo existente por el nodo con los nuevos datos.
  • RemoveChild(nodoOld). Elimina un nodo permanentemente.

Estos métodos actuan sobre los nodos secundarios del objeto que realiza la llamada. Por lo tanto, el "truco" consiste en posicionarse en el árbol del XML sobre el nodo padre del nodo que pretendemos actualizar, reemplazar o borrar.

El código que a continuación veremos hace uso del método secundario CrearNodoXml() que ya vimos en al artículo "Insertar datos XML". Recordar que este método devuelve un objeto XmlNode de tipo "empleado" devidamente construido.

public void ModificarDatosXml(string id, string nom, string ape, string nss, string fijo, string mvl)
        {
            
//Cargamos el documento XML.
            
documento = new XmlDocument();
            
documento.Load(Ruta);

            
//Obtenemos el nodo raiz del documento.
            
XmlElement empleados documento.DocumentElement;

            
//Obtenemos la lista de todos los empleados.
            
XmlNodeList listaEmpleados documento.SelectNodes("empleados/empleado");

            foreach 
(XmlNode item in listaEmpleados)
            {
                
//Determinamos el nodo a modificar por medio del id de empleado.
                
if (item.FirstChild.InnerText == id)
                {
                    
//Nodo sustituido.
                    
XmlNode nodoOld item;

                    
//Nodo nuevo.
                    
XmlNode nodoNew CrearNodoXml(id, nom, ape, nss, fijo, mvl);

                    
//Remplazamos el nodo.
                    
empleados.ReplaceChild(nodoNew, nodoOld);

                    
//Borrar un nodo.
                    //empleados.RemoveChild(nodoOld);
                
}
            }

            
//Salvamos el documento.
            
documento.Save(Ruta);
        
}

Categories: XML
Posted by Oscar.SS on viernes, 30 de octubre de 2009 21:50
Permalink | Comentarios (0) | Post RSSRSS comment feed

Paginación con XSLT y XML

El motivo de este post es crear una forma de paginar el contenido de un archivo XML formateando los datos por medio de la tecnología XSLT.

En principio la idea es bien sencilla. Supongamos un archivo XML como el siguiente:

 

<?xml version="1.0" encoding="utf-8" ?>
<empleados>  
	<empleado id="1" nombre="Pedro" salario="45234€" />  
	<empleado id="2" nombre="Carlos" salario="45234€" />  
	<empleado id="3" nombre="Juan" salario="65362€" />  
	<empleado id="4" nombre="Antonio" salario="13134€" />  
	<empleado id="5" nombre="Manolo" salario="623462€" />  
	<empleado id="6" nombre="Aitor" salario="45234€" />
</empleados>
 

Lo que pretendemos es mostrar los elementos empleado del XML paginados de 2 en 2. En este caso tendremos un total de 3 páginas.

Podemos modificar el XML para que contenga un nodo raiz en el que guardaremos como atributos los datos necesarios para la páginación. Nuestro XML quedaría así:

 

<?xml version="1.0" encoding="utf-8" ?>
<pag posicionInicial="1" elementosPagina="2">
<empleados>  
	<empleado id="1" nombre="Pedro" salario="45234€" />  
	<empleado id="2" nombre="Carlos" salario="45234€" />  
	<empleado id="3" nombre="Juan" salario="65362€" />  
	<empleado id="4" nombre="Antonio" salario="13134€" />  
	<empleado id="5" nombre="Manolo" salario="623462€" />  
	<empleado id="6" nombre="Aitor" salario="45234€" />
</empleados>
</pag>
 

Lo mejor de esta técnica es que podemos añadir y modificar los atributos del nodo <pag> por medio de JavaScript mejorando la experiencia del usuario. Podemos cargar el XML entero en memoria y modificar los atributos ahorrando de este modo viajes innecesarios al servidor.

Ahora solo tendremos que recoger los valores de los atributos posicionInicial y elementosPagina en el código XSLT a modo de variables, tal y como se indica a continuación.

<xsl:variable name="start" select="pag/@posicionInicial" />
<
xsl:variable name="limint" select="pag/@elementosPagina" />
<
xsl:variable name="end" select="$start + $limint - 1" />
<
xsl:foreach select="pag/empleados/empleado[position() >= $start and position() <= $end]">          <xsl:sort select="@id" order="descending"/>

Aquí pondríamos todo el código HTML que fuera necesario.
</xsl:for-each>

 

Después de esto, por medio del evento onClick de una imagen o botón, tanto para avanzar como retroceder, llamaremos a una función JavaScript que se encarge en cada caso de aumentar (++) o disminuir (--) en 1 el valor del atributo XML posicionInicial.


Tags:
Categories: XML
Posted by Oscar.SS on sábado, 25 de julio de 2009 23:00
Permalink | Comentarios (0) | Post RSSRSS comment feed

Insertar datos XML

Anteriormente vimos como leer datos y escribir datos en un archivo XML. Ahora vamos a mostrar como insertar un nodo o registro en cualquier lugar del árbol de nodos del archivo XML. 

Aunque comenzaremos viendo como insertar un nodo al final de un archivo, que es la operación más habitual, luego veremos como insertar un registro de forma más controlada.

Dado que las clases que vamos a utilizar para este ejemplo ya fuerón explicadas anteriormente recomiendo a todo el mundo que lean en primer lugar los artículos precedentes. Además el modelo de archivo XML es el mismo que en los ejemplos anteriores.

En primer lugar crearemos el nodo que deseamos insertar.

 

      private XmlNode CrearNodoXml(string id, string nom, string ape, string nss, string fijo, string mvl)
      {
         
//Creamos el nodo que deseamos insertar.
         
XmlElement empleado documento.CreateElement("empleado");

         
//Creamos el elemento idEmpleado.
         
XmlElement idEmpleado documento.CreateElement("idEmpleado");
         
idEmpleado.InnerText id;
         
empleado.AppendChild(idEmpleado);

         
//Creamos el elemento nombre.
         
XmlElement nombre documento.CreateElement("nombre");
         
nombre.InnerText nom;
         
empleado.AppendChild(nombre);

         
//Creamos el elemento apellidos.
         
XmlElement apellidos documento.CreateElement("apellidos");
         
apellidos.InnerText ape;
         
empleado.AppendChild(apellidos);

         
//Creamos el elemento numeroSS.
         
XmlElement numeroSS documento.CreateElement("numeroSS");
         
numeroSS.InnerText nss;
         
empleado.AppendChild(numeroSS);

         
//Creamos el elemento telefonos.
         
XmlElement telefonos documento.CreateElement("telefonos");
         
empleado.AppendChild(telefonos);

               
//Creamos el elemento fijo.
               
XmlElement nodoFijo documento.CreateElement("fijo");
               
nodoFijo.InnerText fijo;
               
telefonos.AppendChild(nodoFijo);
               
//Creamos el elemento movil.
               
XmlElement movil documento.CreateElement("movil");
               
movil.InnerText mvl;
               
telefonos.AppendChild(movil);

         return 
empleado;
      
}

 

Una vez que tenemos el nodo creado procedemos a insertar un registro al final del documento XML.

 

      private void InsertarXml()
      {
         
//Cargamos el documento XML.
         
documento = new XmlDocument();
         
documento.Load(ruta);

         
//Creamos el nodo que deseamos insertar.
         
XmlNode empleado = this.CrearNodoXml("4""Gerardo""Montaz Soaz""444-444-444-444""893434220""609334209");

         
//Obtenemos el nodo raiz del documento.
         
XmlNode nodoRaiz documento.DocumentElement;

         
//Insertamos el nodo empleado al final del archivo
         
nodoRaiz.InsertAfter(empleado, nodoRaiz.LastChild);   //***

         
documento.Save(ruta);
      
}

Ahora nos fijamos en la función anterior justo en la linea que esta marcada con //*** . Esta linea es la que inserta el nodo precisamente a

continuación del último nodo del documento XML. Como hemos comentado antes esta es la operación más usual pero existen más opciones.

 

  •  Insertar antes del último nodo del documento.
         nodoRaiz.InsertBefore(empleado, nodoRaiz.LastChild);
  • Insertar después del primer nodo del documento.
         nodoRaiz.InsertAfter(empleado, nodoRaiz.FirstChild);
  • Insertar antes del primer nodo del documento.
         nodoRaiz.InsertBefore(empleado, nodoRaiz.FirstChild);
  • Insertar en un lugar determinado del documento.
      nodoRaiz.InsertAfter(empleado, documento.SelectNodes("empleados/empleado").Item(2)); 
En este último caso hay que tener en cuenta que el método Item() accede a la colección de nodos del documento, y esta colección tiene
un índice inicial igual acero. En el ejemplo, hemos insertado el nodo después del elemento 2 de la colección, pero podíamos haberlo insertado 
antes con InsertBefore().


Descargar código:InsertarXML.rar (22,83 kb)

Categories: XML
Posted by Oscar.SS on domingo, 26 de abril de 2009 5:47
Permalink | Comentarios (15) | Post RSSRSS comment feed

Escribir datos XML

De alguna forma, este artículo es una continuación de "Lectura de datos XML" que vimos hace algunos días. Por este motivo recomiendo leer el artículo anterior para que sea más fácil familiarizarse con los conceptos que ahora veremos.

Para escribir datos en un archivo XML utilizaremos la clase XmlTextWriter que hereda de la clase XmlWriter. En cuanto a XmlWrite, veremos en otro artículo como utilizarla. Realmente su uso se parece bastante a lo que veremos aquí con XmlTextWriter  pero con algunos matices.

Los métodos que utilizaremos de la clase XmlTextWriter son los siguientes:

  • XmlTextWriter.WriteStartDocument(): Este método escribe la declaración XML con la versión 1.0.
  • XmlTextWriter.WriteStartElement(): Escribe el comienzo de un nodo.
  • XmlTextWriter.WriteElementString(): Se utiliza para escribir el contenido de cadena de un elemento.
  • XmlTextWriter.Flush(): Escribe todo el contenido almacenado en el bufer en el archivo XML.

Ahora veremos una función que escribe el mismo esquema de datos XML que vimos en "Lectura de datos XML".

 

public void EscribirXml(string id, string nom, string ape, string nss, string fijo, string mvl)
      {
         
//Creamos el escritor.
         
using (XmlTextWriter Writer = new XmlTextWriter(Ruta, Encoding.Unicode))
         {
            
//Declaración inicial del Xml.
            
Writer.WriteStartDocument();

            
//Configuración.
            
Writer.Formatting Formatting.Indented;
            
Writer.Indentation 5;

            
//Escribimos el nodo principal.
            
Writer.WriteStartElement("empleados");

            
//Escribimos un nodo empleado.
            
Writer.WriteStartElement("empleado");

            
//Escribimos cada uno de los elementos del nodo empleado.
            
Writer.WriteElementString("idEmpleado", id);
            
Writer.WriteElementString("nombre", nom);
            
Writer.WriteElementString("apellidos", ape);
            
Writer.WriteElementString("numeroSS", nss);
            
//Escribimos el subnodo teléfono.
            
Writer.WriteStartElement("telefonos");
            
Writer.WriteElementString("fijo", fijo);
            
Writer.WriteElementString("movil", mvl);
            
            
//Cerramos el nodo y el documento.
            
Writer.WriteEndElement();
            
Writer.WriteEndDocument();
            
Writer.Flush();
         
}
      }
Como se puede apreciar no tiene ninguna dificultad. Otro día comentaremos como incluir nuevos registros al final de un archivo XML.

Categories: XML
Posted by Oscar.SS on domingo, 01 de febrero de 2009 21:28
Permalink | Comentarios (4) | Post RSSRSS comment feed

Lectura de datos XML

En el espacio de nombres System.Xml tenemos a nuestra disposición multitud de clases que nos permiten el manejo, escritura y lectura de los archivos XML. En este artículo nos centraremos en la lectura de los datos almacenados en un archivo XML.

Supongamos que tenemos un archivo XML que guarda los datos de los empleados de una empresa. Estos datos podrían ser el nombre, los apellidos, el número de la seguridad social y el teléfono. Simplificando mucho el archivo podría tener la siguiente estructura:

 

<?xml version="1.0" encoding="utf-8" ?>
<empleados>
  <empleado>
    <idEmpleado>
1</idEmpleado>
    <nombre>Pedro</nombre>
    <apellidos>Martinez Segura</apellidos>
    <numeroSS>
111-111-111-111</numeroSS>
    <telefonos>
      <fijo>
913847913</fijo>
      <movil>
680432874</movil>
    </telefonos>
  </empleado>

  <empleado>
    <idEmpleado>
2</idEmpleado>
    <nombre>Amalia</nombre>
    <apellidos>García Pedrueza</apellidos>
    <numeroSS>
222-222-222-222</numeroSS>
    <telefonos>
      <fijo>
947895433</fijo>
      <movil>
678343221</movil>
    </telefonos>
  </empleado>

  <empleado>
    <idEmpleado>
3</idEmpleado>
    <nombre>Luis</nombre>
    <apellidos>Gómez Luta</apellidos>
    <numeroSS>
333-333-333-333</numeroSS>
    <telefonos>
      <fijo>
968454907</fijo>
      <movil>
678453248</movil>
    </telefonos>
  </empleado>
</empleados>

Lo que pretendemos es implementar un método que nos permita recuperar los datos de un empleado en función de un número (idEmpleado) introducido por el usuario de nuestra aplicación.

Para leer este documento vamos a utilizar los siguientes objetos:

  • XmlDocument. Representa el documento o archivo XML. Con este objeto cargaremos el archivo XML que pretendemos leer.
  • XmlNodeList. Representa una colección de nodos XML. Permite obtener todos los nodos de un tipo concreto especificado por una ruta XPath.
  • XmlNode.Representa un único nodo. Con él podremos acceder a su contenido, tanto si solo contiene una cadena de texto como si contine otros nodos (nodos hijos).

A grandes rasgos, la técnica a ejecutar es la siguiente. Primeramente obtenemos una lista con todos los empleados, de esta lista obtenemos el empleado en función del número introducido por el usuario. A continuación pasamos a recuperar los datos del empleado.

Aquí teneís una función que realiza esta tarea. No es la única forma de hacerlo, así que os aconsejo que investiguéis y encotréis por vuestros propios medios la forma que más comoda os resulte.

 

        public void ObtenerEmpleado(int numEmpleado)
        {
            
//Creamos un documento y lo cargamos con los datos del XML.
            
XmlDocument documento = new XmlDocument();
            
documento.Load("Ruta y nombre del archivo XML");

            
//Obtenemos una colección con todos los empleados.
            
XmlNodeList listaEmpleados documento.SelectNodes("empleados/empleado");

            
//Creamos un único empleado.
            
XmlNode unEmpleado;

            
//Recorremos toda la lista de empleados.
            
for (int 0i < listaEmpleados.Counti++)
            {
                
//Obtenemos cada empleado.
                
unEmpleado listaEmpleados.Item(i);

                
//Seleccionamos el id del empleado.
                
int idEmpleado Convert.ToInt32(unEmpleado.SelectSingleNode("idEmpleado").InnerText);

                
//Comprobamos que el id de empleado sea el mismo que el número introducido por el usuario.
                
if (numEmpleado == idEmpleado)
                {
                    Console.WriteLine()
;

                    
//Obtenemos el nombre.
                    
Console.WriteLine("Nombre: {0}", unEmpleado.SelectSingleNode("nombre").InnerText);

                    
//Obtenemos los apellidos.
                    
Console.WriteLine("Apellidos: {0}", unEmpleado.SelectSingleNode("apellidos").InnerText);

                    
//Obtenemos el número de la seguridad social.
                    
Console.WriteLine("N.S.S.: {0}", unEmpleado.SelectSingleNode("numeroSS").InnerText);

                    
//Obtenemos la lista de telefonos.
                    
XmlNodeList telefonos unEmpleado.SelectSingleNode("telefonos").ChildNodes;

                    
//Obtenemos el teléfono fijo y movil.
                    
XmlNode tlfFijo telefonos[0];
                    
XmlNode tlfMovil telefonos[1];

                    
Console.WriteLine("Teléfono fijo: {0}", tlfFijo.InnerText);
                    
Console.WriteLine("Teléfono movil: {0}", tlfMovil.InnerText);
                
}
            }
        }

Categories: XML
Posted by Oscar.SS on jueves, 18 de diciembre de 2008 15:23
Permalink | Comentarios (2) | Post RSSRSS comment feed