Este artículo explica cómo hacer nuestro primer componente de servidor utilizando Visual Basic 6. Encapsulando código ASP en un objeto COM, conseguimos, no sólo aumentar la velocidad de nuestra aplicación ASP, sino también proteger y centralizar el código en un único archivo.

Introducción

Se presupone en este artículo ciertas nociones sobre qué es COM. Te recomiendo que leas el artículo Introducción a COM para programadores ASP.

COM es un estándar binario, independiente del lenguaje, que especifica una interfaz de programación, para facilitar la comunicación entre programas. Se pueden hacer objetos COM en Visual Basic, Visual C++ (ATL), Visual J++ e incluso Delphi. Cualquier lenguaje que soporte la interfaz COM, nos vale.

En términos más prácticos, un objeto COM puede tomar la forma de un componente de servidor (server-side component), que es un archivo .DLL que, registrado en el servidor web, proporciona uno o varios objetos para ser utilizados desde nuestras páginas ASP. El objeto ASPEmail que conocemos, o ASPUpload... Son componentes de servidor.

Para seguir este artículo y desarrollar nuestro componente, necesitamos unos requerimientos mínimos: Visual Basic 5 o 6, obviamente, y Personal Web Server o IIS. El equipo en que he desarrollado este componente es un Pentium 450 Mhz con Windows 98 SE y PWS.

¿Por qué utilizar componentes?

Utilizar componentes en una aplicación IIS tiene las siguientes ventajas:

• El código está compilado, por lo que ejecuta mucho más rápido que el ASP nativo, que tiene que ser interpretado por el servidor web para generar el HTML.
• El código está encapsulado en una DLL, lo que facilita su distribución.
• Una vez registrado, el componente ActiveX reside en el mismo espacio que IIS (o PWS), por lo que el acceso desde nuestras páginas es inmediato (mucho más rápido que los programas CGI, que implican la ejecución de un programa en el servidor).
• Utilizando componentes, tenemos acceso a muchos más recursos del servidor web. Podemos utilizar otras referencias que existan en el servidor para efectuar cálculos complejos, efectuar intercambio de datos con una base de datos utilizando Microsoft Transaction Server, etc.
• Es compatible con cualquier navegador, puesto que devuelve código HTML.

Es importante, sobre todo para la gente que ya haya desarrollado aplicaciones en Visual Basic, no confundir un componente ActiveX de servidor con un componente ActiveX del lado del cliente. Este último es enviado a través de una red, junto con el HTML, y sólo puede ejecutarse en Microsoft Internet Explorer. Son la competencia de Microsoft a los applets de Java que todos hemos visto en forma de chat, por ejemplo.

Un componente ActiveX de servidor, en cambio, se ejecuta en el servidor web y envía HTML al cliente, de forma que cualquier navegador es compatible. Lo que tiene que ser compatible, por tanto, es el servidor web. Cualquiera con la API de ASP nos sirve.

Para que os apetezca todavía más desarrollar un componente, imaginad poder desarrollar código ASP asociado al servidor web. Más que asociado, que pertenezca al servidor. Pues puedes.

El hecho de que utilicemos Visual Basic no es fortuito: como desarrolladores ASP, estamos -la mayoría- familiarizados con el lenguaje VBScript. Por esto, el mismo código que utilizamos en nuestro ASP nos sirve para Visual Basic.

Preparación

Lo primero que tenemos que hacer es iniciar Visual Basic 6 y, en la ventana que aparece al principio, optar por un Nuevo Proyecto y elegir DLL ActiveX de las opciones que nos presenta. (Figuras 1 y 2)

Para poder acceder a los entresijos de nuestra página ASP (los objetos integrados, Response, Request...) tenemos que añadir una referencia en nuestro proyecto. Para ello, elegimos Referencias desde el menú desplegable Proyecto.

En la nueva ventana que aparece, buscamos (está ordenado por orden alfabético), Microsoft Active Server Pages Object Library (ver Figura 3). Una vez añadida la referencia, tendremos nuestro entorno de Visual Basic preparado. Si no lo tenéis ya, mostrad el Explorador de Proyectos (Ver -> Explorador de Proyectos) y la ventana de Propiedades (Ver -> Ventana de Propiedades).

En el explorador, tendremos Proyecto1 y, dentro de los módulos de clase, Class 1. Estos dos nombres serán los que utilicemos como ProgId al instanciar nuestro objeto en una página ASP. Haciendo click en el explorador sobre Proyecto1, veremos sus propiedades debajo, que se limitan al nombre. Podemos editar el nombre en ese campo, y cambiarlo a Ejemplo. De igual forma, haciendo click en la clase Class 1, podemos cambiar el nombre a HolaMundo. Si no está hecho, poned la propiedad Instancing a 5-Multiuse.

El contexto ASP

Para hacer nuestro primer objeto, vamos a programar el gran clásico de todo lenguaje: el "Hola mundo". Vamos a hacer un objeto que imprima las dos palabras directamente mediante un método. Olvidáos de sacar dinero de esto. :)

Hacemos doble click sobre la clase HolaMundo para ver el código, que debería estar en blanco. Para escribir en el navegador, utilizamos como ya sabéis el objeto Response. Como este no es un objeto integrado de Visual Basic, hemos añadido la referencia a la librería de objetos ASP.

Llegamos a un momento importante: además de porque vamos a empezar a escribir, porque tenemos que obtener el contexto, es decir el entorno de la página que instancia el componente. Para hacer esto, vamos a escribir el Sub OnStartPage. Este procedimiento responde a un evento, que es el que se produce cuando un visitante carga una página que contiene nuestro componente. IIS pasará entonces el contexto de esa página a nuestro componente. ¿Cómo? A través del objeto ScriptingContext, que podríamos traducir, por no perder la costumbre, por Contexto de Secuenciado de Comandos. Ya, ya sé que no suena nada bien, así que utilizaremos ScriptingContext. El contexto son los objetos ASP, y los valores que estos puedan tener (por ejemplo, los campos enviados con un formulario, y accesibles desde Request.Form). Escribimos el siguiente Sub:

Sub OnStartPage (ContextoPasado As ScriptingContext)
	
set miContexto = ContextoPasado

set Response = miContexto.Response
set Request = miContexto.Request
set Application = miContexto.Application
set Session = miContexto.Session
set Server = miContexto.Server

End Sub

Con esto nos vale, pero para ponerle las cosas más fáciles al compilador, y sobre todo, para obtener la maravillosa ayuda en línea de Visual Basic, declaramos estas variables al principio del código.

Private miContexto As ScriptingContext
Private Response As Response
Private Request As Request
Private Application As Application
Private Server As Server
Private Session As Session

Puede parecer una perogrullada, pero decirle a Visual Basic el tipo de las variables (ojo, no estamos creando los objetos) hace que al utilizar algún método o propiedad de estos objetos, nos muestre una "ayudita" con los parámetros. Me entenderéis cuando la veáis.

Si en una página ASP, para escribir "Hola mundo", hacemos:

Response.Write("Hola mundo")

En nuestro componente escribiremos:

Response.Write("Hola mundo")

Antes de que os vayáis y digáis que esto es un timo (gratis), os explicaré por qué es igual. Debéis notar que no es el mismo objeto. En el segundo caso utilizamos el objeto que hemos creado dentro del Sub OnStartPage. Para no perder la costumbre, lo he llamado también Response, pero podíamos haberlo llamado Mesa, y utilizar:

Mesa.Write("Hola mundo").

Si existe un procedimiento que se ejecuta al iniciarse la página, existirá otro que se ejecuta al terminar. Es el evento OnEndPage, y en él vamos a limpiar nuestros objetos (igualito que en ASP, recordad).

Sub OnEndPage ()

set miContexto = nothing
set Response = nothing
set Request = nothing
set Application = nothing
set Server = nothing
set Session = nothing

End Sub

¡Hola mundo!

Para hacer nuestro método HolaMundo que imprimirá la archiconocida frase en el explorador, declaramos un Sub público, para que pueda ser llamado desde nuestra página ASP:

Public Sub DiHola ()
	Response.Write "¡Hola mundo!"
End Sub

Vamos a probar el componente. Salva la clase y el proyecto (Guardar HolaMundo.cls y Guardar proyecto como Ejemplo.vbp), y después selecciona Generar Ejemplo.dll. Te preguntará dónde quieres salvar la DLL, y como el directorio no importa, sálvalo donde quieras.

Visual Basic compilará el proyecto y escribirá la nueva DLL. Si hacemos la prueba en el mismo equipo en que desarrollamos un componente, no hace falta registrarlo, pues al generar la DLL queda registrado automáticamente. Si luego copiáramos la DLL a otro equipo, tendríamos que registrar el componente así:

regsvr32 C:/Componentes/ejemplo.dll

Suponiendo que lo copiéis en el directorio Componentes.

La página ASP

¿Y nuestra página ASP? Pues va a ser muy sencilla, puesto que simplemente tiene que instanciar el objeto e invocar el método DiHola. Escribimos, por tanto:

<%

Dim oEjemplo

set oEjemplo = Server.CreateObject("Ejemplo.HolaMundo")

oEjemplo.DiHola 

set oEjemplo = nothing

%>

Ejecuta tu página, introduciendo la URL en el navegador y voilà. ¡El componente funciona!

Recompilar el componente

Si hacemos cualquier cambio en nuestro proyecto e intentamos generar de nuevo la DLL, Visual Basic nos dará un error, diciendo que el componente está siendo utilizado. Es el IIS (PWS), que lo tiene residente en memoria. Microsoft no pensó mucho en esto y, ni siquiera deteniendo y reiniciando el PWS podemos recompilar, así que parece que estamos forzados a reiniciar.

Como semejante entorno de desarrollo es insoportable, tenemos dos soluciones:

• Utilizar directamente la línea de comandos para descargar y recargar el PWS, así:

  C:\Windows\System\Inetsrv\pws.exe /stop

  Que detiene por completo el PWS (espera a que la ventana MSDOS diga que ha finalizado).

  C:\Windows\System\Inetsrv\pws.exe

  Que vuelve a iniciarlo.

  Así, antes de volver a generar la DLL ejecutamos el primer comando y después, para probar la página ASP, ejecutamos el segundo. (Una buena idea es hacer dos archivos .BAT con estos comandos, y dejar un acceso directo en el escritorio -gracias Doug Dean por la idea!).

• Utilizar la característica de Visual Basic 6 para probar estos componentes. Esto es lo que yo hago. El problema es, que todo el código anterior funciona para Visual Basic 5, excepto esto. Así que si utilizas Visual Basic 5, tienes que usar el método anterior.

  Para probar nuestros componentes sin tener que registrar la DLL, desplegamos Proyecto>Propiedades de..., y en la pestaña Depurar, marcamos Inicar el explorador con la dirección URL, e introducimos nuestra URL, por ejemplo http://localhost/pruebas/holamundo.asp.

  (Ver Figura 4) Para probar nuestro componente ahora, sin generar la DLL, utilizamos el hermoso botón de Play que tenemos arriba, o pulsamos F5, o elegimos Ejecutar -> Iniciar. Esto abrirá el explorador cargando la página. Después, pulsamos el botón de Stop (o elegimos Interrumpir desde el menú Ejecutar), y podemos seguir editando y salvando el proyecto sin problemas.

  No olvides, cuando hayas terminado, generar la DLL para utilizar la página ASP normalmente.

En resumen

Aunque nuestro componente es sumamente sencillo, hemos recorrido el proceso completo a seguir para crear cualquier componente con Visual Basic. Con esta guía podéis desarrollar cualquier cosa. Por ejemplo, podemos hacer un componente que escriba HTML, o un componente que lea de base de datos y haga una página dinámica, o que reciba un formulario y haga operaciones en función de este... Podemos hacer incluso un foro de discusión completo en un sólo componente, decidiendo que apartado mostrar en función de una querystring.

El límite, como se suele decir, lo pone la imaginación.

Código

Links