¿Qué es DXML?
Este es el tercer artículo de una serie sobre el uso del lenguaje de marcado extensible (XML) y el lenguaje de hoja de estilo extensible (XSL) en sitios web. En el primer artículo, hablamos sobre el uso de archivos XML para almacenar la información de la tabla de contenido (TOC) de un sitio y el uso de XSL, hojas de estilo en cascada (CSS) y scripts para generar un TOC DHTML. En el segundo artículo, utilizamos los mismos datos XML para generar menús DHTML utilizados en sitios web como microsoft.com. Si aún no ha leído estos artículos, le recomendamos leer los dos primeros antes de leer este.
Este mes, analizaremos algunas formas diferentes de implementar menús y TOC en su sitio. Abordaremos varias preguntas sobre implementación y arquitectura, y veremos algunos casos de uso:
Introducción de XML directamente en el marco
Uso de ASP # en HTML generado dinámicamente
Uso de ASP #include en HTML creado previamente
Es importante tener en cuenta que aunque podemos ver el DHTML de salida con cualquier navegador, siempre y cuando el XSL Para convertir, se debe tener Internet Explorer 5. instalado. Si, como en el primer caso, es necesario enviar XML al cliente, el cliente debe ser Internet Explorer 5. Si, como en el segundo y tercer caso, el XML se va a convertir en el servidor, es necesario instalar Internet Explorer 5 en el servidor. (Nota: solo se puede instalar en el servidor el analizador redistribuible Microsoft XML (inglés)).
Caso 1: Introducción de XML directamente en el marco
Si se encuentra en un entorno completo de Internet Explorer 5 (como una intranet), la forma más sencilla de enviar resultados al usuario es Probablemente con la ayuda de Internet Explorer 5, puedas navegar directamente por XML (inglés). Internet Explorer 5 puede enviar XML utilizando hojas de estilo relevantes; no es necesario realizar conversiones explícitas. Sólo necesitas especificar una hoja de estilo XSL con pautas de procesamiento (en inglés).
En el primer caso, utilizamos nuestro propio TOC como ejemplo. El marco TOC contendrá un archivo cuyo archivo webdev.xml hará referencia a la hoja de estilo TOC, como se muestra a continuación:
< p. >lt;?xml version="1.0"?gt;lt;?xml-stylesheet type="text/xsl" href="toc.xsl"?gt;
lt;TOPICLIST TYPE="Referencias de desarrollo web"gt;
.
.
.
lt;/TOPICLISTgt;
El marco TOC en sí se incluirá en el conjunto de marcos de la siguiente manera:
lt;FRAMESET COLS="150,*"gt;
lt;FRAME NAME= " fraToc" SRC="webdev.xml"gt;
lt;FRAME NAME="fraContent" SRC="home.htm"gt;
lt;FRAMESETgt;
Si ve este código utilizando Internet Explorer 5, puede ver la demostración de TOC de exploración XML.
Además de ser una manera fácil de enviar XML con estilo a los usuarios, explorar XML también es una excelente manera de depurar hojas de estilo XSL, incluso si está realizando la transformación en el servidor de esta manera. Internet Explorer puede proporcionarle información inmediata cuando se producen errores, incluidos números de línea y tipos de errores.
Caso 2: El uso de ASP #incluye en HTML generado dinámicamente
En muchos casos, necesita tener en cuenta otros navegadores además de Internet Explorer 5, o desea utilizar únicamente XML para formar parte del documento HTML (como el menú superior), en lugar del documento completo. El comando ASP #include proporciona una excelente manera de insertar algunos caracteres HTML en un documento más grande y compartir código común en varias páginas. ASP #includes se puede ampliar fácilmente para aprovechar XML realizando transformaciones XSL en el archivo #include.
El archivo #include carga los archivos XML y XSL, los convierte a HTML y luego escribe el HTML en el documento ASP. El siguiente es un documento ASP que contiene un menú:
Listado 1: Plantilla de documento HTML genérico que usa "dinámico" #includes
lt
lt ; HEADgt;
lt;TITLEgt;ASP dinámico #incluye demolt;/TITLEgt;
lt;/HEADgt;
lt;BODYgt;
lt;!-- #include file="menus_dyn.inc" --gt;
lt;Pgt;Este es el contenido general del documento...lt;/Pgt;
lt;/BODYgt;
lt;/HTMLgt;
Incluir archivos hará todo el trabajo duro.
Lista 2: menu_dyn.inc
lt;% @LANGUAGE="JScript" %gt;
lt;%
var sXml = "webdev.xml";
var sXsl = "menus.xsl";
var oXmlDoc = Server.CreateObject("Microsoft.XMLDOM"); p> oXmlDoc.async = false
oXmlDoc.load(Server.MapPath(sXml));
if (false != oXmlDoc.parseError)
{
Response.Write('XML parseError en línea ' oXmlDoc.parseError.line);
Response.End();
}
var oXslDoc = Server.CreateObject("Microsoft.XMLDOM");
oXslDoc.async = false;
oXslDoc.load(Server.MapPath(sXsl));
if (false != oXslDoc.parseError)
{
Response.Write('XSL parseError en línea ' oXslDoc.parseError.line);
Response.End();
}
Response.Write(oXmlDoc.transformNode(oXslDoc));
%gt; >
Desde el último artículo, he actualizado el menú para que sea utilizable en todos los navegadores, por lo que puedes usar cualquier navegador para ver la demostración dinámica #include.
Caso 3: Uso de ASP #include en HTML creado previamente
Cuando el servidor tiene una carga pesada o no desea cargar Cuando se llama al objeto XML desde En el menú, puedes elegir la tercera opción: realizar la conversión sin conexión. El código utilizado en este caso es casi idéntico a un include "real".
La única diferencia es: en lugar de usar Response.Write para generar el HMTL requerido, podemos usar el objeto Scripting.FileSystemObject para guardar el HTML convertido en un archivo.
Lista 3: makemenus.asp
lt;% @LANGUAGE="JScript" %gt;
lt;%
var sXml = "webdev.xml";
var sXsl = "menus.xsl";
var oXmlDoc = Server.CreateObject("Microsoft.XMLDOM"); p> oXmlDoc.async = false
oXmlDoc.load(Server.MapPath(sXml));
if (false != oXmlDoc.parseError)
{
Response.Write('XML parseError en línea ' oXmlDoc.parseError.line);
Response.End();
}
var oXslDoc = Server.CreateObject("Microsoft.XMLDOM");
oXslDoc.async = false;
oXslDoc.load(Server.MapPath(sXsl));
if (false != oXslDoc.parseError)
{
Response.Write('XSL parseError en línea ' oXslDoc.parseError.line);
Response.End();
}
var sOutput = oXmlDoc.transformNode(oXslDoc);
var sIncFileName = "menus_pre.inc" ;
var oFS = Server.CreateObject("Scripting.FileSystemObject");
var oIncFile = oFS.CreateTextFile(Server.MapPath(sIncFileName)); > oIncFile.Write(sOutput);
oIncFile.Close();
Response.Write('El archivo de inclusión lt;A HREF="' sIncFileName '"gt;'
sIncFileName 'lt;/Agt; se creó correctamente.');
%gt;
No estamos escribiendo en el flujo de respuesta ASP, sino en el server Se crea un archivo "estático" que contiene el HTML convertido. En otras palabras, en lugar de colocar el código de transformación XML directamente en el archivo #include, todo el código de transformación estará en la página ASP de Utilidades, que generará el archivo de inclusión.
Esto podría interesarte si necesitas utilizar el proceso de compilación para una aplicación web.
Siempre que se actualiza el archivo menus.xml, simplemente cargamos makemenus.asp y generamos un archivo #include actualizado. El uso de este algoritmo en una aplicación de Visual Basic logra el mismo objetivo.
Como en el caso 2, agregamos este archivo #include a todos los documentos que usan estos menús.