Tutorial de XSP (Ximian ASP.NET)

Alvaro del Castillo San Félix

Ándago

          
        

Alejandro Sánchez

mono-hispano

          
        


Table of Contents
1. Prefacio
2. Introducción
3. ¿Qué es ASP.NET?
4. Vamos con XSP
5. Compilación de XSP
6. Análisis de una petición ASPX
6.1. El código ASPX
7. Partes de ASPX
7.1. Controles
7.1.1. Controles del servidor web (WebServerControl)
7.1.2. Controles HTML
8. Ejecución del ASPX
9. Conclusiones
10. Referencias

1. Prefacio

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license can be found in GNU Free Documentation License.


2. Introducción

El presente artículo pretende ser una introducción a XSP, la implementación que está llevando Ximian de ASP.NET, la propuesta de páginas activas en el servidor que Microsoft a presentado dentro de su plataforma .NET.

En la actualidad se ha implementado el parser de páginas ASP y el generador de código para poder ejecutar Aplicaciones ASP Web.

Dentro de la plataforma Mono los servicios web serán una de las partes que más demanda recibirán, ya que las plataformas web se encuentran ya implantadas de forma muy amplia y permiten acceder con navegadores genéricos e independientes de la plataforma a los servicios. Gracias a XSP podremos obtener dichos servicios de forma cómoda utilizando toda al flexibilidad de la plataforma Mono a la hora de desarrollar.

A muchos desarrolladores siempre nos ha gustado evitar en todo lo posible utilizar la plataforma Microsoft para desarrollar. Con ASP.NET no tendremos que desarrollar en plataforma Microsoft si no que nuestros desarrollos, a parte de funcionar en GNU/Linux con Mono, funcionarán también dentro de ASP.NET, al menos mientras Microsoft no introduzca sistemas que bloqueen esta portabilidad.


3. ¿Qué es ASP.NET?

La idea detrás de ASP.NET es la misma que existía con ASP (Active Server Pages): hacer sencilla la programación dentro del servidor de web. En las páginas ASP, muy similares en idea a PHP, se podía incorporar junto al HTML, código de acceso a BD, de acceso a librerías para control de sesiones web y otras funcionalidades muy útiles a la hora de desarrollar aplicaciones web.

La principal referencia de ASP.NET la tenemos en http://www.asp.net/, un portal de Microsoft donde se nos describe la tecnología y sus ventajas. Junto con los motivos para utilizar ASP.NET, tenemos más de 900 ejemplos que nos pueden ayudar a conocer el entorno de forma rápida, junto con tutoriales más detallados para conocer con detalle ciertos aspectos de la plataforma.

La cantidad de artículos, libros y portales dedicados a ASP.NET es bastante importante lo que muestra que ya es una tecnología que poco a poco se va implantando. Al ser XSP una implementación de ASP.NET, podemos reaprovechar todos estos recursos en nuestra plataforma Mono. El trabajar codo con codo con la plataforma de Microsoft tiene sus ventajas ;-)

Pero, respondamos a la pregunta de esta sección: ASP.NET es una plataforma que se integra con IIS (en nuestro caso será por ejemplo con Apache) y que permite que se accedan a páginas con extensión "aspx" las cuales pueden tener junto al HTML, código en diferentes lenguajes de programación, aunque sólo se debe de utilizar uno por página.

Para el lector familizarizado con PHP, Zope o J2EE, la idea es la misma: facilitar el desarrollo de aplicaciones con interfaz web. Para ello es común montar una infraestructura de librerías y servidores detrás del servidor web. El servidor web recibe la petición y si es de una página activa, terminada en ".aspx", le pasa la petición a la arquitectura ASP.NET.

En el caso de XSP y Mono, cuando Apache vea que se pide una página ".aspx", le pasará la petición al módulo XSP el cual con la ayuda de Mono, servirá la petición, entregará los resultados a Apache y este se los entregará al cliente.


4. Vamos con XSP

Como desarrolladores de software libre, podríamos tener poco interés en ASP.NET al ser una plataforma cerrada, pero ahora que Ximian se ha lanzado a ofrecernos una alternativa libre, esta adquiere un gran interés para nosotros. Tenemos todos los recursos de ASP.NET para aprender, todas las librerías que se vayan haciendo (XSP será capaz de ejecutar las páginas aspx que corren en ASP.NET) para ASP.NET asi que, todo parecen ventajas. La migración de sistemas ASP.NET de plataformas cerradas como Windows 2000 con IIS a plataformas libres con GNU/Linux y Mono será ahora mucho más sencilla que, cuando había que utilizar inseguras extensiones de Apache para poder ejecutar código ASP en máquinas GNU/Linux. Concluyendo, el interés por esta plataforma es enorme dentro del mundo de software libre.

Lo primero para comenzar a jugar con XSP es bajarnos el módulo del CVS de Mono. Como vemos, esto es bastante sencillo:

acs@merry:~/src$ cvs -d :pserver:anonymous@anoncvs.go-mono.com:/mono co xsp
acs@merry:~/src$ cd xsp/
acs@merry:~/src/xsp$ ls
CVS  doc  Makefile  README  src  test
      
Como siempre, lo primero es leer el README, que en este caso contiene información interesante.
XSP es la implementación de Ximian del parser de página y generador de código
de ASP.NETpara la ejecución de Aplicaciones ASP Web.

Estructura:

    src/
        Ficheros de fuente para el parser/generador.

    doc/
        Documentación de las páginas ASP.NET

    test/
        Pequeños ejemplos de páginas ASP.NET

Responsable: gonzalo@ximian.com
      
No, el fichero no está en español, pero se ha traducido :) Dentro del directorio "doc" tenemos documentos que nos describen el lenguaje ASPX, el código C# generado desde una página ASPX y como ayudar en el proyecto.

Dentro del directorio "test" tenemos varios ejemplos de páginas "aspx" para poder comprobar el correcto funcionamiento del parser y del generador de código y finalmente, nos queda el directorio "src", donde esta la implementación real de XSP. En este mismo directorio tenemos un servidor de web de pruebas que nos va a servir para comprobar el funcionamiento de las páginas ASPX.

Resumiendo, la idea ahora es compilar el parser de ASPX, el generador de código, comprobar utilizando el servidor de web de pruebas que las páginas ASPX se procesan y se sirven de forma correcta.


5. Compilación de XSP

Llega el momento más divertido, el de comenzar a jugar con XSP. Para ello nos vamos al directorio de las fuentes, "src" y lo compilamos. Ojo, hay que tener las últimas versiones de mono para poder jugar a partir de ahora. Hay algunos problemas actualmente, Julio de 2002, cuando se usa el recolector de basura de Mono (GC) por lo que necesitamos compilar mono con el GC desactivado. Para ello, compilamos las fuentes de "mcs" y las instalamos y luego compilamos "mono" con las opciones:

acs@merry:~/src/mono$ ./autogen.sh --prefix=/usr/local/ --with-gc=none
      
Luego hay que asegurarnos de utilizar esta versión de mono y por ejemplo, no utilizar la versión empaquetada para Debian. Para ello, ponemos las siguientes variables de entorno:
export PATH=/usr/local/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
      
Vamos ahora a compilar a XSP:
acs@merry:~/src$ cvs -d :pserver:anonymous@anoncvs.go-mono.com:/mono co xsp
cvs server: Updating xsp
U xsp/Makefile
...
U xsp/test/web_textbox.aspx
acs@merry:~/src$
acs@merry:~/src$ cd xsp
acs@merry:~/src/xsp$ ls
CVS  doc  Makefile  README  src  test
acs@merry:~/src/xsp$ make install
acs@merry:~/src/xsp$ make install
(cd src && make)
make[1]: Entering directory `/home/acs/src/xsp/src'
mcs /r:System.Web.dll /r:System.Drawing.dll /define:MONO /out:xsp.exe asp-parser.cs asp-tokenizer.cs aspelements.cs driver.cs generator.cs
Compilation succeeded
(cd HttpServer && make)
make[2]: Entering directory `/home/acs/src/xsp/src/HttpServer'
mcs /r:System.Web.dll /define:MONO /out:server.exe server.cs
Compilation succeeded
make[2]: Leaving directory `/home/acs/src/xsp/src/HttpServer'
make[1]: Leaving directory `/home/acs/src/xsp/src'
mkdir rundir
mkdir rundir/output
cp src/xsp.exe src/HttpServer/server.exe src/HttpServer/redirector.sh rundir/
cp test/*.aspx rundir/
cp test/*.png rundir/
mcs --target library -o rundir/output/tabcontrol.dll \
    -r System.Web test/tabcontrol.cs
Compilation succeeded
mcs --target library -o rundir/output/tabcontrol2.dll \
    -r System.Web test/tabcontrol2.cs
Compilation succeeded

Now cd to rundir and run: mono server.exe 8000
Then point your web browser to http://127.0.0.1:8000/
Enjoy
      
Bueno, ya tenemos compilado el parser, el generador de código y el servidor de web de pruebas. Además, nos indica como tenemos que arrancar el servidor de web (cd rundir; mono server.exe 8000) y a que URL debemos de acceder con el navegador, al puerto 8000 de nuestra máquina, donde tenemos allí escuchando a nuestro servidor de web.

La primera página con la que nos encontramos es la siguiente:

Figure 1. Página de ejemplos de XSP

Como vemos, nos lleva esta página a múltiples ejemplo de código ASPX funcionando ya dentro de Mono. Ha llegado el momento de comenzar a jugar con Mono.


6. Análisis de una petición ASPX

Rompamos la magia de como se procesa un fichero ASPX y veamos los pasos que se llevan a cabo para procesar dentro del servidor este tipo de ficheros, pasos que conluyen devolviendo al cliente web en formato HTML los resultados de su petición. Para ello, lo primero es arrancar el servidor:

acs@merry:~/src/xsp/rundir$ mono server.exe 8000
Remember that you should rerun the server if you change
the aspx file!
Server started.
      
Este primer mensaje nos indica que el servidor de web mantiene cache de las páginas que ya se han accedido, dejando en esta cache precompilados los ASPX. Si cambiamos alguno, tenemos que volver a reiniciar el servidor para que limpie la cache.

Vamos a analizar el ejemplo "button.aspx" que es bastante sencillo y útil para comenzar. El resultado de acceder a este ejemplo es:

Figure 2. Ejemplo de botón ASPX en XSP

Y las trazas que deja el servidor son:
Accepted connection.
Started processing...
mono xsp.exe button.aspx
Output goes to output/xsp_button.cs
Script file is output/xsp_button.aspx.sh
mcs --target library -L . -r corlib -r System -r System.Data -r System.Web -r System.Drawing -o output/1566455972button.dll output/xsp_button.cs
Output goes to output/output_from_compilation_xsp_button.txt
Script file is output/last_compilation_xsp_button.bat
Finished processing...	
      
Lo primero que se hace es acceder al código de "button.aspx" y utilizar el generador de código "xsp.exe" que, a partir de la página "button.aspx", nos genera un programa en C# que se encargará de generar la página HTML para el cliente.


6.1. El código ASPX

La gran ventaja de utilizar ASPX para hacer las páginas web es la misma que tenemos con PHP: tenemos un lenguaje de programación más potente que HTML. Con este lenguaje incluso podemos acceder a bases de datos, realizar conexiones por red y otro tipo de acciones que no son posibles utilizando HTML estático.

El gran objetivo con este tipo de lenguajes del lado del servidor es pues ofrecer a los desarrolladores de sitios web un sistema sencillo de utilizar una plataforma de desarrollo potente, como puede ser PHP o Mono, y ser invocados y devolver los resultados a través de interfaces web.

El código del programa "button.aspx" es el siguiente:

<%@ Page Language="C#" %>
<html>
<head>
    <script runat="server">
    void Button1_OnClick(object Source, EventArgs e) 
    {
        HtmlButton button = (HtmlButton) Source;
        if (button.InnerText == "Enabled 1"){
            Span1.InnerHtml="You deactivated Button1";
            button.InnerText = "Disabled 1";
        }
        else {
            Span1.InnerHtml="You activated Button1";
            button.InnerText = "Enabled 1";
        }
    }

    </script>
</head>
<body>
    <h3>HtmlButton Sample</h3>
    <form id="ServerForm" runat="server">
        <button id=Button1 runat="server" OnServerClick="Button1_OnClick">
        Button1
        </button>
         
        <span id=Span1 runat="server" />
    </form>
</body>
</html>
	
Como vemos, es una página HTML en la que se ha introducido código C#. En general es mejor evitar mezclar HTML con código fuente, en este caso C#, para poder separar de forma clara el trabajo de diseño (HTML) del de programación, y utilizar plantillas para fundir el HTML en el código. En este primer ejemplo, y para simplificarlo, vamos a mezclar ambos en un único fichero.

Al comienzo de la página indicamos que el lenguaje que queremos utiliza es "C#". Esto muestra que en ASPX se quiere dejar abierta la opción de utilizar diferentes lenguajes, aunque un cambio de lenguaje exige utilizar otro generador de código. En Mono de momento sólo se puede utilizar C#.

Dentro de la página HTML utilizamos una etiqueta especial, "button", que es reconocida por el generador de código de XSP y que será sustituida por los elementos HTML necesarios. Podemos ver el código C# que se genera para generar este botón:

        private System.Web.UI.Control __BuildControl_Button1 ()
        {
            System.Web.UI.HtmlControls.HtmlButton __ctrl;

            __ctrl = new System.Web.UI.HtmlControls.HtmlButton ();
            this.Button1 = __ctrl;
            System.Web.UI.IParserAccessor __parser = (System.Web.UI.IParserAccessor) __ctrl;
            __ctrl.ID = "Button1";
            __ctrl.ServerClick += new System.EventHandler (this.Button1_OnClick);
            __parser.AddParsedSubObject (new System.Web.UI.LiteralControl ("\n\t\tButton1\n\t\t"));

            return __ctrl;
        }
	
Como vemos este método se encargar de crear el bóton (Button1), de asociarle lo que ocurre cuando se pulsa el botón y de asignarle una etiqueta. Vemos que este control se trata como si fuera casi un "widget" de un toolkit gráfico, aunque finalmente termina generando código HTML. Esto en realidad son ls tripas de la implementación y no tienen especial interés para el desarrollador.

Todas las partes del HTML que necesitan ser procesadas por el servidor dentro de Mono, se marcan con la etiqueta "runat=server". De esta forma, el servidor sabe que partes debe de entregar al cliente web tal cual, sin modificar, y cuales deben de ser procesadas dentro de XSP.


7. Partes de ASPX

7.1. Controles

En ASPX existen tres tipos de controles, estos son los WebServerControl, los HTMLServerControl y los controles de validación. Los primeros son elementos de la interfaz gráfica que se van a mostrar al usuario y se van a ejecutar en nuestra aplicación, tales como puede ser mostrar un calendario, un botón o mismamente una imágen. Los segundos son muy parecidos a lo que es la sintaxis html son las etiquetas o tags, unicamente que se van a poder hacer referencia sin necesidad de tags como si fuesen simples elementos que el programador hace referencia.


7.1.1. Controles del servidor web (WebServerControl)

Aquí unicamente enumerar los que hay y decir que muchos de los controles del servidor web podemos encontrar sus equivalentes en controles HTML , tales como botones, controles de texto, etcétera.

Entre los controles podemos ver los siguientes:

* AdRotator: Para mostrar una secuencia de anuncios

* Button: Se muestra un botón al que le podemos asociar un evento, al puro estilo GTK+ o GTK#

* Calendar: Muestra un calendario

* CheckBox: Típica casilla de comprobación con su equivalente como control HTML.

* CheckBoxList: Conjunto de casillas de comprobación

* DataGrid: Para mostrar información de una BBDD

* DataList: Lista con información de una BBDD

* DropDownList: Lista desplegable

* HyperLink: Vínculo a un web site

* Image: Muestra una imágen

* ImageButton: Muestra un botón con una imágen

* Label: Muestra una etiqueta de texto

* LinkButton: Botón con un enlace a una url

* ListBox: Lista de elemenos

* Panel: Panel que contiene otros controles, bien, un Button, CheckBox o cualquier otro.

* RadioButton: Botón de radio, una única opción a seleccionar

* RadioButtonList: Grupo de botones de radio

* Table: Una tabla con datos

* TableRow: Fila de una tabla

* TextBox: Caja de texto

Todos estos controles forman parte de lo que se llaman los controles del servidor al igual que los controles HTML porque se procesan en la parte del servidor donde estos residen, bien sea la máquina cliente o servidor, al igual que son traducidos a controles HTML para poderse mostrar en nuestro navegador web.


7.1.2. Controles HTML

Bueno los controles HTML se asemejan a lo son las etiquetas en HTML, sólo que viene a ser más parecido a lo que el programador necesita, ya que dota al programador de una serie de controles que hacen referencia a lo que son las etiquetas en HTML. Para ello veremos a continuación cuales tenemos disponibles, obviamente la mayoría de los definidos por la W3C en HTML 4.0.

Los controles HTML o HTMLServerControl al igual que sus equivalentes sería entre otros los siguientes:

HtmlAnchor: <a>

HtmlButton: <button>

HtmlForm: <form>

HtmlGenericControl: Resto de etiquetas no asignadas a los controles.

Image: <img>

HtmlInputButton


8. Ejecución del ASPX

Ya hemos visto que la página ASPX pasa a generar un programa en C# que es el que generará el HTML. Ahora llega el momento de ver como el servidor compila ese programa y lo ejecuta, algo que se realiza en el script "Script file is output/xsp_button.aspx.sh".

	  redirector.sh mono output/xsp_button.cs xsp.exe button.aspx
	
Tras ello, se pasa a crear una "dll" que será la que utilice el servidor para obtener la página HTML. Esta "dll" se genera con:
	  mcs --target library -L . -r corlib -r System -r System.Data -r System.Web -r System.Drawing -o output/1566455972button.dll output/xsp_button.cs
	
Como vemos, lo que se hace es compilar el fichero "xsp_button.cs" que fue anteriormente generado a partir de la página HTML con ASPX por XSP. Esta "dll" se guardará ya para futuras peticiones de esta página, evitando tener que volver a generar la página C# y compilarla.

En realidad, dentro del servidor se crea un "AppDomain" en el que se carga la "dll". Esto es así ya que podemos descargar de memoria un "AppDomain", lo que nos permitirá refrescar las librerías "dll" en caso de modificaciones.


9. Conclusiones

En este tutorial hemos querido acercar el estado actual de XSP, el cual está en plena evolución, analizando como funciona y la tecnología. A partir de este momento, nos podemos introducir en el mundo de ASPX, el cual ya se encuentra ampliamente documentado en Internet, en sitios como MSN.

El desarrollo de XSP se está realizando como software libre por lo que si te ha entrado el gusanillo de XSP y quieres seguirlo más de cerca, no dudes en entrar en contacto con los desarrolladores desde la lista de Mono y en el canal de #mono en irc.gnome.org.


10. Referencias