xml, distribución y componentes tema 1 – procesamiento xml en.net
Post on 23-Jan-2016
222 Views
Preview:
TRANSCRIPT
XML, Distribución y Componentes
Tema 1 – Procesamiento XML en .NEThttp://paginaspersonales.deusto.es/dipina/MasterISW/
Dr. Diego Lz. de Ipiña Gz. de Artazahttp://paginaspersonales.deusto.es/dipina (Personal)
http://www.morelab.deusto.es (Research Group)http://www.smartlab.deusto.es (Research Lab)
http://www.ctme.deusto.es (Cátedra de Telefónica Móviles)http://www.tecnologico.deusto.es (Tecnológico-Fundación Deusto)
2/119
Temario
Procesamiento XML en .NET (21 y 22 Febrero) Estándar .NET [XML.NET] Soporte XML [XML-SAX, XML-DOM, Validación] XSL [XPath, XSLT, Scripts, Objetos de extensión]
Aplicaciones distribuidas (23 Febrero, 5 Marzo) XML/SOAP .NET Remoting Mensajería
Componentes .NET (6 y 7 Marzo) Metadatos y Reflexion Componentes .NET y Enterprise Services Complementos Interoperabilidad COM y P/Invoke COM+ y MTS MSMQ (colas de mensajes) Microsoft Communication Foundation (Indigo)
3/119
Contenidos Parte XML
XML DTD Schema
XML Parsing SAX API DOM API
XSLT XSLT Scripts XSLT Object Extensions
4/119
¿Qué es XML?
eXtensible Mark-up Language. Es un metalenguaje que permite diseñar otros lenguajes
(WML, MathML, XHTML,..). Cualquiera puede desarrollar su propio lenguaje de
etiquetas adecuado al tipo de aplicación que más le convenga.
En realidad hay muchas tecnologías basadas en XML (XPath, XLink, XPointer, XSL, ...).
XML 1.0 Specificationhttp://www.w3.org/TR/REC-xml
5/119
HTML y XML
SGML (Standard Generalized Markup Language) HTML es una aplicación de SGML XML es subconjunto más fácil de usar de SGML XHTML es una aplicación de XML
6/119
XML describe estructura y semántica
<?xml version=”1.0”><!DOCTYPE comedor SYSTEM “comedor.dtd”><comedor> <fabricante>Ipiña Altzariak</fabricante> <mesa tipo="redonda" madera="arce"> <precio>€400</precio> </mesa> <silla madera="arce"> <cantidad>2</cantidad> <calidad>excelente</calidad> <cojin incluido="sí"> <color>azul</color> </cojin> <precio>€200</precio> </silla></comedor>
7/119
HTML describe formato
<html> <head><title>Comedor</title></head> <body> <h1>Comedor</h1> <p>Fabricante: Ipiña Altzariak</p> <ul> <li><b>Mesa redonda de madera de
arce</b></li> <li><b>Dos sillas de madera de arce</b>,
de excelente calidad, con un cojín azul cada una.</li>
<li><b>3 sillas de madera de roble</b>.</li> </ul> </body></html>
8/119
Ventajas XML
Una de las mayores utilidades de XML es poder etiquetar los datos con su significado (self-describing data).
Permite la estructuración de la información. Ello lleva el tratamiento automático de la información a
límites insospechados. XML es la base de la nueva generación de aplicaciones
web intercambio de datos
9/119
Usos XML
Sitios web Permite separar contenido y presentación
Comunicación <-> intercambio datos Servicios web
Como configuración de programas Deployment descriptos en servidores J2EE Ant make system
10/119
Componentes documento XML
Los documentos XML constan de: Instrucciones de procesamiento (processing
instructions – PI) Declaraciones de tipo de documento Comentarios Elementos Referencias a entidades Secciones CDATA
11/119
Instrucciones de procesamiento
Las PI son instrucciones para el procesador del documento XML.
Siempre hay al menos una PI, que pertenece al prólogo del documento:<?xml version="1.0"?><saludo>
Hola, mundo!</saludo>
Algunos navegadores interpretan la siguiente instrucción de procesamiento para indicar que el documento debería ser procesado mediante una hoja de estilo Guitars.xsl antes de ser visualizado:<?xml-stylesheet type="text/xsl" href="Guitars.xsl"?>
12/119
Comentarios en XML
Los comentarios no se procesan. Tienen la siguiente sintaxis:
<!-- Esto es un comentario -->
13/119
Elementos y atributos en XML
Los elementos son los que aportan estructura semántica al documento.
Se delimitan por etiquetas de apertura, cierre y etiquetas sin elementos interiores (etiquetas vacías).
Las etiquetas de apertura y las vacías suelen venir acompañadas de atributos, que parametrizan el elemento.
El valor de los atributos siempre se encierra entre comillas, dobles o simples.
<saludo tipo="coloquial">Hola</saludo>
14/119
Elementos vs. Atributos
Demasiados atributos hacen que los documentos XML se puedan leer difícilmente.
No se puede indicar estructura de documento mediante atributos
<CUSTOMER LAST_NAME="Smith" FIRST_NAME="Sam" DATE="October 15, 2001" PURCHASE="Tomatoes" PRICE=“€1.25" NUMBER="8" />
15/119
Elementos vs. Atributos (cont)
<CUSTOMER> <NAME> <LAST_NAME>Smith</LAST_NAME> <FIRST_NAME>Sam</FIRST_NAME> </NAME> <DATE>October 15, 2001</DATE> <ORDERS> <ITEM> <PRODUCT>Tomatoes</PRODUCT> <NUMBER>8</NUMBER> <PRICE>$1.25</PRICE> </ITEM> </ORDERS> </CUSTOMER>
16/119
Referencias a entidades
Las referencias a entidades sirven para insertar un determinado contenido definido previamente.
<!ENTITY Empresa “Universidad de Deusto”><pie>Creado por &Empresa;</pie>
17/119
Códigos de escape
Existen 5 referencias a entidades predefinidas: & el carácter & < el carácter < > el carácter > ' el carácter ' " el caracter "
Se incluyen los caracteres del juego ISO 10646. ‘ ⼱
18/119
Secciones CDATA
Las secciones CDATA (character data) contienen texto que no debe ser procesado.
Se tratan como una secuencia de caracteres sin estructura.
<![CDATA[<saludo>Hola, mundo!</saludo>]]>
19/119
Gramáticas en XML
La gramática que restringe los elementos válidos dentro de un nuevo derivado de XML puede expresarse en forma de:DTD (Document Type Definitions) oEsquemas XML
20/119
Document Type Definitions (DTDs)
Especifican la estructura y sintaxis de un documento XML
Labgroups.dtd
<!ELEMENT lab_group (student_name)*><!ELEMENT student_name (#PCDATA)> <!ATTLIST student_name dni ID #REQUIRED tutor IDREF #IMPLIED>
21/119
Document Type Definitions (cont)
<?xml version="1.0"?><!DOCTYPE mensaje SYSTEM “labgroups.dtd">
<lab_group> <student_name dni=“44670523"> Josu Artaza </student_name> <student_name dni=“44543211"> Nuria Buruaga </student_name> <student_name dni=“23554521" tutor=“33456211"> Inga Dorsman </student_name> </lab_group>
22/119
XML Schemas
Los DTD no son muy potentes para definir gramáticas.
Otra forma de hacerlo es con Esquemas XML basados en el propio XML y que soporta más tipos de datos.
23/119
Ejemplo Schema
DTD :<!ELEMENT text (#PCDATA | emph | name)*> <!ATTLIST text timestamp NMTOKEN #REQUIRED>
XML Schema:<xsd:element name="text"> <xsd:complexType mixed="true"> <xsd:sequence> <xsd:element ref="emph"/> <xsd:element ref="name"/> </xsd:sequence> <xsd:attribute name="timestamp" type="xsd:date"
use="required"/> </xsd:complexType> </xsd:element>
24/119
Ejemplo Schema (cont)
XML Document:
<?xml version="1.0"?><text timestamp="08:45:00.000">The deadline of <name>Distributed.NET assigment</name> is <emph>December 22nd 2005</emph>.
</text>
25/119
What is an XML Schema?
Extraído de: http://www.w3schools.com/schema/default.asp
The purpose of an XML Schema is to define the legal building blocks of an XML document, just like a DTD.
An XML Schema: defines elements that can appear in a document defines attributes that can appear in a document defines which elements are child elements defines the order of child elements defines the number of child elements defines whether an element is empty or can include text defines data types for elements and attributes defines default and fixed values for elements and attributes
26/119
XML Schemas are the Successors of DTDs
We think that very soon XML Schemas will be used in most Web applications as a replacement for DTDs. Here are some reasons: XML Schemas are extensible to future additions XML Schemas are richer and more powerful than DTDs XML Schemas are written in XML XML Schemas support data types XML Schemas support namespaces
27/119
Ejemplo XML y DTD
Ejemplo XML:<?xml version="1.0"?><!DOCTYPE note SYSTEM "http://www.w3schools.com/dtd/note.dtd">
<note> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body></note>
Ejemplo DTD:<!ELEMENT note (to, from, heading, body)><!ELEMENT to (#PCDATA)><!ELEMENT from (#PCDATA)><!ELEMENT heading (#PCDATA)><!ELEMENT body (#PCDATA)>
28/119
Ejemplo XML y Schema Ejemplo XML:
<?xml version="1.0"?><note xmlns="http://www.w3schools.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.w3schools.com note.xsd">
<to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body></note>
Ejemplo DTD:<?xml version="1.0"?><xs:schema xmlns:xs=http://www.w3.org/2001/XMLSchema
targetNamespace=http://www.w3schools.com xmlns=http://www.w3schools.com elementFormDefault="qualified">
<xs:element name="note"> <xs:complexType> <xs:sequence>
<xs:element name="to" type="xs:string"/><xs:element name="from" type="xs:string"/><xs:element name="heading" type="xs:string"/><xs:element name="body" type="xs:string"/>
</xs:sequence> </xs:complexType></xs:element></xs:schema>
29/119
Elementos Simples
<xs:element name="xxx" type="yyy"/> donde xxx es el nombre del elemento e yyy el tipo, siendo
los más comunes: xs:string xs:decimal xs:integer xs:boolean xs:date xs:time
Ejemplos:<lastname>Refsnes</lastname> <age>36</age> <dateborn>1970-03-27</dateborn>
30/119
Atributos y Restricciones en Elementos
Ejemplo atributos:<lastname lang="EN">Smith</lastname><xs:attribute name="lang" type="xs:string"/>
Ejemplo restricciones sobre un elemento:<xs:element name="letter"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[a-z]"/> </xs:restriction> </xs:simpleType></xs:element>
31/119
XML bien formado y/o XML válido
Hay dos tipos de documentos XML:Bien formados: son aquellos que cumplen las
reglas sintácticas de XMLVálidos: son aquellos que, además de ser bien
formados, siguen las reglas de una gramática (definida en un DTD o XML Schema)
32/119
Reglas para que un documento esté bien formado
Para que un documento esté bien formado:Debe tener un prólogoDebe tener una etiqueta raízLas etiquetas se hallan correctamente
anidadasSe usan caracteres válidos y bien aplicadosLos valores de los atributos vienen encerrados
entre comillas ...
33/119
Reglas para que un documento sea válido
Para que un documento sea válido debe declarar el DTD o XML Schema contra el cual debe validarse.
Se hace mediante DOCTYPE, pudiendo ser los DTD públicos o de sistema.
<!DOCTYPE saludo SYSTEM “saludo.dtd”><!DOCTYPE saludo PUBLIC “-//Saludos//DTD Lenguaje de saludos//ES” “http://www.deusto.es/dtds/saludo.dtd”>
También se puede insertar el DTD entero en ese punto, en lugar de referenciar al fichero.
34/119
Proceso de validación documento XML
¿WellFormed?
DocumentoXML
DTDError: Documento
XML no válidoError: DocumentoXML mal formado
Procesamiento dela información
¿Valid?
¿DTD?
(opcional) si
no
si
si
no
no
35/119
XML Namespaces
El estándar XML también define los espacios de nombres (XML Namespaces).
Permiten que un mismo documento XML tenga etiquetas de diferentes lenguajes (definidas en diferentes gramáticas DTD).
Así es posible mezclar más información en los documentos, por ejemplo, añadir información semántica a un documento XHTML.
36/119
Ejemplo XML Namespaces
<?xml version="1.0"?><!DOCTYPE mensaje SYSTEM "mensaje.dtd">
<mensaje><remite>
<dir:direccion xmlns:dir=“http://www.deusto.es/direccion”>
<dir:calle>Avda. Universidades</dir:calle>
<dir:localidad cp=“40007”>Bilbao</dir:localidad>
</dir:direccion><nombre>Diego Ipiña</nombre><email>dipina@eside.deusto.es</email>
</remite><!-- Resto del mensaje XML... -->
</mensaje>
37/119
Lenguajes basados en XML
Chemical Markup Language (CML) Mathematical Markup Language (MathML) Channel Definition Format (CDF) Synchronized Multimedia Integration Language (SMIL) XHTML Scalable Vector Graphics (SVG) SOAP y WSDL VoiceML Wireless Markup Language (WML) RSS (Rich Site Summary)
38/119
Herramientas de XML
Editores http://www.xmlcooktop.com/ gratis XML Spy, www.xmlspy.com
XML parsers Lee un documento XML Verifica que XML está bien formado Verifican que XML es válido
expat, parser written in C by James Clark (www.jclark.com) Lark, written in Java (www.textuality.com/Lark/) Apache Jakarta Xerces (www.apache.org) .NET FCL System.Xml
XML Validators Verifican que XML es válido
XML.com's Validator based on Lark (xml.com)
39/119
¿Por qué usar XML?
Un documento XML puede ser fácilmente procesado y sus datos manipulados
Existen APIs para procesar esos documentos en Java, C, C#, C++, Perl.. (y por supuesto Python)
XML define datos portables al igual que Java define código portable
40/119
XML Parsing
DocumentoXML
XML DTDXML Schema
Parser XMLAplicación
XML
41/119
XML Parsing (cont)
SAX Define interfaz dirigido por eventos (event-driven) para el
procesamiento de un documento XML Definido por David Megginson y lista correo XML-DEV :
http://www.megginson.com/SAX
DOM Provee una representación de un documento XML en forma de un
árbol Carga todo el documento XML en memoria http://www.w3.org/DOM
42/119
XML en .NET
El espacio de nombres System.Xml ofrece una variedad de clases para leer y escribir documentos XML: La clase XmlDocument implementa DOM Para un procesamiento orientado al stream se puede
usar XmlTextReader o XmlValidatingReader XmlTextWriter simplifica el proceso de creación de
documentos XML.
43/119
System.XML
Este espacio de nombres comprende todas las clases necesarias para manejar documentos XML.
Permite leer o parsear un documento, así como escribir un documento XML.
Para ello necesitaremos conocer previamente la estructura de un documento XML.
44/119
System.XML
Este espacio de nombres provee soporte para los estándares de procesamiento XML: XML 1.0 - http://www.w3.org/TR/1998/REC-xml-19980210 -
including DTD support. XML Namespaces - http://www.w3.org/TR/REC-xml-names/ - both
stream level and DOM. XSD Schemas - http://www.w3.org/2001/XMLSchema XPath expressions - http://www.w3.org/TR/xpath XSLT transformations - http://www.w3.org/TR/xslt DOM Level 1 Core - http://www.w3.org/TR/REC-DOM-Level-1/ DOM Level 2 Core - http://www.w3.org/TR/DOM-Level-2/
45/119
Un poco de XML
Lenguaje mundial de facto para intercambio de datos
XML no tiene tanto éxito porque es un gran lenguaje, sino porque las herramientas disponibles para leer, escribir y manipular XML son muy comunes
Casi todos los parseadores de XML implementan una de dos APIs: DOM: lee un documento en memoria y lo carga en un
árbol SAX: API basada en eventos
46/119
Ejemplo DOM en .NET
<?xml version=“1.0”?><Guitars> <Guitar Image=“MySG.jpeg”> <Make>Gibson</Make> <Model>SG</Model> <Year>1977</Year> <Color>Tobacco Sunburst</Color> <Neck>Rosewood</Neck> </Guitar> <Guitar Image=“MyStrat.jpeg”> <Make>Fender</Make> <Model>Stratocaster</Model> <Year>1990</Year> <Color>Black</Color> <Neck>Maple</Neck> </Guitar></Guitars>
47/119
Ejemplo DOM en .NET
using System;using System.Xml;
class MyApp{ static void Main () { XmlDocument doc = new XmlDocument (); doc.Load ("Guitars.xml"); XmlNodeList nodes = doc.GetElementsByTagName
("Guitar"); foreach (XmlNode node in nodes) { Console.WriteLine ("{0} {1}",
node["Make"].InnerText, node["Model"].InnerText); } }}
48/119
XmlDocument
Interfaz programática para documentos XML que conforman con la especificación DOM
Método Load(nombre-doc) procesa el documento y construye un árbol del mismo
Una llamada exitosa es normalmente seguida de invocación a propiedad DocumentElement Para saber si tiene hijos usar propiedad HasChildNodes
Propiedad ChildNodes devuelve los hijos de un nodo Todo hijo es un XMLNode que puede ser del tipo Element, Text, Attribute, etc.
49/119
XmlTextReader
Frente al estándar SAX, .NET ofrece XmlTextReader
Está basado en streams como SAX y es por tanto más eficiente con el uso de memoria que DOM
Usa un mecanismo pull para examinar XML en vez de push como SAX
50/119
Ejemplo XmlTextReader I
Lee un fichero XML y visualiza todos sus nodos
<?xml version="1.0"?><!-- This is a sample XML document --><!DOCTYPE Items [<!ENTITY number "123">]><Items> <Item>Test with an entity: &number;</Item> <Item>test with a child element <more/>
stuff</Item> <Item>test with a CDATA section <![CDATA[<456>]]>
def</Item> <Item>Test with an char entity: A</Item> <!-- Fourteen chars in this element.--> <Item>1234567890ABCD</Item></Items>
51/119
Ejemplo XmlTextReader II
public class Sample { private const String filename = "items.xml"; public static void Main() { XmlTextReader reader = null; try { // Cargar reader con fichero XML ignorando espacios.
reader = new XmlTextReader(filename); reader.WhitespaceHandling = WhitespaceHandling.None; // Procesar fichero y visualizar cada nodo while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: Console.Write("<{0}>", reader.Name); break; case XmlNodeType.Text: Console.Write(reader.Value); break; case XmlNodeType.CDATA: Console.Write("<![CDATA[{0}]]>", reader.Value); break;
52/119
Ejemplo XmlTextReader III
case XmlNodeType.ProcessingInstruction: Console.Write("<?{0} {1}?>", reader.Name,
reader.Value); break; case XmlNodeType.Comment: Console.Write("<!--{0}-->", reader.Value); break; case XmlNodeType.XmlDeclaration: Console.Write("<?xml version='1.0'?>"); break; case XmlNodeType.Document: break; case XmlNodeType.DocumentType: Console.Write("<!DOCTYPE {0} [{1}]",
reader.Name, reader.Value); break;
53/119
Ejemplo XmlTextReader IV
case XmlNodeType.EntityReference: Console.Write(reader.Name); break; case XmlNodeType.EndElement: Console.Write("</{0}>", reader.Name); break; } } } finally { if (reader!=null) reader.Close(); } }} // Final clase
54/119
Transformaciones XSLT
XSLT (Extensible Stylesheet Language Transformations) es un lenguaje para convertir documentos XML de un formato en otro
Tiene dos usos principales: Convertir documentos XML en HTML Convertir documentos XML en otros documentos XML
Este tipo de conversiones son el núcleo de aplicaciones middleware como Microsoft BizTalk Server.
55/119
Ejemplo transformación XSLT
using System;using System.Xml;using System.Xml.XPath;using System.Xml.Xsl;class MyApp { static void Main (string[] args) {
if (args.Length < 2) { Console.WriteLine ("Syntax: TRANSFORM xmldoc
xsldoc"); return; } try { XslCompiledTransform xsl = new
XslCompiledTransform (); xsl.Load (args[1]);
56/119
Ejemplo transformación XSLT
//Crear un nuevo XPathDocument y cargar el fichero XML a transformar
XPathDocument doc = new XPathDocument (args[0]);
//Crear un XmlTextWriter que escribe a consola.
XmlWriter writer = new XmlTextWriter(Console.Out);
xsl.Transform (doc, null, writer, null); } catch (Exception ex) { Console.WriteLine (ex.Message); }
}}
57/119
W3C Document Object Model (DOM)
Documentos XML son tratados como un árbol de nodos
Cada elemento es un “nodo” Los elementos hijos y el texto contenido dentro
de un elemento son subnodos W3C DOM Site: http://www.w3.org/DOM/ DOM Java Language Binding:
http://www.w3.org/TR/DOM-Level-2-Core/java-binding.html
58/119
Características DOM
Documento que se carga totalmente en memoria en una estructura de árbol
Ventaja: fácil acceder a datos en función de la jerarquía de elementos, así como modificar el contenido de los documentos e incluso crearlos desde cero.
Desventaja: coste en tiempo y memoria que conlleva construir el árbol
59/119
W3C XML DOM Objects
Element – un elemento XML Attribute – un attributo Text – texto contenido en un elemento o atributo CDATAsection – sección CDATA EntityReference – Referencia a una entidad Entity – Indicación de una entidad XML ProcessingInstruction – Una instrucción de
procesamiento Comment – Contenido de un comentario de XML Document – El objeto documento DocumentType – Referencia al elemento DOCTYPE DocumentFragment – Referencia a fragmento de
documento Notation – Contenedor de una anotación
60/119
DOM
<?xml version="1.0"?><Guitars> <Guitar Image="MySG.jpeg"> <Make>Gibson</Make> <Model>SG</Model> <Year>1977</Year> <Color>Tobacco Sunburst</Color> <Neck>Rosewood</Neck> </Guitar></Guitars>
61/119
Árbol DOM
62/119
XMLDocument I
La clase XMLDocument es compatible con la especificación DOM Level 2 Core Representa a un documento como un árbol de nodos que tiene por raíz el
elemento raíz del documento XML. Cada nodo es una instancia de XmlNode, que expone métodos y propiedades
para navegar árboles DOM, leer y escribir contenido de nodos, añadir y borrar nodos, etc.
Un ejemplo sencillo de su uso sería:XmlDocument doc = new XmlDocument ();doc.Load ("Guitars.xml");
El atributo DocumentElement devuelve un XmlNode que hace referencia a la raíz del documento, que es el punto de comienzo al navegar de arriba a abajo el árbol DOM
La combinación de los atributos HasChildNodes y ChildNodes hace posible un enfoque recursivo para iterar sobre los nodos de un árbol
La invocación a ChildNodes no devuelve atributos XML, sin embargo, su propiedad Attributes lo hace.
Las propiedades NodeType, Name, y Value de un XmlNode exponen su tipo, nombre, y valor del correspondiente nodo En atributos usa la propiedad LocalName para devolver nombres sin prefijos.
63/119
XMLDocument II
Para acceder a nodos particulares puedes hacer uso de las propiedades de un XmlDocument GetElementsByTagName, SelectNodes, y SelectSingleNode
XmlDocument puede también utilizarse para escribir documentos XML
La clase XmlDataDocument ofrece un mecanismo para tratar datos relacionales como datos XML. Puedes crear un XmlDataDocument alrededor de un DataSet del siguiente modo:DataSet ds = new DataSet ();// TODO: Initialize the DataSet with a database query
XmlDataDocument doc = new XmlDataDocument (ds);
64/119
Ejemplo XmlDocument I
using System;using System.Xml;class MyApp{ static void Main () { XmlDocument doc = new XmlDocument (); doc.Load ("Guitars.xml"); XmlNodeList nodes = doc.GetElementsByTagName ("Guitar"); foreach (XmlNode node in nodes) { Console.WriteLine ("{0} {1}",
node["Make"].InnerText, node["Model"].InnerText); }
// Visualiza el contenido de todo el árbolOutputNode (doc.DocumentElement);
}
65/119
Ejemplo XmlDocument II
public static void OutputNode (XmlNode node){
Console.WriteLine ("Type={0}\tName={1}\tValue={2}",node.NodeType, node.Name, node.Value);
if (node.Attributes != null) {
foreach (XmlAttribute attr in node.Attributes)Console.WriteLine("Type={0}\tName={1}\
tValue={2}",attr.NodeType, attr.Name,
attr.Value);}
if (node.HasChildNodes) {
XmlNodeList children = node.ChildNodes;foreach (XmlNode child in children)
OutputNode (child);}
}}
66/119
XmlTextReader
La clase System.Xml.XmlTextReader ofrece una interfaz rápida, hacia adelante, de sólo lectura de documentos XML.
XmlValidatingReader permite efectuar una validación de un documento XML Es orientada al stream como SAX Es más eficiente en consumo de memoria que XmlDocument,
XmlTextReader reader = null;...reader = new XmlTextReader ("Guitars.xml");reader.WhitespaceHandling = WhitespaceHandling.None;while (reader.Read ()) { Console.WriteLine ("Type={0}\tName={1}\tValue={2}", reader.NodeType,
reader.Name, reader.Value); if (reader.AttributeCount > 0) { while (reader.MoveToNextAttribute())
{ Console.WriteLine ("Type={0}\tName={1}\tValue={2}",
reader.NodeType, reader.Name, reader.Value); } }
}}
67/119
XmlTextWriter
La clase XmlTextWriter se puede utilizar para generar documentos Xml desde cero.
XmlTextWriter writer = null;...writer = new XmlTextWriter ("Guitars.xml",
System.Text.Encoding.Unicode);writer.Formatting = Formatting.Indented;
writer.WriteStartDocument ();writer.WriteStartElement ("Guitars");writer.WriteStartElement ("Guitar");writer.WriteAttributeString ("Image", "MySG.jpeg");writer.WriteElementString ("Make", "Gibson");writer.WriteElementString ("Model", "SG");writer.WriteElementString ("Year", "1977");writer.WriteElementString ("Color", "Tobacco Sunburst");writer.WriteElementString ("Neck", "Rosewood");writer.WriteEndElement ();writer.WriteEndElement ();
68/119
XPath
XPath o XML Path Language, es un lenguaje para acceder a partes de un documento XML
XPath puede ser considerado con el equivalente XML de SQL El espacio de nombres System.Xml.XPath define un conjunto de clases que
permiten su uso Algunos ejemplos de location path son:
Todos los elementos Guitar que son hijos de Guitars: /Guitars/Guitar Todos los atributos (no elementos) de nombre Image que pertenecen a elementos
Guitar: /Guitars/Guitar/@Image Todos los elementos Guitar en el documento: //Guitar Todos los elementos hijo de Guitars: /Guitars/* Todos los atributos que pertenecen a elementos Guitar en el documento:
//Guitar/@* Elementos Guitar que tienen atributo Image: //Guitar[@Image] Todos los elementos Guitar que tienen atributo Image con valor
“MyStrat.jpeg”: //Guitar[@Image = "MyStrat.jpeg"] Guitarras manufacturadas después de 1980 por Fender: //Guitar[Year > 1980]
[Make = "Fender"] o //Guitar[Year > 1980 and Make = "Fender"]
69/119
System.Xml.XPath
Las clases principales de este espacio de nombres son: XPathDocument, representa documentos XML que quieren ser
consultados mediante XPath XPathNavigator, provee un mecanismo para ejecutar consultas XPath; XPathNodeIterator, que representa conjuntos de nodos generados por
consultas XPath y permite iterar sobre ellos XPathNavigator provee 5 métodos para ejecutar consultas XPath.
Los más importantes son: Evaluate ejecuta cualquier expresión XPath, devolviendo un Object que puede
ser un string, un float, un boolean o un XPathNodeIterator Select trabaja exclusivamente con expresiones que devuelven conjuntos de
nodos y es un vehículo ideal para evaluar location paths. Siempre devuelve un XPathNodeIterator
XPathNodeIterator es una clase simple que puedes utilizar para iterar por los elementos devueltos en un node set. La propiedad Count devuelve cuántos nodos han sido devueltos: Console.WriteLine ("Select returned {0} nodes",
iterator.Count); El método MoveNext te permite iterar por el conjunto de nodos. Mientras
iteras, la propiedad Current expone un objeto XPathNavigator que representa el nodo actual.
70/119
Ejemplo XPath
using System;using System.Xml.XPath;class MyApp{
static void Main (){
XPathDocument doc = new XPathDocument ("Guitars.xml");XPathNavigator nav = doc.CreateNavigator ();XPathNodeIterator iterator = nav.Select ("/Guitars/Guitar");
while (iterator.MoveNext ()) {
XPathNodeIterator it = iterator.Current.Select ("Make");
it.MoveNext ();string make = it.Current.Value;
it = iterator.Current.Select ("Model");it.MoveNext ();string model = it.Current.Value;
Console.WriteLine ("{0} {1}", make, model);}
}}
71/119
Extensible Style Language Transformations (XSLT) I
Con la diversidad de lenguajes de presentación que hay (WML, HTML, cHTML) existen dos alternativas para desarrollar las aplicaciones: Desarrollar versiones de los procesos de generación
de presentación (JSP, ASP, CGI,..) para cada lenguaje.
Desarrollar solo una versión que genere XML y conversores de XML a los lenguajes de presentación.
72/119
Extensible Style Language Transformations (XSLT) II
Dos partes: Transformation Language (XSLT) Formatting Language (XSL Formatting Objects)
XSLT transforma un documento XML en otro documento XML
XSLFO formatea y estiliza documentos en varios modos XSLT W3C Recommendation - http://www.w3.org/TR/xslt
73/119
Operaciones entre árboles en XSL
74/119
Ventajas y desventajas de XSLT
Ventajas: No asume un único formato de salida de documentos Permite manipular de muy diversas maneras un documento XML:
reordenar elementos, filtrar, añadir, borrar, etc. Permite acceder a todo el documento XML XSLT es un lenguaje XML
Desventajas: Su utilización es más compleja que un lenguaje de programación
convencional Consume cierta memoria y capacidad de proceso DOM detrás
75/119
Usando hojas de estilo XSLT
Para crear una transformación XSL necesitamos: El documento XML a transformar (students.xml) La hoja de estilo que especifica la transformación
(students.xsl)
76/119
Documento XML (students.xml)
<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href=“students.xsl"?><course> <name id="csci_2962">Programming XML in Java</name> <teacher id=“di">Diego Ipiña</teacher> <student id=“ua"> <name>Usue Artaza</name> <hw1>30</hw1> <hw2>70</hw2> <project>80</project> <final>85</final> </student> <student id=“iu"> <name>Iñigo Urrutia</name> <hw1>80</hw1> <hw2>90</hw2> <project>100</project> <final>40</final> </student> </course>
77/119
Hoja de estilo XSLT (students.xsl)
<?xml version="1.0"?> <xsl:stylesheet version="1.0“
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="course"> <HTML> <HEAD><TITLE>Name of students</TITLE></HEAD> <BODY> <xsl:apply-templates select="student"/> </BODY> </HTML> </xsl:template> <xsl:template match="student"> <P><xsl:value-of select="name"/></P> </xsl:template> </xsl:stylesheet>
78/119
Resultado de transformación
(students.html)
<HTML> <HEAD> <TITLE>Name of students</TITLE> </HEAD>
<BODY> <P>Usue Artaza</P> <P>Iñigo Urrutia</P> </BODY> </HTML>
79/119
Formas de uso de XSLT
Visualizar directamente en un navegador el documento XML que tiene asociada una hoja XSLT.
Ejecutar el procesador XSLT independientemente del navegador. Se le pasan las entradas necesarias (fichero origen y hoja XSLT a utilizar) y genera la salida en un fichero, con el que podemos hacer lo que queramos.
Realizar las transformaciones dentro de un programa en el servidor y enviar a los clientes sólo el resultado de la transformación.
80/119
Aplicaciones usando XSLT
Internet
JSP
Clases Java
Base de Datos
Cliente Servidor
XML
Arquitectura en 5 capas dónde el servidor contiene conversores XSLT para generar presentación en distintos formatos.
XSLT
81/119
XSLT son documentos XML bien formados
xsl:stylesheet – elemento raíz xsl:template – cómo transformar un nodo
seleccionado Se asocia con un fragmento del documento a través de una
expresión en XPath Transforma XML entrante en otro fragmento de XML match – Atributo para seleccionar nodo
"/" – nodo raiz del documento de entrada
Elemento xsl:apply-templates. Aplica los templates definidos para los hijos de un nodo seleccionado
82/119
Ejemplo XSLT
<?xml version="1.0"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/"> <xsl:apply-templates/> </xsl:template> </xsl:stylesheet>
83/119
Elementos XSLT
xsl:value-of permite recuperar el valor de un nodo Los nodos son seleccionados usando la sintaxis de la
especificación XPath XML Sólo selecciona el valor del primer estudiante que
encuentre<xsl:template match=“course"> <xsl:value-of select=“student"/>
</xsl:template>
84/119
Elementos XSLT
Si queremos seleccionar varios podemos hacer:<xsl:template match=“course"> <xsl:apply-templates select=“student"/>
</xsl:template> <xsl:template match=“student"> <xsl:value-of select="."/>
</xsl:template>
O usar xsl:for-each<xsl:template match=“course"> <xsl:for-each select=“student">
<xsl:value-of select="."/> </xsl:for-each>
</xsl:template>
85/119
Elementos XSLT (cont)
Para realizar distintos procesamientos en función de los datos se usa xsl:choose: Se compone de elementos xsl:when Un elemento opcional xsl:otherwise
Para procesar o no un elemento en función de una condición se usa xsl:if: Condición en atributo test
86/119
Ejemplo
<?xml version="1.0"?> <xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="/"> <HTML> <HEAD> <TITLE>Name of students</TITLE> </HEAD> <BODY> <xsl:apply-templates/> </BODY> </HTML> </xsl:template> <xsl:template match="course"> <xsl:apply-templates select="student"/> </xsl:template> <xsl:template match="student"> <xsl:for-each select="name"><P><xsl:value-of
select="."/></P></xsl:for-each> </xsl:template> </xsl:stylesheet>
87/119
Patrones XPath para el atributo match o select
Seleccionar el nodo raiz: <xsl:template match="/"> ... </xsl:template> Seleccionar un elemento: <xsl:template match="student"> ...</xsl:template>
Seleccionar hijos de un elemento: <xsl:template match="course/student"> ... </xsl:template>
<xsl:template match="course/*/name"> ... </xsl:template>
Seleccionar descendientes de un elemento:<xsl:template match="course//name"> ... </xsl:template>
88/119
Patrones XPath para el atributo match o select
Seleccionar atributo título:<xsl:value-of select="./@id"/>
Seleccionar comentarios:<xsl:template match="comment()"> ... </xsl:template>
Seleccionar elementos de texto:<xsl:template match="text()"> ... </xsl:template>
Recuperar posición que ocupa un sub-elemento dentro de elemento padre<xsl:value-of select="position()"/>
89/119
Evaluando condiciones con []
Evaluando si una condición es cierta: Si el elemento estudiante tiene un hijo name
<xsl:template match="student[name]"> Cualquier elemento que tiene un elemento name
<xsl:template match="*[name]"> Elemento student tiene un sub-elemento hw1 o hw2 element
<xsl:template match="student[hw1 | hw2]">
90/119
Ejemplo XSLT
Problema: Imprimir nombre de alumnos con nota media mayor de 65%
<?xml version="1.0"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:output method="text"/> <xsl:template match="course"> <xsl:apply-templates select="student"/> </xsl:template> <xsl:template match="student"> <xsl:variable name="ave"> <xsl:value-of select="(hw1 + hw2 + project + final) div
4"/> </xsl:variable> <xsl:if test="$ave > 65">
Student name="<xsl:value-of select="name"/>" average="<xsl:value-of select="$ave"/>"
</xsl:if> </xsl:template> </xsl:stylesheet>
91/119
Resultado transformación
Salida (grades70.txt):
Student name=“Usue Artaza" average="66,25"
Student name=“Iñigo Urrutia" average="77,5"
92/119
XSLT en .NET
XSLT (Extensible Stylesheet Language Transformations ) es la herramienta de tratamiento estrella de XML.
XSLT es un lenguaje de programación para convertir documentos XML de un formato a otro.
XSLT tiene dos usos principales: Convertir documentos XML en HTML: útil para construir páginas
web y otros documentos XML dirigidos a browsers Convertir documentos XML en otros documentos XML
Las conversiones XSLT XML-a-XML son el núcleo de aplicaciones middleware como Microsoft BizTalk Server que automatizan los procesos de negocio orquestrando el flujo de información
La clase System.Xml.Xsl.XslCompiledTransform nos permite efectuar transformaciones XSLT.
93/119
XSLT
La figura ilustra el funcionamiento de XSLT. Se necesita: Un documento fuente XML
a transformar Un documento XSL que
describe cómo el procesador XSLT debe transformar el documento
94/119
Aplicando XSL en el Cliente I
<!– guitars.xml --><?xml version="1.0"?><?xml-stylesheet type="text/xsl" href="Guitars.xsl"?><Guitars> <Guitar> <Make>Gibson</Make> <Model>SG</Model> <Year>1977</Year> <Color>Tobacco Sunburst</Color> <Neck>Rosewood</Neck> </Guitar> <Guitar> <Make>Fender</Make> <Model>Stratocaster</Model> <Year>1990</Year> <Color>Black</Color> <Neck>Maple</Neck> </Guitar></Guitars>
95/119
Aplicando XSL en el Cliente II
// guitars.xsl<?xml version="1.0"?><xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:template match="/"> <html> <body> <h1>My Guitars</h1> <hr /> <table width="100%" border="1"> <tr bgcolor="gainsboro"> <td><b>Make</b></td> <td><b>Model</b></td> <td><b>Year</b></td> <td><b>Color</b></td> <td><b>Neck</b></td> </tr>
96/119
Aplicando XSL en el Cliente II
<xsl:for-each select="Guitars/Guitar"> <tr> <td><xsl:value-of select="Make" /></td> <td><xsl:value-of select="Model" /></td> <td><xsl:value-of select="Year" /></td> <td><xsl:value-of select="Color" /></td> <td><xsl:value-of select="Neck" /></td> </tr> </xsl:for-each> </table> </body> </html> </xsl:template></xsl:stylesheet>
97/119
Aplicando XSL en el Cliente III
98/119
Aplicando XSL en el Servidor I
<!-- quotes.xml --><?xml version="1.0"?><Quotes> <Quote> <Text>Give me chastity and continence, but not yet.</Text> <Author>Saint Augustine</Author> </Quote> <Quote> <Text>The use of COBOL cripples the mind; its teaching should therefore be regarded as a criminal offense.</Text> <Author>Edsger Dijkstra</Author> </Quote> <Quote> <Text>C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do, it blows away your whole leg.</Text> <Author>Bjarne Stroustrup</Author> </Quote> <Quote> <Text>A programmer is a device for turning coffee into code.</Text> <Author>Jeff Prosise (with an assist from Paul Erdos)</Author> </Quote> ...</Quotes>
99/119
Aplicando XSL en el Servidor II
<?xml version="1.0"?> <!-- quotes.xsl --><xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:template match="/"> <html> <body> <h1 style="background-color: teal; color: white; font-size: 24pt; text-align: center; letter-spacing: 1.0em"> Famous Quotes </h1> <table border="1"> <tr style="font-size: 12pt; font-family: verdana; font-weight: bold"> <td style="text-align: center">Quote</td> <td style="text-align: center">Author</td> </tr> <xsl:for-each select="Quotes/Quote"> <xsl:sort select="Author" /> <tr style="font-size: 10pt; font-family: verdana"> <td><xsl:value-of select="Text"/></td> <td><i><xsl:value-of select="Author"/></i></td> </tr> </xsl:for-each> </table> </body> </html> </xsl:template></xsl:stylesheet>
100/119
Aplicando XSL en el Servidor III
<!-- quotes.aspx --><%@ Page Language="C#" %><%@ Import Namespace="System.Xml.XPath" %><%@ Import Namespace="System.Xml.Xsl" %>
<% XPathDocument doc = new XPathDocument (Server.MapPath ("Quotes.xml")); XslTransform xsl = new XslTransform (); xsl.Load (Server.MapPath ("Quotes.xsl")); xsl.Transform (doc, null, Response.OutputStream);%>
101/119
Aplicando XSL en el Servidor IV
102/119
Transform.cs
using System;using System.Xml.XPath;using System.Xml.Xsl;class MyApp{ static void Main (string[] args) { if (args.Length < 2) { Console.WriteLine ("Syntax: TRANSFORM xmldoc xsldoc"); return; }
try { XPathDocument doc = new XPathDocument (args[0]); XslTransform xsl = new XslTransform (); xsl.Load (args[1]); xsl.Transform (doc, null, Console.Out); } catch (Exception ex) { Console.WriteLine (ex.Message); } }}
103/119
XSLT Object Extensions
La clase System.Xml.Xsl.XslCompiledTransform provee dos mecanismos para crear extensiones de usuario: Las páginas XSLT pueden contener funciones escritas en C#,
VB.NET o JavaScript dentro de elementos msxml:script Pueden invocarse desde dentro de la hoja de estilo
Usar objetos de extensión XSLT Objetos cuyos métodos públicos son accesibles desde la hoja de
estilo una vez añadidos al objeto XslTransform mediante el método AddExtensionObject
Ventajas objetos de extensión XSLT: Desacoplan las extensiones de una página concreta Pueden reutilizarse tales extensiones
104/119
XSL Scripts
Solamente funciona para IE Documentación en:
http://msdn2.microsoft.com/en-us/library/ms256042(VS.80).aspx
Elemento a utilizar msxsl:script Ejemplo XML:
<?xml version="1.0" ?> <?xml-stylesheet type="text/xsl" href="XslScriptExample.xsl"?>
<prueba/>
105/119
XSL Scripts
Ejemplo XSL:<?xml version="1.0"?><xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" xmlns:user="http://mycompany.com/mynamespace" version="1.0"> <xsl:template match="/">
<xsl:value-of select="user:xml(.)"/><xsl:value-of select="user:clock()"/>
</xsl:template>
<msxsl:script language="JavaScript" implements-prefix="user"><![CDATA[function xml(nodelist) { return nodelist.nextNode().xml;}]]>
</msxsl:script>
106/119
XSL Scripts
<msxsl:script language="JavaScript" implements-prefix="user"> <![CDATA[ function clock() { var time = new Date(); var hours = time.getHours(); var min = time.getMinutes(); var sec = time.getSeconds(); var status = "AM"; if (hours > 11) { status = "PM"; } if (hours < 11) { hours -= 12; } if (min < 10) { min = "0" + min; } if (sec < 10) { sec = "0" + sec; } return hours + ":" + min + ":" + sec + " " + status; } ]]></msxsl:script>
</xsl:stylesheet>
107/119
Transformación con JavaScript
<html> <body> <script type="text/javascript">// Load XML var xml = new ActiveXObject("Microsoft.XMLDOM") xml.async = false xml.load("cdcatalog.xml")// Load XSL var xsl = new ActiveXObject("Microsoft.XMLDOM") xsl.async = false xsl.load("cdcatalog.xsl")// Transform document.write(xml.transformNode(xsl)) </script> </body></html>
108/119
XSLT Object Extensions
Microsoft recomienda evitar el uso de scripts in-line en hojas XSLT Para implementar funcionalidad extra es mejor utilizar
códigos de bloque externos Revisar ejemplo en las siguientes transparencias
109/119
Ejemplo Extensions Object// Compile: csc /target:library Products.csusing System;using System.Data.SqlClient;namespace InventoryExtensionObject{ public class Products { SqlConnection cn; public Products()
{ cn = new SqlConnection(@"server=localhost\
SQLEXPRESS;database=northwind;uid=sa;pwd=distributed.net"); cn.Open(); }
public int GetCurrentStockLevel(int ProductId) { SqlCommand cmd = new SqlCommand("Select UnitsInStock from Products where" + "
ProductID = " + ProductId, cn); int UnitsInStock = Convert.ToInt32(cmd.ExecuteScalar());
return UnitsInStock; }
public void Dispose() {
cn.Close(); } }}
110/119
Products.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<Products><Product id="1" name=“chorizo"/><Product id="2" name=“jamón"/><Product id="3" name=“salami"/>
</Products>
111/119
Products.xsl
<?xml version='1.0' encoding="ISO-8859-1" ?><!-- Notice how a namespace URI and prefix are declared to reference EO --> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:InventoryExtensionObj="urn:InventoryExtensionObj"><xsl:template match="Products"> <HTML> <BODY> <H3>Ipiña Altzariak</H3><BR/> <TABLE BORDER="1"> <TR> <TH>Product Id</TH>
<TH>Product Name</TH> <TH>Units In Stock</TH>
</TR> <xsl:for-each select="Product"> <TR> <TD><xsl:value-of select="@id"/></TD> <TD><xsl:value-of select="@name"/></TD> <!-- call extension object method to retrieve stock information --> <TD><xsl:value-of
select="InventoryExtensionObj:GetCurrentStockLevel(@id)"/></TD> </TR> </xsl:for-each> </TABLE> </BODY> </HTML></xsl:template> </xsl:stylesheet>
112/119
Ejemplo Aplicación usando EO
// Compile: csc /r:Products.dll ProductsStockLevel.csusing System;using System.Text;using System.Xml;using System.Xml.XPath;using System.Xml.Xsl;
namespace InventoryExtensionObject{ public class ProductsStockLevel { public static void Main(string [] args) { try { XPathDocument xmlDoc = new XPathDocument("products.xml");
// Instantiate a new XslTransform object and load the style sheet. XslCompiledTransform xslt = new XslCompiledTransform(); xslt.Load("products.xsl"); // Instantiate an XsltArgumentList object. // An XsltArgumentList object is used to supply extension object instances
// and values for XSLT paarmeters required for an XSLT. transformation XsltArgumentList xsltArgList = new XsltArgumentList();
//Instantiate and Add an instance of extension object to XsltArgumentList. InventoryExtensionObject.Products InventoryExtensionObj =
new InventoryExtensionObject.Products(); xsltArgList.AddExtensionObject("urn:InventoryExtensionObj", InventoryExtensionObj);
113/119
Ejemplo Aplicación usando EO
// Execute the transformation and generate the output to results.html XmlWriterSettings settings = new XmlWriterSettings(); settings.Encoding = Encoding.GetEncoding("iso-8859-1"); XmlWriter xmlWriter = XmlWriter.Create("results.html", settings); xslt.Transform(xmlDoc, xsltArgList, xmlWriter); InventoryExtensionObj.Dispose(); InventoryExtensionObj = null; } // Exception handling code. catch(XsltCompileException xsltCompileExp) { Console.WriteLine(xsltCompileExp.Message); } catch(XsltException xsltExp) { Console.WriteLine(xsltExp.Message); } catch(XPathException XPathExp) { Console.WriteLine(XPathExp.Message); } catch(XmlException XmlExp) { Console.WriteLine(XmlExp.Message); } } }}
114/119
EXSLT
Iniciativa para proporcionar extensiones a XSLT http://www.exslt.org/
Objetivo: extender su uso entre los implementadores de motores XSLT para incrementar la portabilidad de hojas XSLT
Define los siguientes módulos: Common EXSLT: exsl:node-set, exsl:object-type Math EXSLT: math:min, math:max, math:highest, math:abs, math:random
Sets EXSLT: set:difference, set:intersection, set:distinct
Dates and Times EXSLT: date:date-time, date:time, date:month-name, date:seconds
Strings EXSLT: str:tokenize, str:replace Regular Expressions EXSLT: regexp:test, regexp:match, regexp:replace
115/119
XSLT Object Extensions
Es una implementación de las extensiones EXSLT para XSLT 1.0 para la framework .NET: Web: http://mvp-xml.sourceforge.net/exslt/ Download: http://sourceforge.net/project/showfiles.php?
group_id=102352 Ejemplos interesantes: http://msdn2.microsoft.com/en-
us/library/ms950776.aspx EXSLT: iniciativa para crear extensiones para XSLT
116/119
XSLT Object Extensions
//Create the XslTransform and load the stylesheet.XslTransform xslt = new XslTransform();xslt.Load("test.xsl");//Load the XML data file.XPathDocument doc = new XPathDocument("test.xml");//Create an XsltArgumentList and add the EXSLT object
for the math functionsXsltArgumentList xslArg = new XsltArgumentList();xslArg.AddExtensionObject("http://exslt.org/math", new
ExsltMath());//Create an XmlTextWriter to output to the console.XmlTextWriter writer = new XmlTextWriter(Console.Out);//Transform the file.xslt.Transform(doc, xslArg, writer, null);writer.Close();
117/119
Conclusión
Las clases en el espacio de nombres System.Xml simplifican la lectura, escritura y manipulación de documentos XML
Miembros destacados de System.Xml son: XmlDocument, que provee una interfaz DOM a documentos XML XmlTextReader y XmlValidatingReader, que combina la
eficiencia de SAX con un modelo sencillo PULL para leer XML y validarlo opcionalmente
XmlTextWriter, que escribe documentos Xml XPathDocument, XPathNavigator, y XPathNodeIterator,
que permiten la realización de consultas XPath en documentos Xml e iterar sobre los resultados
XslCompiledTransform, que efectúa transformaciones XSL en datos XML.
XML es una realidad del desarrollo software actual La FCL de .NET nos simplifica este proceso
118/119
Referencias
XML DOM Tutorial http://www.w3schools.com/dom/default.asp
XSLT Tutorial http://www.w3schools.com/xsl/default.asp
HOW TO: Use Extension Objects When You Execute XSL Transformations in Visual C# .NET Applications http://support.microsoft.com/kb/323370
EXSLT: Enhancing the Power of XSLT http://msdn2.microsoft.com/en-us/library/ms950776.aspx
Ejemplos interesantes de uso de EXSLT: http://msdn2.microsoft.com/en-us/library/ms950776.aspx
Nuevas características .NET XML 2.0: http://www.15seconds.com/issue/050601.htm
XML, Distribución y Componentes
Tema 1 – Procesamiento XML en .NET –Preguntas y Sugerencias
Dr. Diego Lz. de Ipiña Gz. de Artazahttp://paginaspersonales.deusto.es/dipina (Personal)
http://www.morelab.deusto.es (Research Group)http://www.smartlab.deusto.es (Research Lab)
http://www.ctme.deusto.es (Cátedra de Telefónica Móviles)http://www.tecnologico.deusto.es (Tecnológico-Fundación Deusto)
top related