PDF de programación - Tutorial de XSP (Ximian ASP.NET)

2010-05-17

http://web.archive.org/web/20080607201...o-linux.com/x2/2x009-tutorial-xsp.html

#1

Tutorial de XSP (Ximian ASP.NET)
Alvaro del Castillo San Félix
Ándago
          <[email protected]>
        
Alejandro Sánchez
mono-hispano
          <[email protected]>
        

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

2010-05-17

http://web.archive.org/web/20080607201...o-linux.com/x2/2x009-tutorial-xsp.html

#2

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:[email protected]:/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: [email protected]

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:[email protected]:/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

2010-05-17

http://web.archive.org/web/20080607201...o-linux.com/x2/2x009-tutorial-xsp.html

#3

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";

2010-05-17

http://web.archive.org/web/20080607201...o-linux.com/x2/2x009-tutorial-xsp.html

#4

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 e