Tutorial de XML con C Sharp
De Mono Hispano
Contents |
Tutorial de XML con C#
Autor: Christian Mauricio Castillo Estrada christian_mauricio83@yahoo.com.mx
Prologo
Este tutorial describe el uso de Archivos XML desde el lenguaje C# sobre la plataforma mono. Es un tutorial para nivel principiante y trata de describir el acceso a XML (Lectura y Escritura).
El Tutorial de XML con C# es Copyrigth (C) 2005 de Monohispano
Se otorga permiso para hacer y distribuir copias literales de este manual siempre y cuando la nota de copyright y esta nota de permisos se conserven en todas las copias.
Se otorga permiso para hacer y distribuir copias modificadas de este documento bajo las condiciones de la copia literal, siempre y cuando esta nota de copyright sea incluida exactamente como en el original, y que el trabajo derivado resultante completo sea distribuido bajo los mismos términos de nota de permisos que éste.
Se otorga permiso para hacer y distribuir traducciones de este documento a otras lenguas, bajo las anteriores condiciones para versiones modificadas.
Si pretendes incorporar este documento en un trabajo publicado, contacta por favor con el mantenedor, y haremos un esfuerzo para asegurar de que dispones de la información más actualizada.
No existe garantía de que este documento cumpla con su intención original. Se ofrece simplemente como un recurso libre y gratuito. Como tal, los autores y mantenedores de la información proporcionada en el mismo no garantizan de que la información sea incluso correcta.
Introducción
Conceptos Basicos
¿Qué es XML?
XML es el acrónimo del inglés eXtensible Markup Language (lenguaje de marcado ampliable o extensible) desarrollado por el World Wide Web Consortium (W3C).
Es una versión simple de SGML. Su objetivo principal es conseguir una página web más semántica. Aunque una de las principales funciones con las que se desarrollo es suceder al HTML, separando la estructura del contenido y permitiendo el desarrollo de vocabularios modulares, compatibles con cierta unidad y simplicidad del lenguaje, tiene otras aplicaciones entre las que destaca su uso como estándar para el intercambio de datos entre diversas aplicaciones o software con lenguajes privados como en el caso del SOAP.
El XML se basa en documentos de texto plano en los que se utilizan etiquetas <etiq> para delimitar los elementos de un documento. Sin embargo, XML define estas etiquetas en función del tipo de datos que está describiendo y no de la apariencia final que tendrán en pantalla o en la copia impresa, además de permitir definir nuevas etiquetas y ampliar las existentes.
Ejemplo de un Archivo de Datos XML
Como he mencionado anteriormente las sentencias en XML consisten en una serie de etiquetas (llamadas Elementos) con una serie de modificadores (llamados Atributos). Las etiquetas pueden estar anidadas unas dentro de otras, pero toda etiqueta que se abra se tiene que cerrar, y siempre en el mismo orden. En caso de que un elemento no tenga pareja (por no tener ningún contenido dentro), se le denomina elemento vacío y se indica con un / al final.
En el siguiente ejemplo podemos ver un sencillo archivo de datos XML, el cual sera utilizado en este Tutorial(datos.xml):
<?xml version="1.0" encoding="utf-8"?>
<persona>
<nombre>Christian Mauricio</nombre>
<apellido_p>Castillo</apellido_p>
<apellido_m>Estrada</apellido_m>
<edad>22</edad>
</persona>
El cual cuenta con 4 elementos que son nombre, apellido paterno, apellido materno y edad
Este pequeno archivo de datos XML describe a una Persona.
System.Xml
El espacio de nombres denominado System.Xml proporciona compatibilidad que esta basada en normas para el procesamiento de Archivos XML.
A continuacion doy a conocer las normas que son admitidas:
*XML 1.0: http://www.w3.org/TR/1998/REC-xml-19980210, incluida la compatibilidad con DTD. *Espacios de nombres XML: http://www.w3.org/TR/REC-xml-names/, tanto nivel de secuencias como DOM. *Esquemas XSD: http://www.w3.org/2001/XMLSchema *Expresiones XPath: http://www.w3.org/TR/xpath *Transformaciones XSLT: http://www.w3.org/TR/xslt *Core DOM Level 1: http://www.w3.org/TR/REC-DOM-Level-1/ *Core DOM Level 2: http://www.w3.org/TR/DOM-Level-2/
Este espacio de nombres tiene un conjunto completo de clases XML para análisis, validación y manipulación de datos XML mediante sistemas de lectura, sistemas de escritura y componentes compatibles con el consorcio World Wide Web (W3C) DOM.
A continuacion muestro las Clases principales del espacio de nombres XML, que son usadas en este tutorial:
XmlTextReader: Proporciona acceso rápido de lectura, sin almacenamiento en caché y con desplazamiento sólo hacia delante a datos XML. XmlNodeReader: Proporciona un objeto XmlReader a través del subárbol de nodo DOM dado. XmlTextWriter: Proporciona una forma rápida para el desplazamiento sólo hacia delante generando código XML.
Las clases del espacio de nombres se ajustan a las especificaciones del World Wide Web Consortium (W3C) y, por tanto, proporcionan un completo conjunto de herramientas XML con el fin de generar aplicaciones para Web y para cualquier escenario basado en el intercambio de datos XML.
XmlTextReader
La clase XmlTextReader nos permite leer Lenguaje de marcado extensible (XML) desde una secuencia. La secuencia puede provenir de diversos orígenes, como por ejemplo una secuencia de bytes de un servidor, un archivo o una clase TextReader.
El objeto StreamReader se utiliza para leer caracteres en archivos. Para su construccion necesitamos indicar el nombre del archivo de datos XML (ejemplo.xml), y el formato de codificacion de texto que en nuestro caso es UTF8.
StreamReader reader = new StreamReader (nombre_archivo_xml, System.Text.Encoding.UTF8);
Generalmente, XmlTextReader se utiliza si necesita tener acceso a XML como datos sin procesar sin la carga de un DOM; por lo tanto, XmlTextReader proporciona un mecanismo más rápido para leer XML. XmlTextReader tiene diferentes constructores para especificar la ubicación de datos de XML. En este tutorial utilizo un constructor al que se le pasa como parametro un StreamReader(Una Secuencia) que es nuestro objeto lector.
XmlTextReader lector = new XmlTextReader (reader);
Una vez generado nuestro objeto lector (xml), ya podemos realizar lecturas secuenciales para moverse por los datos del archivo XML, para esto debemos utilizar el método Read para ir leyendo cada uno de los registros. Este método nos devuelve False si no hay más registros que leer.
while (lector.Read ())
{
//Lectura del archivo XML
}
Para procesar los datos de XML, cada registro tiene un tipo de nodo, que puede estar determinado por la propiedad NodeType. Las propiedades Nombre y Valor devuelven el nombre del nodo (los nombres del elemento y del atributo) y el valor del nodo (el texto del nodo) del nodo actual (o registro).
La enumeración NodeType determina el tipo de nodo. Para leer un elemento de nodo debemos entonces llamar al método Name y luego podemos leer el valor de ese elemento con el método ReadString(), como se puede ver en el siguiente ejemplo:
switch (lector.NodeType)
{
case XmlNodeType.Element:
switch (lector.Name)
{
case "persona": break;
case "nombre": nombre = lector.ReadString ();
//Leemos el valor del elemento Nombre
break;
}
break;
}
Una vez terminada la lectura debemos cerrar el nuestro objeto de lectura:
lector.Close();
XmlTextWriter
La Clase XmlTextWriter es una implementación de la clase XmlWriter que proporciona la API y que escribe archivos de datos XML. Ademas, representa un sistema de escritura, sin almacenamiento en caché y con desplazamiento sólo hacia delante para generar secuencias o archivos con datos XML que satisface las recomendaciones relativas a espacios de nombres en XML y Extensible Markup Language (XML) 1.0 del Consorcio W3C. El objeto XmlTextWriter tiene distintos constructores, cada uno de los cuales especifica un tipo de ubicación diferente en la que se van a escribir los datos XML.
En este Tutorial utilizamos un constructor para declarar un objeto de la Clase XmlTextWriter, el cual se explica a continuacion:
XmlTextWriter obj = new XmlTextWriter (nombre_archivo_xml, System.Text.Encoding.UTF8);
En este ejemplo se declara un objeto, el cual sera utilizado para ejecutar los metodos que proporciona la Clase XmlWriter. En esta sentencia se indican 2 parametros el nombre del archivo XML(ejemplo.xml) y el tipo de codificacion de texto que en este caso es UTF8.
Una vez creado nuestro objeto escritor, podemos escribir los elementos que son las etiquetas para darle formato a nuestro archivo de datos XML.
Para escribir un elemento necesitamos indicar el nombre del elemento o etiqueta, luego el valor de ese elemento en formato tipo cadena de caracteres, como podemos ver en el siguiente ejemplo:
xml.WriteStartElement (null, "edad", null); //Escribimos la etiqueta edad xml.WriteString (txtedad.Text); //Los datos en formato cadena de caracteres xml.WriteEndElement ();
XPathNavigator
XPathNavigator es una clase abstracta. Puede ser creada por clases que implementa la intefaz IXPathNavigable. Existen dos implementaciones de clases: XPathDocument and XmlDocument.
Tu puedes extender XPathNavigator y crear tu propia implementacion. Algunos miembros son virtuales, asi que no tendras que implementar tales miembros, otros son abstractos asi que tendras que implementar estos por ti mismo.
Usualmente XPathNavigator carga completos los documentos en memoria, mientras XmlReader no hace esto. XPathNavigator no es una parte del ECMA CLI specification, ni tampoco una API estandar. Algunas personas de Microsoft dicen que ellos esta eligiendo XPathNavigator como una ruta aceptable en el manejo de XML.
XPathNavigator y XPath Data Model
XPathNavigator esta basado sobre su propio modelo de datos. Dicho modelo esta especificado en el XPath W3C Recommendation. El modelo de programacion de XPathNavigator es diferente al de XmlDocument. Cuando nosotros usamos XmlDocument y XmlNode, nosotros usualmente dejamos una variable que apunta a determinado XmlNode. Pero cuando nosotros usamos XPathNavigator, no hay clases que representen a XPath node.
Asi que las propiedades de los nodos son diferentes con respecto a las propiedades del XPathNavigator. Las propiedades son similares a XmlDocument o XmlReader: Name, LocalName, NamespaceURI, Value y NodeType.
Los Tipos de Nodo son definidos de acuerdo al XPathNodeType enumerator:
* All * Attribute * Comment * Element * Namespace * ProcessingInstruction * Root * SignificantWhitespace * Text * Whitespace
El tipo de Nodo "Namespace" sirve para representar el "namespace node" usado en el XPath. Nota que los atributos "xmlns" y "xmlns:*" no son considerados como attribute nodes, son diferentes a como se presenta en XmlDocument.
El tipo de Nodo "Root" sirve para representar document node (En XPath la expresion es "/"). EL tipo de Nodo "All" no es para representar un nodo.
Tu puedes utilizar algunas funciones similares a las de XmlReader: GetAttribute(), GetNamespace(), BaseURI, XmlLang y IsEmptyElement. GetNamepace() es similar a GetAttribute() pero regresa el nombre de espacio URI.
Para clonar o copiar un nodo se usa el metodo Clone(). Tu tendras que usar este metodo por ejemplo cuando tu quieras comparas dos nodos.
Princiaples Metodos de Navegacion
Existen varios metodos para navegar. Muchos de ellos regresan valores booleanos que indican que la operacion fue exitosa o no.
* MoveToRoot() Transporta a la raiz del Documento. Nunca Falla. * MoveToFirstChild() Transporta al primer nodo hijo. * MoveToFirstAttribute() Transporta al primer atributo del nodo. * MoveToFirstNamespace() Transporta al primer namespace del nodo. * MoveToPrevious () Mover hacia el nodo anterior. * MoveToNext() Mover al nodo siguiente. * MoveToNextAttribute() Mueve hacia el siguiente atributo del nodo. * MoveToNextNamespace() Mueve hacia el siguiente namespace del nodo. * MoveToFirst() Mueve hacia el primer nodo. * MoveToParent() Mueve hacia el nodo padre. * MoveToId() Mueve hacia el elemento que contenga dicho ID. * MoveTo() Mueve depediendo de los parametros del XPathNavigator.
XPathNodeIterator y Metodos de Seleccion
Cuando nosotros manejamos XPath "node-set", nosotros usamos la clase XPathNodeIterator. El Diseno de esta clase es muy simple; Una vez que tu obtienes un XPathNodeIterator, primeramente tu tendras que llamar a MoveNext() para ir hacia el siguiente nodo, y usar la propiedad Current que apunta al nodo actual. MoveNext() regresa un valor de false si no existen mas nodos que relacionar.
XPathNavigator nav = new XPathDocument ("my_document.xml").CreateNavigator ();
XPathNodeIterator links = nav.Select ("//a[@href]");
while (links.MoveNext ())
{
Console.WriteLine (links.Current.Value);
}
Nota que XPathNodeIterator se desplaza en un solo sentido. No puedes regresar.
* SelectChildren() Regresa los hijos filtrados por el argumento del nodo. * SelectDescendants() Regresa sus descendientes similares. * SelectAncestors() Regresa sus antecesores similares. * Select() Regresa el resultado node-set para la expresion especificada por el XPath.
Cuando especificamos XPath para el metodo Select(), tu puedes usar ambos tanto una expresion en formato string o un objeto compilado XPathExpression object. El objeto XPathExpression puede ser creado a traves del metodo Compile(). La compilacion XPath es un poco lenta, asi que usar XPathExpression quizas ayude a mejorar el desempeño.
Metodos de Evaluacion
En algunas ocaciones tu quizas quieras comparar posiciones, o evaluar valores basados en los tipo de el XPath tales como un numero, booleano, string, node-set y el resultado de un fragmento de un arbol. Estos tipos son representados en la enumeracion del XPathResultType y mapeados hacia los tipos de CLR types como los siguientes:
| XPath type | XPathResultType | CLR type |
|---|---|---|
| any type | Any | System.Objec |
| boolean | Boolean | System.boolean |
| (no equivalent) | Error | (no equivalent) |
| result tree fragment | Navigator | System.Xml.XPath.XPathNavigator |
| node-set | Node-set | System.Xml.XPath.XPathNodeIterator |
| number | Number | System.Double |
| string | String | System.String |
Metodos de Comparacion
Las ultimas piezas de XPathNavigator son los metodos de comparacion del arbol de nodos.
*IsDescendant() Verifica si el nodo apuntado por el argumento de XPathNavigator es su decendiente
o no.
*IsSamePosition() Verifica si el nodo apuntado por el argumento de XPathNavigator tambien apunta
al mismo nodo.
*ComparePosition() Regresa la posicion representada como un tipo de enumeracion del XmlNodeOrder.
Regresa un valor de "After" Si el argumento de nodo(apuntado por XPathNavigator) esta localizado
despues de este nodo. Si esta localizado antes de este nodo entonces regresa un "Before", y
"Same" cuando esten en la misma posicion.
Si las fuentes de los documentos son diferentes, entonces regresa un valor de "Unknown".
Nota que el modelo de datos XML (and of course XPath) no es conciente de el orden de los atributos. Asi que tu no deberias confiar en este "orden". Sin embargo, tu puedes confiar en el hecho de MoveToNextAttribute() itera todos los atributos de alguna forma.
Ejemplo: Mi primer aplicacion usando XML y C#
Requerimientos
Para este Ejemplo que doy a conocer en este Tutorial debes tener instalado:
mono 1.0 gtk-sharp 1.0
Descripcion de la Aplicacion
Esta aplicacion consiste en tener acceso a un archivo de datos XML utilizando como lenguaje de programacion C#, es decir utilizaremos el espacio de nombres System.Xml para accesar a nuestro archivo. Este ejemplo ofrece 2 funciones principales leer y escribir, para eso utilizo un interfaz grafica disenada en Glade-2, la cual puedes descargar en este mismo tutorial asi como tambien el codigo fuente (.cs) de la aplicacion. Esta interfaz grafica (GUI) esta divida en 2 principales secciones la de lectura y la del formato de registro para que el usuario pueda ingresar los datos que seran almacenados en formato XML.
Este un sencillo ejemplo de como podemos implementar el espacio de nombres System.Xml, pero se pueden realizar aplicacion muy complejas y utiles, espero que les guste este ejemplo y les sirva como base para entender el manejo de archivos XML desde C#.
Interfaz Grafica y Codigo Fuente
El diseno de la Interfaz Grafica será sencilla, básicamente será es una aplicación que lee y escribe datos desde un archivo XML.
Utilizando Glade generamos una interfaz semejante a la siguiente:
Básicamente nuestra interfaz contiene 1 label principal donde se visualizan los datos que son leidos, 4 Widgets del tipo Gtk.Entry para que el usuario pueda ingresar los datos correpondientes a cada elemento del archivo XML y por ultimo dos botones principales el de lectura y escritura.
Puedes descargar la interfaz grafica aqui.
Despues debemos generar el codigo de nuestra aplicacion utilizando el Lenguaje C#, el cual muestro a continuacion:
//XML - Ejemplo de la utilizacion de XML con el Lenguaje C# sobre la plataforma Mono
//Copyright (C) Julio - 2005 Christian Mauricio Castillo Estrada <xpchristian@hotmail.com>
namespace App{
using System;
using System.Collections;
using System.IO;
using System.Xml;
using Gtk;
using Gnome;
public class XmlApp
{
private string nombre,apellido_p,apellido_m,edad;
public static void Main (string[] args)
{
try{
new XmlApp (args);
}
catch(Exception e){ Console.WriteLine(e); }
}
private Glade.XML gxml;
#region Glade
[Glade.Widget("winmain")] Gtk.Window winmain;
[Glade.WidgetAttribute] private Gtk.Entry txtnombre;
[Glade.WidgetAttribute] private Gtk.Entry txtapellido_p;
[Glade.WidgetAttribute] private Gtk.Entry txtapellido_m;
[Glade.WidgetAttribute] private Gtk.Entry txtedad;
[Glade.WidgetAttribute] private Gtk.Entry txtnombre_xml;
[Glade.WidgetAttribute] private Gtk.Label texto;
[Glade.WidgetAttribute] private Statusbar statusbar;
#endregion
public XmlApp(string[] args)
{
//Inicializar la Interfaz Grafica
Application.Init();
gxml = new Glade.XML (null,"gui.glade", "winmain", null);
gxml.Autoconnect(this);
statusbar.Push(0,"Demo utilizacion de Archivos XMl con C# - Christian M. C.E.");
Application.Run();
}
public void gtk_widget_destroy(object sender, EventArgs a)
{
Gtk.Application.Quit();
}
public void on_btnleer_clicked(object o,EventArgs args)
{
if(txtnombre_xml.Text.Length==0)
{
Console.WriteLine("Debes de indicar un nombre de Archivo");
return;
}
Leer(txtnombre_xml.Text);
texto.Markup ="Hola "+nombre+" "+ apellido_p+" "+apellido_m+", \r\r\rTu edad es: "+edad+"";
statusbar.Push(0,"Leyendo Archivo XML");
}
public void on_btnescribir_clicked( object o,EventArgs args)
{
if(txtnombre_xml.Text.Length==0)
{
Console.WriteLine("Debes de indicar un nombre de Archivo");
return;
}
Escribir(txtnombre_xml.Text);
txtnombre.Text ="";
txtapellido_p.Text="";
txtapellido_m.Text ="";
txtedad.Text ="";
statusbar.Push(0,"Escribiendo en el Archivo XML");
}
public void on_btnacercade_clicked( object o, EventArgs args)
{
string[] authors = new string[]{"Christian Mauricio C.E. xpchristian@hotmail.com>"};
string[] doc = new string[] {};
About about = new About ("XmlApp","Beta 1","Copyright (C) 2005 Christian Mauricio <xpchristian@hotmail.com>","Ejemplo sobre el uso de archivos XML con C#",authors,doc,"",icono);
about.Show ();
}
//Esta Funcion permite Leer un Archivo XML
public void Leer(string nombre_xml)
{
//Declaramor un lector para el XML indicando el nombre de este
StreamReader reader = new StreamReader (nombre_xml, System.Text.Encoding.UTF8);
//Indicamos cual es el nombre de lector XML a usar en este caso es reader
XmlTextReader xml = new XmlTextReader (reader);
xml.Namespaces = false;
//Hacemos un ciclo para leer cada uno de los nodos del XML
while (xml.Read ())
{
//Vamos a leer cada uno de los elementos que contiene el archivo XML
//En este ejemplo los elementos son nombre,apellido_p,apellido_,
// y edad incluidos dentro del Nodo principal llamado Persona
switch (xml.NodeType)
{
case XmlNodeType.Element:
switch (xml.Name)
{
case "persona":
break;
case "nombre":
//Leemos el valor elemento Nombre
nombre = xml.ReadString ();
break;
case "apellido_p":
apellido_p = xml.ReadString ();
break;
case "apellido_m":
apellido_m = xml.ReadString ();
break;
case "edad":
edad = xml.ReadString ();
break;
}
break;
}
}
//Cerramos el lector de XML
xml.Close ();
}
//Esta funcion permite escribir en un archivo XML
public void Escribir(string nombre_xml)
{
//Declaramos un escritor de texto XML, indicando cual es el nombre del archivo XML
XmlTextWriter xml = new XmlTextWriter (nombre_xml, System.Text.Encoding.UTF8);
xml.Formatting = Formatting.Indented;
//Inicializamos el Documento XML
xml.WriteStartDocument ();
//Escribimos el Elemento Principal (Persona)
xml.WriteStartElement (null, "persona", null);
//Escribimos el elemento <nombre>
xml.WriteStartElement (null, "nombre", null);
//Escribimos el dato de ese elemento en formato tipo cadena (String)
xml.WriteString(txtnombre.Text);
//Cerramos el elemento </nombre>
xml.WriteEndElement ();
xml.WriteStartElement (null, "apellido_p", null);
xml.WriteString (txtapellido_p.Text);
xml.WriteEndElement ();
xml.WriteStartElement (null, "apellido_m", null);
xml.WriteString (txtapellido_m.Text);
xml.WriteEndElement ();
xml.WriteStartElement (null, "edad", null);
xml.WriteString (txtedad.Text);
xml.WriteEndElement ();
xml.WriteEndElement (); //Cerramos el Elemento Principal </persona>
xml.WriteEndDocument (); //Cerramos el Documento XML
xml.Close (); //Cerramos el Escritor XML
}
}
}
Descarga este Codigo Fuente aqui
Compilando y Ejecutando
Compilando la apliacion:
mcs Xml.cs -pkg:gtk-sharp -pkg:glade-sharp -pkg:gnome-sharp /resource:gui.glade
Ejecutando nuestra aplicacion:
mono Xml.exe
Dos ScreenShots de la Apliacion en ejecucion
Recuerda que debes crear un archivo (datos.xml), con la descripcion anteriormente descrita, la cual consiste en 4 elementos principales para describir una Persona.
Conclusiones
Puedo concluir que existen muchas tecnologias para el procesamiento de la informacion tal es el caso de los archivos de datos XML. Espero que este tutorial les haya gustado y minimo haber aprendido como se manipulan estos archivos desde el lenguaje C#. Actualmente el uso de XML es mas constante en el desarrollo de sistemas de informacion, asi que debemos aprender a usarlo e implementarlo.
Si encuentras algún error en este tutorial o quieres aportar algo nuevo, no dudes en notificármelo correo.
Powered by MediaWiki