MoreLab - Mobility Research Lab

Download Report

Transcript MoreLab - Mobility Research Lab 

XML, Distribución y
Componentes
Tema 1 – Procesamiento XML en .NET
http://paginaspersonales.deusto.es/dipina/MasterISW/
Dr. Diego Lz. de Ipiña Gz. de Artaza
http://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)
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)
2/119
Contenidos Parte XML

XML
 DTD
 Schema

XML Parsing
 SAX API
 DOM API

XSLT
 XSLT
Scripts
 XSLT Object Extensions
3/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 Specification
http://www.w3.org/TR/REC-xml
4/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
5/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>
6/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>
7/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
8/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
9/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
10/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"?>
11/119
Comentarios en XML


Los comentarios no se procesan.
Tienen la siguiente sintaxis:
<!-- Esto es un comentario -->
12/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>
13/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" />
14/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>
15/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>
16/119
Códigos de escape

Existen 5 referencias a entidades predefinidas:
 &amp;
el carácter &
 &lt; el carácter <
 &gt; el carácter >
 &apos; el carácter '
 &quot; el caracter "

Se incluyen los caracteres del juego ISO 10646.
 &#145;
 &#x2F31;
17/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>]]>
18/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) o
 Esquemas XML
19/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>
20/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>
21/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.
22/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>
23/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>
24/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
25/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
26/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
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
note (to, from, heading, body)>
to (#PCDATA)>
from (#PCDATA)>
heading (#PCDATA)>
body (#PCDATA)>
27/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>
28/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>
29/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>
30/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 XML
 Válidos: son aquellos que, además de ser bien
formados, siguen las reglas de una gramática (definida
en un DTD o XML Schema)
31/119
Reglas para que un documento
esté bien formado

Para que un documento esté bien formado:
 Debe
tener un prólogo
 Debe tener una etiqueta raíz
 Las etiquetas se hallan correctamente
anidadas
 Se usan caracteres válidos y bien aplicados
 Los valores de los atributos vienen encerrados
entre comillas
 ...
32/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.
33/119
Proceso de validación documento
XML
Documento
XML
(opcional)
¿Well
Formed?
no
si
¿DTD?
no
Procesamiento de
la información
si
si
DTD
Error: Documento
XML mal formado
¿Valid?
no
Error: Documento
XML no válido
34/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.
35/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>[email protected]</email>
</remite>
<!-- Resto del mensaje XML... -->
</mensaje>
36/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)
37/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)
38/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
39/119
XML Parsing
Documento
XML
Parser XML
Aplicación
XML
XML DTD
XML Schema
40/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
41/119
XML en .NET

El espacio de nombres System.Xml ofrece una
variedad de clases para leer y escribir
documentos XML:
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.
 La
42/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.
43/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/
44/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
45/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>
46/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);
}
}
}
47/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.
48/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
49/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: &#65;</Item>
<!-- Fourteen chars in this element.-->
<Item>1234567890ABCD</Item>
</Items>
50/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;
51/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;
52/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
53/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.
54/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]);
55/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);
}
}
}
56/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/javabinding.html
57/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
58/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
59/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>
60/119
Árbol DOM
61/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.
62/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);
63/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 árbol
OutputNode (doc.DocumentElement);
}
64/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);
}
}
}
65/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);
}
}
}
}
66/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 ();
67/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"]
68/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.

69/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);
}
}
}
70/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.
71/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
72/119
Operaciones entre árboles en
XSL
73/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
74/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)
75/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>
76/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>
77/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>
78/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.
79/119
Aplicaciones usando XSLT
Cliente
Servidor
XML
Internet
XSLT
Arquitectura en 5 capas dónde el
servidor contiene conversores
XSLT para generar presentación
en distintos formatos.
JSP
Clases
Java
Base de
Datos
80/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
81/119
Ejemplo XSLT
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Tran
sform">
<xsl:template match="/">
<xsl:apply-templates/>
</xsl:template>
</xsl:stylesheet>
82/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>
83/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>
84/119
Elementos XSLT (cont)

Para realizar distintos procesamientos en función
de los datos se usa xsl:choose:
compone de elementos xsl:when
 Un elemento opcional xsl:otherwise
 Se

Para procesar o no un elemento en función de
una condición se usa xsl:if:
 Condición
en atributo test
85/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>
86/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>
87/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()"/>
88/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]">

89/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>
90/119
Resultado transformación

Salida (grades70.txt):
Student name=“Usue Artaza"
average="66,25"
Student name=“Iñigo Urrutia"
average="77,5"
91/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.
92/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
93/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>
94/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>
95/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>
96/119
Aplicando XSL en el Cliente III
97/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>
98/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>
99/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);
%>
100/119
Aplicando XSL en el Servidor IV
101/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);
}
}
}
102/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


Usar objetos de extensión XSLT


Pueden invocarse desde dentro de la hoja de estilo
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
103/119
XSL Scripts




Solamente funciona para IE
Documentación en:
http://msdn2.microsoft.com/enus/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/>
104/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>
105/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>
106/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>
107/119
XSLT Object Extensions

Microsoft recomienda evitar el uso de scripts inline en hojas XSLT
 Para
implementar funcionalidad extra es mejor utilizar
códigos de bloque externos

Revisar ejemplo en las siguientes transparencias
108/119
Ejemplo Extensions Object
// Compile: csc /target:library Products.cs
using 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();
}
}
}
109/119
Products.xml
<?xml version="1.0" encoding="ISO8859-1" ?>
<Products>
<Product id="1" name=“chorizo"/>
<Product id="2" name=“jamón"/>
<Product id="3" name=“salami"/>
</Products>
110/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>
111/119
Ejemplo Aplicación usando EO
// Compile: csc /r:Products.dll ProductsStockLevel.cs
using 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);
112/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);
}
}
}
}
113/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
114/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/enus/library/ms950776.aspx
 EXSLT: iniciativa para crear extensiones para XSLT
115/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 functions
XsltArgumentList 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();
116/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
117/119
Referencias

XML DOM Tutorial


XSLT Tutorial


http://msdn2.microsoft.com/en-us/library/ms950776.aspx
Ejemplos interesantes de uso de EXSLT:


http://support.microsoft.com/kb/323370
EXSLT: Enhancing the Power of XSLT


http://www.w3schools.com/xsl/default.asp
HOW TO: Use Extension Objects When You Execute XSL
Transformations in Visual C# .NET Applications


http://www.w3schools.com/dom/default.asp
http://msdn2.microsoft.com/en-us/library/ms950776.aspx
Nuevas características .NET XML 2.0:
 http://www.15seconds.com/issue/050601.htm
118/119
XML, Distribución y
Componentes
Tema 1 – Procesamiento XML en .NET –
Preguntas y Sugerencias
Dr. Diego Lz. de Ipiña Gz. de Artaza
http://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)