Apéndice B.1 - Curso Básico de Programación en Visual Basic

Este es el contenido de la primera parte del Apéndice B del Curso Básico de Programación con Visual Basic

Como bien sabrás, este Curso Básico de Programación con Visual Basic empezó siendo "genérico" para todas las versiones que había en aquel "lejano" 18 de Abril de 1997 (sí, hace muchos años ya), pero con el tiempo los temas tratados fueron centrándose más en la versión de 32 bits de Visual Basic 4.0 (con esa versión se podían crear aplicaciones tanto de 16 como de 32 bits, con las versiones anteriores solo podíamos crear de 16 bits), después llegaron las versiones 5.0 y 6.0 que es la última de esta familia de Visual Basic, ya que la versiones posteriores (7.0, 8.0 y la futura 9.0) solamente serán para las versiones de .NET Framework.
En las dos últimas versiones de Visual Basic (5.0 y 6.0) se introdujeron nuevas características que hacían (y siguen haciendo) muy potentes a este lenguaje, que a pesar de tener más de 15 años de edad sigue siendo el favorito de muchos programadores (o desarrolladores, según gustos).
En este curso básico, he intentado enseñarte todo lo que puedes hacer con este lenguaje, aunque, como es natural, no lo he explicado todo, y no se si algún día conseguiré explicarlo todo, pero como ves, después de tres años, aún quiero seguir manteniéndolo vivo, ya que a pesar de lo que muchos predecían, la gente no acaba por pasarse a la versión de .NET de este lenguaje, la razón principal es porque aún hay muchos sitios (no sitios de Internet, sino sitios de trabajo) en el que siguen "exigiendo" a sus empleados que "sepan" programar con VB6. Así que... creo que habrá VB6 durante mucho tiempo más.

Introducción

Y en este apéndice, (por no llamarlo entrega, que también podía llamarlo así, pero... he preferido que sea un apéndice, por aquello de que en realidad es algo "aparte" del curso en sí), quiero explicarte los tipos de proyectos que podemos crear con Visual Basic 6.0 (cuando digo 6.0 también es válido para el 5.0, incluso para el 4.0, aunque en este último ya no se utiliza, además de que no permite crear todos los tipos de proyectos que veremos en este apéndice).
También te explicaré cómo compilar esos diferentes tipos de proyectos y cómo configurarlos, ya que aún hay gente que se "queja" de que no saben a ciencia cierta para que sirven las diferentes opciones que tenemos en la configuración de los proyectos de Visual Basic.

Antes de seguir, te recomiendo que le eches un vistazo a los dos apéndices anteriores, en el primero (el apéndice A.1) te explico cómo crear nuevos proyectos usando Visual Basic 5.0 Crontrol Creation Edition (la versión gratuita de VB5); en el segundo (apéndice A.2) te explico cómo añadir controles a los formularios y esas cosillas.
Te recomiendo que te los leas, porque lo mismo piensas que en este te explicaré lo mismo... pero no, lo que aquí veremos es cómo configurar y compilar los distintos tipos de proyectos que podemos crear con Visual Basic 6.0.

Nota:
Todas las capturas y explicaciones de este apéndice serán de la versión empresarial de Visual Basic 6.0 en español, pero lo explicado será igualmente válido para el resto de versiones y ediciones, ya que solo trataremos de los 4 tipos principales de proyectos que podemos crear con Visual Basic.

Crear un nuevo proyecto de Visual Basic

Lo primero que haremos es crear un nuevo proyecto, para así poder ver cómo los tenemos que configurar.
Por tanto, debemos iniciar el VB y por regla general nos mostrará la pantalla mostrada en la figura 1:

Nota:
Si la pantalla mostrada en la figura 1 no se muestra al iniciar el Visual Basic, tendrás que seleccionar Nuevo proyecto del menús de Archivo.

Empezaremos creando uno del tipo EXE estándar, que será el más común, es decir, el que nos permite crear un .EXE de toda la vida.

Siempre que se crea el nuevo proyecto de tipo EXE tendremos un formulario en la ventana del Explorador de proyectos, que no te voy a explicar para que sirve, ya que está bien explicado en los dos apéndices anteriores.
Ahora lo que veremos es cómo "configurar" las propiedades de este proyecto.

Las propiedades del proyecto

Para configurar las propiedades del proyecto, debemos seleccionar Propiedades <nombre proyecto>... del menú Proyecto, tal como vemos en la figura 2.

Al seleccionar esa opción tendremos a la vista un cuadro de diálogo como el de la figura 3.

Propiedades generales del proyecto

La primera ficha (o solapa o tab) que se muestra es: General. Desde esta ficha podemos configurar varias cosas.
Veámosla cada una de ellas.

En la parte superior izquierda tenemos un cuadro de diálogo con el Tipo de proyecto que hemos seleccionado, por defecto tendrá el valor EXE estándar (o el que hayamos elegido al crear el nuevo proyecto), de esa lista podemos elegir cualquier otro que nos interese, que serán los cuatro que te comenté antes:
EXE estándar, EXE ActiveX, DLL ActiveX y Control ActiveX.
Como no queremos cambiar el tipo de proyecto, lo dejamos como está, aunque si decides cambiar el tipo de proyecto a generar, desde aquí lo puedes cambiar.

Junto a esa lista tenemos una lista desplegable con el Objeto inicial, es decir, si tenemos varios formularios, podemos indicar cual será el que se usará como formulario inicial de la aplicación.
También podemos seleccionar Sub Main, si es que queremos que la aplicación empiece por el método Main. Ese método o procedimiento debe estar declarado en un módulo de tipo BAS, por ahora no hablaremos de este método pero lo haré en otra ocasión, por ejemplo para crear una aplicación de VB6 que no tenga formularios.

Debajo de estas dos opciones, tenemos el Nombre del proyecto, este nombre será el mismo que el mostrado en el Explorador de proyectos, por tanto podemos cambiarlo desde estas opciones o bien desde el mencionado explorador. Como puedes comprobar, el nombre que muestra es el predeterminado: Proyecto1.

Si queremos que nuestra aplicación de VB6 tenga su propia ayuda, podemos indicar el nombre del fichero en la casilla Nombre del archivo de Ayuda, y si no sabemos el "path" en el que se encuentra, podemos usar el botón con los res puntos suspensivos que hay a continuación. También podemos indicar el "ID" del contenido de la ayuda, con idea de que sea ese "id" el que se use cuando el usuario pulse en F1.
Los tipos de ficheros que soporta el Visual Basic 6.0 son ayudas con extensión .HLP y las que tienen extensión .CHM.

Nota:
La forma de crear ficheros de ayuda para VB y cómo usarlas están explicadas en mi sitio, (y desde el índice principal puedes acceder a ellas), aunque es posible que algún día de estos las resuma y las incluya en el curso básico, ya veremos...

La casilla con la Descripción del proyecto en realidad solo se utiliza (o es útil) para los proyectos de tipo ActiveX, pero no es mala costumbre rellenarla siempre.

Los checkbox que hay abajo a la izquierda sirven para diferentes cosas, aunque dependiendo del tipo de proyecto estarán habilitadas o no, en este caso, está habilitada y seleccionada la de Actualizar controles ActiveX, esto vale por si tenemos añadido algún control ActiveX (.ocx) en nuestro proyecto y si se detecta que hay una nueva versión, se actualizará el proyecto para usar esa versión. Por regla general lo podemos dejar marcado.

Las opciones del grupo Modelo de subprocesos solo estará disponible para proyectos ActiveX.

Propiedades Generar

La segunda ficha de las propiedades del proyecto (ver figura 4) es la de Generar el proyecto.

En esta ficha tenemos los datos del Número de versión, que serán las que se muestren cuando pulsemos en las propiedades del ejecutable que creemos desde VB6. Si marcamos la casilla que hay debajo: Incremento automático, cada vez que creemos un nuevo ejecutable, se incrementará automáticamente el valor de Revisión. Yo normalmente lo tengo desmarcado, ya que añado mis números de revisiones, etc., de forma manual, pero si lo dejas marcado, nunca se te olvidará cambiar ese valor, que siempre es conveniente para saber que esta versión es diferente a las anteriores.

En el grupo Aplicación tenemos el Título del proyecto y el formulario que se usará para el icono de la aplicación. En la lista desplegable que hay junto a Icono se mostrarán los formularios que tengamos y el icono que tenga el seleccionado será el que se use para nuestra aplicación. Por defecto estará el formulario usado como inicio de la aplicación.

En el grupo de Información de la versión tenemos varias opciones en Tipo, según las vayamos seleccionando, podemos escribir el valor en la casilla que hay bajo Valor. Los valores de tipo son los siguientes:

Tipo	Descripción
Comentarios	Descripción larga de la aplicación
Derechos de autor	El copyright
Descripción del archivo	Descripción corta de la aplicación
Marcas comerciales legales	Las marcas comerciales de los productos usados con esta aplicación
Nombre de la compañía	El nombre de la compañía
Nombre del producto	El nombre del producto

Como te comentaba, estos son los valores que se muestran en Windows cuando mostramos las propiedades del ejecutable.
La versión, descripción corta y el copyright son los datos que se muestran en la parte superior de la solapa Versión.
El resto de datos se muestran al seleccionar las opciones que hay en la parte inferior de la solapa Versión, tal como puedes ver en la figura 5.

En Argumentos de la línea de comandos podemos indicar lo que queramos, de forma que ese valor sea el que se pueda interceptar mediante la función Command$ para simular lo que pasaría si el usuario de nuestra aplicación la indiciara indicando algo a continuación del nombre del ejecutable, ya sea desde una ventana de "DOS" o bien porque le ha agregado opciones después del nombre del ejecutable en un acceso directo.
Por ejemplo, si la aplicación se inicia así: proyecto1.exe pepito.doc, el valor de la línea de comandos será "pepito.doc" y ese valor será el que se indique en Command$.
Si se escriben más cosas, por ejemplo: proyecto1.exe Erase una vez que se era, todo lo que haya después del nombre del ejecutable será el contenido de la línea de comandos.

La casilla Argumentos de compilación condicional sirve para crear "constantes de compilación", las constantes de compilación son las que podemos usar con: #If CONSTANTE = VALOR Then.
Esas constantes se tendrán en cuenta mientras compilamos el ejecutable, es decir, no son valores que podamos cambiar una vez que el .exe está creado.
La forma de indicarlo en esa casilla sería de esta forma: NOMBRE = VALOR : NOMBRE2 = VALOR, es decir, las usamos como si hiciéramos una asignación y si queremos definir más de una, las separamos con dos puntos.
Esto es equivalente a definir esas constantes con la instrucción #Const NOMBRE = VALOR en todos los ficheros de nuestro proyecto.

Por último, la casilla Quitar información de controles ActiveX no usados, nos viene muy bien si hemos añadido "componentes" (controles .ocx) a la barra de herramientas de controles, pero que no hemos añadido en ninguno de los formularios, por tanto, cuando compilemos no se harán referencia a esos controles no usados.

Propiedades Compilar

En esa ficha de las configuraciones del proyecto tenemos las opciones para eso, para compilar nuestra aplicación.
Las opciones disponibles son las mostradas en la figura 6, y te las detallo un poco a continuación.

La primera opción es Compilar a P-Code, seleccionándola haremos que el compilador de VB cree un ejecutable en el que se utiliza "pseudo código". Esta compilación lo que hace es crear un ejecutable más pequeño, ya que prácticamente todo lo que contiene son llamadas a las funciones y código ejecutable del "runtime" de Visual Basic. En la mayoría de los casos, esta será la opción más conveniente, sobre todo si lo que nos interesa es que nuestro ejecutable no ocupe mucho.

El grupo de Compilar a código nativo nos da varias opciones que veremos ahora, la diferencia entre la compilación a código nativo y el P-Code es que en la compilación a código nativo se utiliza un compilador "de verdad", es decir, en lugar de usar funciones que llaman a las que están en el runtime, se sustituyen por código máquina, si bien el runtime de VB sigue utilizándose, ya que no todo el código usado se incluye en el ejecutable. Al compilar en modo nativo, el fichero ejecutable suele ser mucho más grande que el de P-Code, también suele tardar más en compilar, dependiendo de la cantidad de código que tengamos en el proyecto.
Y a pesar de lo que puedas pensar no siempre el resultado de compilar a código nativo suele resultar en un ejecutable más rápido, independientemente de como hayas seleccionados las opciones extras de compilar a código nativo.

Cuando seleccionamos la opción de compilar a código nativo, tenemos otras sub opciones que nos sirven para "afinar" dicha compilación, las tres primeras nos permiten optimizar para un código más rápido, lo cual suele ir acompañado de un ejecutable aún más "pesado". La segunda opción es optimizar para código reducido, como te puedes imagina, en este caso se "opta" por reducir el tamaño del ejecutable aunque ello vaya en detrimento de la velocidad, por último, sin optimización, pues eso, no se optimiza ni para código rápido ni para reducido... ¡ni fu, ni fa!

Optimizar para Pentium Pro(tm), pues eso, optimiza el código para los Pentium Pro, en otros Pentium también funcionará, pero puede que el rendimiento sea menor... o eso dice la documentación, en fin...

Lo de Generar información para depuración simbólica, es por si queremos generar un fichero .pdb para poder usar desde Visual Studio (o Visual C++) para depurar el código una vez compilado.

Al pulsar en el botón Optimizaciones avanzadas, nos mostrará el cuadro de diálogo que podemos ver en la figura 7, yo prácticamente nunca he usado estas opciones, y como puedes comprobar en esa figura, tampoco se recomienda su uso si realmente no sabemos lo que hacemos, así que... mi recomendación es que no "trastees" aquí, y si lo vas a hacer, léete lo que dice la ayuda... ya que yo no te lo voy a explicar... je, je, es que si yo no lo uso, pues... el que quiera usarlo que se busque la vida ;-))) No, en serio, no te recomiendo que uses estas opciones salvo que antes hayas comprobado "el efecto" que puede producir.

La opción final de la pantalla de configuración de compilación (figura 6), la que indica Dirección base de la DLL, y que solo estará activada en los proyectos de tipo DLL ActiveX y control ActiveX (un control ActiveX, en realidad es una DLL con la extensión .ocx). Esta opción incluye un valor que por defecto es: &H11000000, ese valor será la dirección de memoria en la que se cargará esa DLL, la recomendación es que siempre usemos una diferente para nuestras DLLs, si al cargar la DLL en memoria, esa dirección está ocupada se utilizará otra, si no está ocupada, se usará la que indiquemos. Yo por regla general le doy el valor que empieza por &H57nnnnnn, por tanto, te rogaría que usaras otra distinta, así si en tu equipo hay una DLL que yo he hecho y una tuya, cada una usará su "segmento" de memoria.

Propiedades Componente

La ficha Componente solo estará disponible cuando creemos proyectos de tipo ActiveX, en la figura 8 vemos esa ficha si tenemos seleccionado un proyecto de tipo EXE ActiveX.

En el grupo Modo de inicio podemos seleccionar Independiente o Componente ActiveX. Estas opciones solo está disponibles cuando el proyecto es de tipo EXE ActiveX. Para comprender bien debes saber cómo funcionan los EXE ActiveX, y no creo que ese este el lugar idóneo para explicarte como "furula" este tipo de proyecto, pero te explicaré un poco, para que no andes demasiado perdido (o creas que quiero escurrir el bulto, je, je).

¿Qué es un EXE ActiveX?

Un EXE ActiveX es un componente ActiveX (o componente COM), en realidad todo lo que creemos con VB6 son componentes ActiveX/COM, (ver la entrega 47 para más detalles), pero es un componente diferente, ya que nos permite usarlo de dos formas diferentes: como un ejecutable normal que es capaz de proporcionar "objetos automatizados" y también se puede usar como un control ActiveX, en el sentido de que simplemente proporciona esos objetos de automatización pero no se "ve" que se esté ejecutando (o en funcionamiento).
Los ejemplos "clásicos" de componentes EXE ActiveX son las aplicaciones como Word o Excel, que tanto pueden hacer de componente ActiveX como de una aplicación normal y corriente.
Pues bien, si seleccionamos la opción Independiente, le estamos indicando al compilador de VB que nuestra idea será usar este ejecutable como un EXE normal que es capaz de proporcionar objetos de automatización, es decir, se ejecutará de forma visible pero si la "referenciamos" desde otro proyecto podremos usar las clases que expone públicamente.
Por otra parte, si seleccionamos Componente ActiveX, la aplicación se iniciará de forma "oculta", y solo proporcionará esas clases públicas que hayamos indicado en dicho ejecutable.

De la opción Servidor remoto no te voy a hablar, ya que nunca la he usado, así que...

En el cuadro Compatibilidad de la versión tenemos tres opciones y se utilizan para los componentes ActiveX (sean del tipo que sean), estas opciones indicarán cómo tratará el compilador el código generado. Normalmente cuando creamos un componente ActiveX, éste debe estar registrado en el registro del sistema operativo, si no lo está, no podremos usarlo. Pues bien, el propio Visual Basic se encarga de hacer ese registro, (pero solo en nuestro equipo), y dependiendo de como tengamos seleccionada estas opciones actuará de una forma u otra.

Si seleccionamos Sin compatibilidad, querrá decir que cada vez que compilemos el componente creará una nueva entrada en el registro, bueno, que creará un nuevo valor que identifica a este componente. Esta opción solo debemos seleccionarla si la queremos empezar "en limpio" un componente, y no será opción que habitualmente seleccionaremos.

Si seleccionamos Compatibilidad de proyecto le estamos indicando que siempre que se compile actualice el resto de proyectos en el que estemos usando dicho componente, de forma que podamos seguir usándolos sin problemas y sin tener que andar cambiando las referencias de los proyectos que usan el componente. Todo esto es para cuando creamos un componente ActiveX y añadimos proyectos normales que lo utilicen, para más detalles sobre todo esto, léete la entrega 47.

Por último tenemos la opción de Compatibilidad binaria, en la que además hay una caja de textos, en la que estará el componente que hemos creado. La compatibilidad binaria significa que siempre se mantendrá la misma clave del registro de Windows, esto quiere decir que si modificamos el código "interno" de las clases que tenemos en ese componente, esos cambios se intentarán manejar como compatibles con las versiones anteriores, de forma que si ya tenemos distribuido el componente, esos cambios no afecten a las aplicaciones que lo utilicen. Esto en realidad es más "peliagudo" de lo que en este pequeño comentario pueda explicarte, y como seguramente será motivo de una entrega propia, no me voy a enrollar demasiado, solo decirte que el propio Visual Basic nos avisará si "rompemos" esa compatibilidad binaria, dándonos opciones para solucionar el "problema". En la caja de textos indicaremos el componente previamente compilado con el que queremos mantener esa compatibilidad binaria. Y si quieres saber más, léete esto.

Y la última opción de este diálogo es la ficha Depurar, de esta ficha, pues tampoco te voy a comentar nada, ni siquiera te voy a poner una captura, porque... si no voy a comentarte nada, ¿que más da lo que contenga?
Pues eso.

Compilar el proyecto

Como ya sabes, en el entorno de Visual Basic podemos tener más de un proyecto abierto, normalmente tendremos varios cuando estemos creando una DLL ActiveX o un Control ActiveX y queramos probarlo en un proyecto normal, tal como te comenté en la entrega 47.
En cualquier caso, para compilar ese o esos proyectos lo haremos mediante la opción Generar <nombre proyecto>... si es un proyecto independiente, bien el único que tengamos abierto o el que tengamos seleccionado si es que tenemos más de uno.
En caso de que tengamos varios proyectos, podemos seleccionar la opción Generar grupo de proyectos... que como vemos en la figura 9, estará deshabilitado si no tenemos varios proyectos cargados.

Dependiendo del tipo de proyecto que tengamos cargado en el IDE de Visual Basic, la extensión será .exe para los proyectos EXE estándar y EXE ActiveX, .dll para el tipo de proyecto DLL ActiveX o bien .ocx para el tipo de proyecto Control ActiveX.

Al pulsar en esa opción nos mostrará un cuando de diálogo como el de la figura 10, en el que indicaremos el nombre que queremos usar y dónde guardarlo. Bueno, ese cuadro de diálogo solo se mostrará si ya hemos compilado (o generado) nuestra aplicación como mínimo una vez, ya que la primera vez la generará directamente usando como nombre el mismo nombre del proyecto y como path el del propio proyecto.

Si pulsamos en el botón Opciones... nos mostrará el cuadro de diálogo de propiedades del proyecto pero solo con las solapas (o fichas) Generar y Compilar.

Pues esto es todo por hoy... que para mi ha sido ayer y hoy, ya que como soy tan "pamplinas", pues tardo una eternidad en escribir cuatro cosillas para que tu lo tengas más fácil... ;-))))

Tipos de proyectos de VB6, cómo compilarlos, y más...

Apéndice B

Una batallita del Guille