Visual Basic 6.

0 Nivel Avanzado

Incluye:
Clases con Proyectos EXE Standard

Proyectos ActiveX Exe

Proyectos ActiveX DLL

Controles ActiveX (.OCX)

Acceso a la API de Windows

Programacin de Sockets
 Contenidos
Detalles de los Proyectos y de las Clases ..................................................................................................... 4
Standard EXE ....................................................................................................................................................... 4
ActiveX EXE .......................................................................................................................................................... 5
ActiveX DLL .......................................................................................................................................................... 6
ActiveX Control ................................................................................................................................................... 7
Caractersticas generales de la programacin orientada a objetos. .................................................... 9
Encapsulacin ...................................................................................................................................................... 9
Reusabilidad (herencia) ................................................................................................................................. 10
Polimorfismo ...................................................................................................................................................... 10
Descripcin de las clases .................................................................................................................................... 11
Qu es una clase o mdulo de clase? .................................................................................................... 11
Eventos de un mdulo de clase: Initialize y Terminate ..................................................................... 12
Diferencias con los mdulos estndar ...................................................................................................... 13
Propiedades y mtodos .................................................................................................................................. 13
Propiedades como variables pblicas .................................................................... 13
Propiedades como procedimientos Property .......................................................................................... 13
Tipos de propiedades Property ............................................................................ 14
Mtodos ............................................................................................................................................................... 15
Procedimientos vs. Mtodos ................................................................................ 15
Alcance de las propiedades y mtodos .................................................................................................... 16
Lab01: Diseando una Clase con propiedades y mtodos .................................................................... 17
Creacin de objetos y otras consideraciones .............................................................................................. 19
Declarando instancias de clase con CreateObject ............................................................................... 19
Declarando instancias de clase con New ................................................................................................. 19
Declarando instancias de clase que generan eventos ........................................................................ 20
Terminar de usar una instancia de clase................................................................................................. 20
Conceptos de Late Binding y Early Binding ............................................................................................ 21
Late Binding (Vinculacin Tarda) ......................................................................... 21
Early Binding (Vinculacin Temprana) .................................................................. 21
Lab02: Usando la librera creada en Lab01 ................................................................................................. 22
Crear y generar eventos en la clases............................................................................................................. 24
Declaracin de eventos con la palabra reservada Event ................................................................... 24
Generar un evento declarado con la instruccin RaiseEvent ........................................................... 24
Declarar la variable de objeto con WithEvents ..................................................................................... 24
Amigos y Enumeraciones ................................................................................................................................... 25
Compartir informacin entre clases como amigos: Friend ............................................................... 25
Qu son Enumeraciones? ............................................................................................................................ 25
Cmo declarar y usar las enumeraciones ............................................................................................... 25
Lab03: Aadir Eventos y enumeraciones ..................................................................................................... 27
Interfases y polimorfismo .................................................................................................................................. 29
Interfases? ........................................................................................................................................................ 29
Desarrollando e implementando interfases en VB ............................................................................... 29

Pgina:2 de 66
 Definiendo la interfase. ...................................................................................... 29
Lab04: Interfases .................................................................................................................................................. 32
Controles de Usuario ............................................................................................................................................ 36
Introduccin: ..................................................................................................................................................... 36
Lab05: Creacin de un Control ActiveX (OCX) Paso a Paso .................................................................. 36
Para crear el proyecto ControlDemo ......................................................................................................... 36
Tiempos y vida de un objeto UserControl ............................................................................................... 41
Dibujar el control ShapeLabel ..................................................................................................................... 43
Guardar los valores de las propiedades del control ShapeLabel .................................................... 45
Dar una pgina de propiedades al control ShapeLabel ...................................................................... 48
Agregar un evento al control ShapeLabel ............................................................................................... 52
Compilar el componente ControlDemo .................................................................................................... 54
Temas de Programacin Avanzada ................................................................................................................. 56
Acceder a la API de Windows ...................................................................................................................... 56
Comprender la API de Windows ........................................................................... 56
Programacin Cliente/Servidor en Visual Basic utilizando el Control WinSock .............................. 59
Conceptos Bsicos de Programacin Cliente/Servidor ....................................................................... 59
Comenzando a Programar con el Control Winsock .............................................................................. 61
Protocolos TCP/IP y UDP ..................................................................................... 61
Propiedades, mtodos y eventos de WinSock. ....................................................... 61
Lista de propiedades ms importantes: ................................................................ 61
Ejemplo 1 ......................................................................................................... 62
Lista de Mtodos ms importantes ....................................................................... 62
Lista de Eventos ms importantes ....................................................................... 62
Programando la primera aplicacin Cliente/Servidor. .............................................. 62
Bibliografa ....................................................................................................... 66

Pgina:3 de 66
 Detalles de los Proyectos y de las Clases
Algunos de los diferentes proyectos que pueden realizarse dentro del ambiente de desarrollo
de Visual Basic 6.0 tiene diferentes caractersticas entre ellos y entre las clases que
contienen. Veamos detalles tericos de estas caractersticas:

Caractersticas generales de la ventana de dialogo de Propiedades de Proyecto

Standard EXE.
ActiveX EXE.
ActiveX DLL.
ActiveX Control.

Los detalles que se vern se observan en el ambiente de Visual Basic 6. Para ver
caractersticas particulares de un proyecto seleccione Propiedades de NombreDeProyecto...
del men Proyecto. Para ver las propiedades particulares de un mdulo de clase vea la
ventana de propiedades (F4) para cada mdulo de clase.

Caractersticas generales de la ventana de dialogo de Propiedades de Proyecto

Si observamos la imagen anterior podemos notar dos reas que en este caso nos interesa
recalcar en esta ocasin.

El Tipo de Proyecto nos dice el tipo de proyecto que estamos desarrollado en el cual
podemos escoger entre Standard Exe, ActiveX Exe, ActiveX Dll y ActiveX Control. Al escoger
en cada uno de ellos podemos observar algunas otras propiedades de esta ventana se
habilitan y otras se deshabilitan presentando diferentes opciones de configurar el proyecto.

El la seccin de Modelo de Subprocesos se pueden observar diferentes formas de

configuracin para el manejo de hilos de ejecucin dentro del proyecto dependiendo del tipo
de proyecto.

Standard EXE

Pgina:4 de 66
Al tener este tipo de proyecto crearemos una aplicacin stand-alone. Si observamos en la
imagen anterior podemos ver que no se tiene ningn modelo de hilos de ejecucin.Si
tenemos un mdulo de clase en el proyecto, podemos observar las siguientes propiedades
en la ventana de propiedades

Devuelve o establece si la clase

funcionar como un receptor de datos

Devuelve o establece si la clase

funcionar como un origen de datos

ActiveX EXE
Si seleccionamos que el tipo de proyecto, en la ventana de propiedades del proyecto, sea del
tipo ActiveX Exe, el modelo de hilo de ejecucin se habilita. (Ver Propiedades de Proyecto)

Subproceso por objeto: informa a VB a crear un nuevo hilo(subproceso) para cada

peticin de CreateObject de las clases marcadas como MultiUse. Cada hilo tiene una
nica copia de todas las variables globales y objetos, y no interfieren con ningn otro
hilo. Se recomienda un nmero pequeo de Clientes/Objetos porque proporciona a
cada cliente con un hilo dedicado en el servidor que existe exclusivamente para
servir las necesidades de ese cliente. Caso contrario, para una gran cantidad de
Clientes/Objetos causa que el servidor consuma una gran cantidad de recursos y
causara un rendimiento bajo.

Conjunto de N subprocesos: reduce el nmero de hilos que consume un proceso

de servidor sencillo. En esta opcin se determinan el nmero mximo de hilos que se
crearan para servir a nuevos objetos. Mientras los objetos creados estn bajo este
numero esta opcin funcionara como Subproceso por objeto, cuando supere la
cantidad asignada VB comienza a asignar las peticiones a hilos existentes. Esto
significa que varios clientes pueden compartir hilo, lo cual es bueno porque consume
menos recursos y malo porque un cliente podra bloquear a otro. Si al cantidad de
hilos a crear es igual a uno, entonces coloca el cdigo en modo compatible con VB4
al manejar los objetos a residir en el hilo principal del proceso del servidor ActiveX
Exe.

Al tener este tipo de proyecto las lista de propiedades para un mdulo de clase se vera as:

(Ver pgina siguiente)

Pgina:5 de 66
La propiedad mas importante de esta lista es la propiedad Instancing, la cual nos indica la
forma de crear instancias de la clase fuera del proyecto y si es as como se comportara. Las
opciones que se muestran son:

1. Prvate: No se permite el acceso a otras aplicaciones sobre la informacin de la

librera de tipos y no podr instanciarlo. Estos objetos solo se usan internamente
dentro del componente que contiene la clase.

2. PublicNotCreatable: Otras aplicaciones pueden hacer uso de esta clase solo si es

creado el objeto primero por el componente que contiene la clase. No se requiere el
uso de CreateObject o New debido a que el objeto ya fue creado e inicializado por el
componente que lo contiene. Por ejemplo, teniendo referenciado dentro del proyecto
el componente de DAO 3.5, podemos utilizar el mtodo OpenDatabase (set dbname
= OpenDatabase...) sin tener que utilizar una referencia de un objeto especifico que
exponga el DAO tal como lo hace OpenRecordset (Set rsname =
dbname.OpenRecordset...) el cual requiere de un objeto tipo DataBase.

3. SingleUse: permite crear objetos de la clase pero cada objeto creado de esta clase
crea una nueva instancia de tu componente. No permitido en proyectos de tipo
ActiveX DLL. Por ejemplo, en MS Excel por cada instancia a este componente se
ejecuta Excel en forma separado (en la barra de tarea tendriamos dos icono para
cada instancia).

4. GlobalSingleUse: Igual al anterior, excepto que las propiedades y mtodos de la

clase pueden ser invocadas como si fueran simples funciones globales. No permitido
en proyectos de tipo ActiveX DLL.

5. MultiUse: permite crear objetos de la clase. Una instancia de tu componente

proporciona cualquier nmero de objetos creados de esta manera. Por ejemplo, en
versiones anteriores de MS Word para Windows 95 por cada instancia a este
componente se ejecuta Word solo una vez (en la barra de tarea tendriamos solo un
icono soportando multiple clientes); de la versin de Windows 95, inclusive, a la de
Office 97 se comporta como SingleUse, ver arriba.

6. GlobalMultiUse: Igual al anterior, con una aadidura: propiedades y mtodos de la

clase pueden ser invocados como si fueran simples funciones globales. No es
necesario que explcitamente creamos una instancia de la clase porque uno ser
creado de forma automtica.

La propiedad DataBindingBehavior permite especificar si la clase funcionar como un

receptor de datos.

La propiedad Persistable, Establece un valor que determina si un objeto puede guardar y

restaurar datos entre varias instancias. Slo puede establecerse en tiempo de diseo.

ActiveX DLL
Si seleccionamos que el tipo de proyecto, en la ventana de propiedades del proyecto, sea del
tipo ActiveX Dll, el modelo de hilo de ejecucin se habilita de la siguiente forma

Pgina:6 de 66
 Subproceso nico: pone el cdigo en modo de compatibilidad con versiones
antiguas y forza a los objetos creados a residir en el hilo principal (STA: Single
Threaded Apartment) del proceso del cliente. Si el cliente trata de crear uno de los
objetos desde cualquier otro hilo o apartamento, COM automticamente regresara
una representacin o agente (proxy) al invocador. Esto asegura que todo acceso al
los objetos son serializados hacia el hilo principal. Esto puede impactar el
rendimiento debido a que se requieren de dos cambios de hilo para cada llamada a
un mtodo.

Subprocesos independientes: De esta forma VB6 aade la entrada

ThreadingModel=Apartment para cada clase que la librera DLL exporta. Esto le
indica a COM que se adelante y para crear los objetos dentro del hilo o departamento
del invocador, proporcionando que el hilo invocador no se ejecute dentro de un
departamento multihilo (MTA: Multithreaded Apartment) en el proceso.

Al tener este tipo de proyecto las lista de propiedades para un mdulo de clase se vera as:

Con respecto a un proyecto de tipo ActiveX Exe, aqu solo tenemos 4 de las seis opciones
para la propiedad de clase Instancing. Estos cuatro son los siguientes:

Private: lea arriba en el proyecto de tipo ActiveX Exe para la descripcin de esta
opcin.

PublicNotCreatable: lea arriba en el proyecto de tipo ActiveX Exe para la

descripcin de esta opcin.

MultiUse: lea arriba en el proyecto de tipo ActiveX Exe para la descripcin de esta
opcin.

GlobalMultiUse: lea arriba en el proyecto de tipo ActiveX Exe para la descripcin de

esta opcin.

ActiveX Control
El modelo de hilo de la ventana de propiedades para este tipo de
proyecto es igual al tipo de proyecto ActiveX DLL:

Pgina:7 de 66
Lea en la seccin anterior detalles sobre el modelo de subprocesos de un Control ActiveX

En este tipo de proyecto se habilita otra opcin dentro de la ventana de propiedades del
proyecto:

Esta opcin habilita el licenciamiento para un proyecto que produce componentes ActiveX
(servidores de automatizacin, controles de usuario o controles ActiveX). Solo se aplica a
este tipo de proyecto. Habilitada esta opcin, VB crear un archivo de licencia (*.vbl) que
deber ser registrada en la maquina del usuario para los componentes a ser usados en el
ambiente de diseo. El programa Aistente para empaquetado y distribucin construir
un programa setup que registrara apropiadamente la informacin en el *.vbl en la maquina
del usuario final.

Al tener este tipo de proyecto las lista de propiedades para un mdulo de clase se vera as:

Con respecto a un proyecto de tipo ActiveX Exe, tenemos las mismas opciones en la
propiedad Instancing, para mayor informacion consulte en la seccin ActiveX Exe

Pgina:8 de 66
Caractersticas generales de la programacin
orientada a objetos.
Visual Basic tiene su propia manera de implementar la programacin orientada a objetos tal
como otra muchas cosas dentro de este ambiente. Programadores puros argumentan que
Visual Basic no es un lenguaje orientado a objetos, sino a eventos, debido a que no soporta
al 100% los tres pilares de este concepto:

Encapsulacin.
Reusabilidad (herencia).
Polimorfismo.

Encapsulacin

Significa simplemente agrupar o contener juntas todas las variables y rutinas relacionadas
con el objeto. Permitiendo mantener interno al objeto algunas de estas variables y rutinas y
exponiendo otras fuera de l.

Muchos de los problemas respecto ha constantes pblicas han sido arreglados por el estatuto
Enum en la versin 5 de Visual Basic, tambin puedes establecer una propiedad o mtodo
como default y crear colecciones (aunque sigue siendo difcil de codificar). Los
procedimientos Property dan a Visual Basic una ventaja sobre C++ y muchos otros lenguajes
orientados a objetos en el sentido de que permiten acceso a datos mediante una sintaxis
natural y sin exponer datos internos a cambios no autorizados.

Pero an se atrasa respecto a otros lenguajes, en la manera que permite compartir datos
entre clases y entre instancias de la misma clase. El nuevo modificador Friend permite
compartir datos entre clases permitiendo especificar exactamente lo que quieres compartir
con otras clases, pero no permite especificar con quin compartir datos dentro de un
proyecto.

Visual Basic no proporciona caractersticas de lenguaje para compartir datos entre instancias
de un objeto (variables estticas en C++), esto se puede simular con variable pblicas
dentro de mdulos estndar. Los miembros amigos y variable pblicas en mdulos estndar
dentro del proyecto llegan a ser invisibles a los clientes fuera del componente, por lo que hay
alguna proteccin.

El gran problema de encapsulacin en Visual Basic, es su inhabilidad de inicializar un objeto

en su declaracin. Este es un gran problema con controles, los cuales contienen Pginas de
Propiedades en su mecanismo de inicializacin.

Porcentaje: 80 %

Ejemplo grfico:

En la dibujo anterior son pblicos al programa (el objeto expone) los mtodos Abrir, Cerrar,
Crear y borrar y las propiedades Color y Contorno. Y son privadas al objeto los

Pgina:9 de 66
procedimientos Abrir-ventana, Abrir_puerta y la variable Color_puerta. Y cada uno de estos
mtodos, propiedades, procedimientos y variables estn encapsuladas en un objeto.

Para ejemplificar las enumeraciones que nos proporciona el estatuto Enum, veamos el dibujo
anterior. Podramos declarar una enumeracin global en la que definamos los colores
permitidos para la propiedad Color. Esto es, podamos definir las constantes cteAzul, cteRojo
y cteVerde para los colores Azul, Rojo y Verde, respectivamente.

Reusabilidad (herencia)
Significa ser capaz de crear una nueva clase que usa caractersticas de una clase existente
sin recodificar esas caractersticas. Significa usar cdigo en una estructura jerrquica. Visual
Basic no lo tiene.

La manera de obtener Reusabilidad en Visual Basic es a travs de un proceso llamado

Delegacin.

Hay dos clases de relaciones de reuso:

Relacin es-un: Una clase es una versin mejorada de otra clase, definida con
herencia.
Relacin tiene-un: Una clase tiene caractersticas de otra clase, definida con
delegacin.

Debido a que Visual Basic no soporta herencia, forza a definir ambos estilos de relaciones
con delegacin. Modelar una relacin es-un usando herencia solo necesitas escribir cdigo
para las nuevas caractersticas, usando delegacin necesitas delegar todo, an los mtodos y
propiedades que no cambian. Este proceso mecnico parece ser automatizado, y de hecho,
Visual Basic lo automatiza, pero este slo funciona para controles no para clases.

COM soporta una tercera tcnica de reuso llamada agregacin, significa combinar varios
objetos internos de tal manera que parezcan ser parte de un objeto externo. Esta es una
organizacin colectiva en lugar de una organizacin jerrquica. Visual Basic no soporta esta
caracterstica pero algunas ventajas de esta pueden obtenerse con el nuevo estatuto
Implements.

Porcentaje: 40 %

Ejemplo:

Una clase llamada ventana (clase base) puede estar contenida en otra clase llamada
departamento y en otra llamada cuarto, etc. sin tener que recodificar la clase. La clase o
clases que contienen ventana pueden mejorar las caractersticas de esta y completarla con la
clase que encapsula.

Polimorfismo

Significa que cualquier objeto puede ser capaz de hacer lo correcto si recibe un mensaje que
entienda.

Visual Basic soporta Polimorfismo de dos maneras. Primero, se logra Polimorfismo usando el
tipo Object, pero debe evitarse porque es muy lento y no tiene proteccin de tipo (Late
binding) por otro lado, hay ocasiones en la que excesiva proteccin de tipo se obtiene en el
camino y donde la velocidad no es critica.

En muchas ocasiones es mejor usar interfaces a travs del nuevo estatuto Implements para
obtener velocidad. La sintaxis para Implements hace que trabaje al estilo de los eventos.
Implements habilita una cantidad de nuevas tcnicas. Es casi una implementacin directa del
poderoso concepto COM de interfaces. Desafortunadamente, algunas de las ventajas de usar
interfaces COM se eliminan debido a que Visual Basic no soporta los tipos usados en varias
interfaces COM estndar.

Pgina:10 de 66
En muchos lenguajes orientados a objetos, Polimorfismo va mano a mano con herencia.

Porcentaje: 70 %

Ejemplo:

Ambas clases, revista y la clase libro, contienen un mtodo llamado Abrir pero su
implementacin es diferente respecto una de otra. A pesar que el mismo termino es aplicado
a ambos tu sabes la accin correcta a ejecutar

Descripcin de las clases

Los diferentes proyectos que soporta Visual Basic, de los cuales hemos hablado
anteriormente, soportan los mdulos de clase con diferentes caractersticas de configuracin
para cada uno de ellos: vea la propiedad Instancing.

En esta seccin aprenderemos acerca de:

Qu es una clase o mdulo de clase?

Eventos del mdulo de clase: Initialize y Terminate.
Diferencias con los mdulos estndar.

Qu es una clase o mdulo de clase?

Es una plantilla para la creacin de objetos.

Es el molde que nos servir para definir todas las propiedades y mtodos, tanto
privados como pblicos, que deseamos que nuestro objeto final posea. Definir todas
las caractersticas que quisieramos que nuestro objeto final tuviera.

Por ejemplo: podemos tener una clase llamada clsEmpleados en el cual deseamos
tener todas las caractersticas con respecto a un empleado. Como propiedades
podriamos definir: nombre, apellidos, domicilio, edad, casado, sueldo, fechaIngreso,
Antiguedad, etc. Como mtodos podriamos tener: ActualizarDatos o GuardarCambios
(donde cambios a las propiedades anteriores se grabaran fisicamente en una base de
datos), ValidarDatos (donde se valida los datos siempre y cuando haya habido
cambios en las propiedades segun una variable privada Cambios).

Las propiedades fechaIngreso y Antiguedad son de slo lectura. Antiguedad se

actualiza al instanciar esta clase mediante la funcin privada Calcula_Antiguedad que
contiene la clase, esta funcin se llama dentro del evento de clase Inicialize.

Es parecido a los tipos definidos por el usuario (UDT).

Los tipos definidos por el usuario son agreados de otro tipos, esto es contiene
miembros que pueden ser de diferentes tipos (integer, string, etc.), as las clases
tambin concentra diferentes tipos en sus miembros pero la sintaxis es muy
diferente.

Una clase es un UDT que actua, hace algo.

En VB los mdulos de clase tiene mayor parecido a las formas o formularios.

Por ejemplo: En VB para definir un tipo se logra de la siguiente forma:

Type tEmpleado
Nombre as string
Edad as Integer
End Type

Pgina:11 de 66
 Dim Empleado As tEmpleado
Empleado.Nombre = "Juan Perez"
Empleado.Edad = 25

La variable Empleado se refiere a una instancia de tEmpleado que contiene "Juan

Perez" en el miembro Nombre y "25" en el Edad.

Cada mdulo define un tipo de objeto.

En el momento de instanciar una clase mediante New o CreateObject estamos

creando un objeto especifico. Esto es, podemos tener varios mdulos de clase para
Empleado, Empresa, Venta, ect. y cada uno de ellos define un objeto al momento de
instanciar alguno de ellos.

En ejecucin creas una instacia (o objeto) de la clase.

Los objetos son creados en tiempo de ejecucin con los estatutos New o
CreateObject. En tiempo de diseo los utilizas los mdulos de clase para crear las
caracteristicas especificas del objeto.

No tiene interfase de usuario.

Los mdulos de clase no presentan una interfaz grfica al desarrollados tal y como lo
hacen las formas o formularios. En los formularios puedes colocar visualmente un
botn, una lista, un texto, etc. Los mdulos de clase solo contiene cdigo que definen
las caracteristicas del objeto.
Si se desea presentar una ventana informativa (como un Acerca de) u otro
formulario, este puede pertenecer a un proyecto ActiveX DLL y mandarlo llamar
mediante un mtodo (como MostraAcercaDe) que expone alguna clase dentro del
proyecto.

Se pueden crear mltiples instacias en ejecucin.

De acuerdo a la configuracin de las propiedades de la clase se pueden crear varias

instancias u objetos de una misma clase. Esto es, la propiedad Instancing de un
mdulo de clase indica como se trataran los objetos creados utilizando un mdulo de
clase determinado. Tenemos la opcinde que sea una clase Privada lo cual significa
que no se puede instanciar directamente por otro programa, solo el proyecto ActiveX
DLL o ActiveX Exe que lo contiene una copia u objeto de este tipo de clase.

Proporciona mtodos y propiedades.

Algo esencial para definir las caracteristicas y el comportamiento de nuestro objeto a

crear con un modulo de clase es definiendo mtodos y propiedades a exponer o no.

Eventos de un mdulo de clase: Initialize y Terminate

Los mdulos de clase presenta dos eventos:

1. Initialize: ocurre cuando se crea una instancia de una clase. Se usa, generalmente
para inicializar cualquier dato usado por la instancia de una clase en el cdigo.

2. Terminate: ocurre cuando toda referencia a una instancia de una clase son
removidas de memoria al establecer todas las variables que la refieren a un objeto a
Nothing o cuando la ultima referencia al el objeto se encuentra fuera de alcance.
Usado generalmente para limpiar la memoria de objetos creados dentro de esta
instancia y generar un error si hay alguna anomala o guardar alguna informacin del
objeto, etc.

Pgina:12 de 66
Diferencias con los mdulos estndar

Deben ser creadas explcitamente (crear instancia) antes de usarlas.

No se puede utilizar el mtodo o la propiedad de una clase si no se tiene una

instancia de la misma o una referencia al componente que la contiene si la clase esta
configurada como Instancing = PublicNoCreatable. Por ejemplo, de la primera forma
no podemos utilizar OpenRecordset sin una instancia de un objeto Database; de la
segunda forma, no podemos utilizar OpenDatabase sin una referencia al componente
que la contiene que es DAO 3.5.

Puedes crear mltiples instancias de la clase.

Si las clases estn configuradas en la propiedad Instancing como SingleUse,

GlobalSingleUse, MultiUse o GlobalMultiUse.

Propiedades y mtodos

Para poder definir las caractersticas del objeto a crear se requieren de tres elementos
esenciales: mtodos, propiedades y eventos. En esta seccin se vern los dos primeros.

Propiedades como variables pblicas.

Propiedades como procedimientos Property.
Tipos de propiedades Property.
Mtodos.
Procedimientos vs. Mtodos.
Alcance de las propiedades y mtodos.

Propiedades como variables pblicas

Las variables declaradas como pblicas en mdulos de clase se convierten en propiedades
de la clase.

Ejemplo: Public sNombre As String

Declararlas de esta manera tiene sus limitaciones:

No se tiene control sobre la misma: si es de slo lectura, o de escritura o ambas.

Declaradas de esta forma la propiedad es de lectura y escritura.
No permite tener una validacin previa o ejecutar un procedimiento antes de
actualizar la propiedad.
No permite generar un error o evento como parte del cdigo de validacin o cambio
de valor de la propiedad.
No permite limitar la propiedad a un grupo de posibles valores.
No apareceran en el Object Browser (F2) en versiones anteriores a VB6.
No pueden proporcionar ayuda sensible al contexto en versiones anteriores a VB6.
Para eliminar estas limitaciones (sobre todo las cuatro primeras en la versin 5 y 6
de Visual Basic) se utilizan los procedimientos Property.

Propiedades como procedimientos Property

Utilizando la clusula Property, para definir las propiedades de la clase, varias de las
limitaciones de crear variables pblicas se eliminan.
Detallemos cmo se eliminan las limitaciones de las propiedades declaradas como variables
pblicas:
Control sobre la propiedad: si es de slo lectura, o de escritura o ambas.
En procedimientos Property se tienen tres diferentes tipos de procedimientos
Property como se vera abajo: Get, Let y Set. Si se declara una propiedad como Get

Pgina:13 de 66
 nada mas, esta es de slo lectura; si ademas se declara como Let la propiedad se
convierte de lectura y escritura.
Validacin previa, ejecutar un procedimiento antes de actualizar la
propiedad y/o generar un error o evento.
Debido a la similitud que existe entre un mtodo o procedimiento con los
procedimientos Property, dentro de la declaracin de la misma se puede aadir
cdigo para realizar una validacin, desplegar un mensaje o una ventana de dilogo,
generar un evento o un error como parte de la validacin o de cambio de valor de la
propiedad.
Limitar la propiedad a un grupo de posibles valores.
Debido a que se puede tener cdigo, ver arriba, dentro de la definicin de la
propiedad se pueden tener validaciones en la propiedad Let para validar el valor a
asignar a la propiedad o utilizar las enumeraciones para limitar la propiedad a ciertos
valores posibles.
Uso del Examinador de Objetos (F2) para observar las propiedades y
mtodos que ofrece la clase.
En versiones anteriores a VB5 las propiedades declaradas como procedimientos
Property se observaban dentro de Examinador de Objetos (Object Browser) para
obtener una referencia rapida sobre una propiedad o metodo.
Proporcionar ayuda sensible al contexto, definida dentro del Examinador de
Objetos (F2).
En la declaracin de la clase, el Navegador de Objetos nos servira entre otras cosas
para asignar una pequea descripcin para cada una de las propiedades y mtodos
que declaremos como publicas dentro de la clase, permitira definir una ayuda de
contexto, declarar un metodo o propiedad como default, esconder metodos o
propiedades entre otras cosas.

Tipos de propiedades Property

Existen tres tipos de procedimientos Property que nos serviran para declarar las
propiedades como de solo lectura, solo escritura o de lectura y escritura.

Observemos que la definicin de una propiedad en VB, mediante procedimientos Property, se

parecen en mucho a un procedimiento tradicional al programador, pero trabaja como una
variable al usuario del objeto o de la clase.

Property Get: lectura, para obtener el valor de una variables de tipo de dato
standard o regresar la referencia a un objeto.

Sintaxis:

Property Get NombrePropiedad([ListaArgumentos]) As tipodato

'Cdigo
End Property

Uso:

Label1.Caption = NombreObjeto.NombrePropiedad

Ejemplo:

Private psNombre as String

Public Property Get Nombre() as String
Nombre = psNombre
End Property

Property Let: Escritura, para establecer o cambiar el valor de una variables de tipo
de dato standard.

Pgina:14 de 66
 Sintaxis:

Property Let NombrePropiedad([ListaArgumentos], NombreValor As tipodato)

'Cdigo
End Property

Uso:
NombreObjeto.NombrePropiedad = Text1.Text

Ejemplo:

Private psNombre as String

Public Property Let Nombre(Valor as String)
psNombre = Valor
End Property

Property Set: Escritura, para establecer o cambiar la referencia de una variable de

tipo objeto.

Sintaxis:

Property Set NombrePropiedad([ListaArgumentos], Referencia)

'Cdigo
End Property

Referencia es, como su nombre indica, un apuntador o referencia de objeto usado en

la parte derecha de la asignacin de referencias.

Uso:

Set nombreobjeto.nombrepropiedad = miobjeto

Ejemplo:

Private poEmpleado as clsEmpelado

Public Property Set RefEmpleado(ObjEmpleado as clsEmpelado)
Set poEmpleado = ObjEmpleado
End Property

Mtodos

Para crear mtodos de una clase es muy sencillo lo unico que se necesita es declarar
aquellos procedimientos o funciones que se desean compartir como pblicos, vea anajo. Al
igual que las propiedades apareceran en el Object Browser y mediante este definir una
pequea descripcin para cada mtodo expuesto por la clase, adems de asignarle un
nmero de contexto de ayuda.

Ejemplo:
Public Sub Calcula_Costo(Porcentaje As Single)
'Cdigo
End Sub

Public Function Calcula_Desviacion(Valor as Single) as Boolean

'Cdigo
End Function

Procedimientos vs. Mtodos

Pgina:15 de 66
Si hemos observado hasta ahora, las propiedade se parecen a un procedimiento tradicional y
los mtodos igual observados por el programador, pero para el usuario de la clase o objeto a
crear son distintos.

Con respecto al uso de las palabra procedimiento y mtodo hay quienes dicen que la
dicerencia es el alcance de las mismas dentro de la definicin de las mismas dentro de la
clases. Esto es, todo aquello procedimientos o funciones que expone la clase al cliente se
llaman Mtodos, todos aquellos procedimientos que no son expuestos por la clase se llaman
Procedimientos.

Ahora, observemos que en la programacin funcional tradicional se llama a un procedimiento

indicando lo que se necesita hacer y se le pasan argumentos para indicar que se quiere
hacer:

HazEsto AEso, ConEstos

En la programacin Orientada a Objetos se indica en lo se quiere trabajar y posteriormente

los mtodos para indicar lo que se quiere hacer:

AEsto.HazEso ConEstos

Alcance de las propiedades y mtodos

En las definiciones de las propiedades y mtodos de una clase, como ya hemos visto en el
caso de los mtodos, se puede anteponer las siguietes clausulas para limitar o expander su
alcance fuera de la clase que los contiene:

[Public | Private | Static] [Friend] Property [Get | Let | Set] nombreVar(...

Public: Indica que la propiedad o metodo a definir es accesible a todos los demas
procedimientos en todos los mdulos. En mdulos de clase es lo que se expone a la
hora de crear el objeto.
Private: Indica que la propiedad o mtodo es accesible solo a otros procedimientos
en el mdulo donde es declarado. En un mdulo de clase, las propiedades creadas
con este prefijo solo seran accesible a todos lo miembros (propiedades y metodos,
etc.) de este mdulo de clase.
Static:
Friend: Esta prefijo es slo usado en mdulos de clase. Indica que la propiedad o
mtodo a definir es visible o accesible a traves del proyecto que la contiene, pero no
es visible a un controlador de una instancia de un objeto. Esto es, solo podra ser
accesado por ActiveX DLL o EXE que contiene la definicin de la(s) clase(s) que
contiene un metodo(s) o propiedad(es) con prefijo Friend.
El prefijo default es Public. Esto es, si no se especifica el prefijo en la definicin de la
propiedad o metodo a definir dentro de la clase, este ser pblico.

El prefijo default es Public. Esto es, si no se especifica el prefijo en la definicin de la

propiedad o metodo a definir dentro de la clase, este ser pblico.

Ejemplo:

Declarar Sub Calcula() es igual a declarar Public Sub Calcula(). Esto puede ser observado en
el Object Browser, si se declara de la primera forma en el Navegador de Objetos se vera que
se le antepone Public a la definicin.

Pgina:16 de 66
Lab01: Diseando una Clase con propiedades y
mtodos
Duracin: 40 min. aprox

Descripcin General:

Iniciar un proyecto ejemplo: mtodos y propiedades

En esta seccin de practica empezaremos a definir las primeras propiedades y mtodos

donde mantengamos las caractersticas esenciales de un empleado.

En esta practica se requiere de una instancia de Visual Basic.

Para guardar sus proyectos, hagalo en su disco duro local creando la siguiente estructura

Disco Duro (C:)

VBAvanzado

PracticaGuiada01

Dentro de la carpeta VBAvanzado deber crear UNA CARPETA por cada Proyecto que
realicemos.

DESCRIPCION DE PASOS A EJECUTAR

1. Ejecute Visual Basic 6.

2. En la ventana de dialogo que aparece, seleccione un nuevo

proyecto de ActiveX DLL . Esto creara un nuevo proyecto de tipo
ActiveX DLL dentro del cual ya presenta un mdulo de clase lista
para llenarse.

3. Ahora, seleccione Agregar Proyecto del men Archivo y seleccione

un proyecto de tipo Standard Exe . Esto aadir un nuevo proyecto
a nuestro grupo de trabajo, en este caso de tipo Standard Exe
dentro del cual ya presenta una forma o formulario listo para
llenarse.

4. Es el momento de salvar nuestro proyectos y grupo de proyectos. Al mdulo de clase

llmelo clsEmpleado.cls, al proyecto de ActiveX DLL llmelo stdLib32.vbp, a la forma
llmelo CatEmpleado.frm al proyecto de Standard Exe llmelo SysEmp.vbp y
finalmente al grupo de proyectos llmelo Curso.vbg. De aqu en adelante guarde sus
proyectos en tiempos razonables para impedir perdidas de informacin por alguna
falla de luz o accidente.

5. De igual forma vamos a nombrar a los mdulos de nuestros proyectos. Seleccione,

del Project Explorer (Ctrl-R) seleccione a Project1 (stdLib32.vbp) y de la ventana de
propiedades (F4) cambie su nombre a stdLib32 en la propiedad Name. De igual
forma seleccionemos Class1 (clsEmpleado.cls), Project2 (SysEmp.vbp) y Form1
(CatEmpleado.frm) y nombrmosle, respectivamente, clsEmpleado, SysEmp y
frmCatEmpleado.

6. Observe las propiedades del mdulo de clase. Deseamos que esta clase pueda ser
instanciada las veces que se quiera y a peticin del cliente. Cmo lo declarar?
Observe la seccin ActiveX Exe las opciones para la propiedad Instancing.

Pgina:17 de 66
En el mdulo de clase declare las siguientes propiedades cmo pblicas (L: Lectura;
E:Escritura):
Nombre: Cadena (L/E)

Apellidos: Cadena (L/E)

Edad: Entero (L/E)

Sexo: integer (L/E); 0: Femenino, otro: Masculino

FechaIngreso: Fecha (L/E)

Antiguedad: Integer (L)

Sueldo: Moneda (L)

Tambin declare los siguientes mtodos:
Aumentar_Sueldo: en el que se recibe como argumento el porcentaje a aumentar y
regresan True si fue posible actualizar el sueldo o no. Se aumenta si el sueldo actual
es mayor o igual a 1000 (mil).

Disminuir_Sueldo: en el que se recibe como argumento el porcentaje a disminuir y

regresan True si fue posible actualizar el sueldo o no. Se disminuye si el sueldo es
mayor a 0 (cero).
Adems de declarar estos mtodos y propiedades, codifiquelos. Para las propiedades basese
en lo que se vi en Tipos de propiedades. Tambin al momento que sea inicializado la clase
para crear un objeto, inicialice el sueldo a 1000 (mil) pesos y la fecha de ingreso a la actual
del sistema en el evento Initialize de la clase, como se vio en Eventos de un mdulo de
clase.

En esta practica es todo lo que se va a disear. Guarde su proyecto o grupo de proyectos.

Quizs este sea el momento para resolver algunas dudas con el instructor o continuar, si aun
dispone de tiempo, en Visual Basic para observar algunas otras caracter sticas o funciones.
Por ejemplo, puede observar el Examinador de Objetos (F2) para ver si es posible ver la
clase que gener en el proyecto y ver los metodos y propiedades que a creado y si estas son
de lectura/escritura o de slo lectura. Si no lo a probado, en este momento puede checar los
caractersticas para cada proyecto y las clases.

Esta prctica debe desarrollarse conjuntamente con el Instructor

Pgina:18 de 66
 Creacin de objetos y otras consideraciones
En esta seccin se enfoca en la creacin de los objetos o instanciacin de las clases y otras
consideraciones a tomar en cuenta en cuanto el manejo de los proyectos ActiveX Exe o Dll
para el proceso de depuracin.

Declarando instancias de clase con CreateObject.

Declarando instancias de clase.
Declarando instancias de clase que generan eventos.
Terminar de usar una instancia de clase.
Conceptos de Late Binding y Early Binding.

Declarando instancias de clase con CreateObject

Requieres de crear en tiempo de ejecucin la conexin a la clase mediante CreateObject
debido a que no se conoce el nombre de la clase o aun si se conociera no se puede utilizar en
VB en tiempo de diseo sin una libreria de tipo (type library). Para esto, necesitas conocer la
cadena ProgID proporcionada por el proveedor. ProgID consiste en el nombre del sservidor
de la aplicacin seguido por un punto y el nombre de la clase.

Para realizar la declaracin e instanciacin se requiere de una variable de tipo Object y

utilizar la instruccin CreateObject como sigue:

Dim nombreVar As Object

set nombreVar = CreateObject(ProgID)

Por ejemplo: En versiones anteriores a la 95 de Office, esto es lo que se tenia que hacer para
lograr una comunicacin OLE con Word.

Dim appWord As Object

Set appWord = CreateObject("Word.WordBasic")

Declarando instancias de clase con New

Las instacia de clase son llamadas usualmente Objetos. Para declarar una instacia de clase
se debera utilizar una variable del tipo de la clase que deseamos instanciar y utilizar la
clausula New para generar la instacia u objeto.

Dim Empleado as clsEmpleado

Set Empleado = New clsEmpleado

La razn de usar New es porque con las instancias de clase, la variable no es lo mismo que la
instancia. La variable es el nico medio de comunicacin con la instancia. Las variables de
clase con tambin llamados variables de objeto y las instancias son llamados Objetos.

Existen dos formas de instanciar las variables de objeto mediante la clausula New:

Declarar la variable de objeto y posteriormente utilizar Set... New para instanciar la clase.
Un ejemplo de este caso es como se manejo arriba.

Dim VariableObjeto As NombreClase

Set VariableObjeto = New NombreClase

Pgina:19 de 66
Esta es la forma ms recomendablesi se desea tener el control sobre la instancia de la
variable: cuando debo crearlo, usarlo, terminarlo, volverlo a crear... etc.

Instanciar la variable de objeto en la misma declaracin de sta como As New.

Dim VariableObjeto As New NombreClase

De esta forma a la hora que entre al modulo o procedimiento que la contiene se generara
automticamente la instanciacin de la clase.

Se tiene menos control sobre la instanciacin de la clase; estos sin poder determinar el
momento en que deseamos que nuestra variable de objeto se instanciado. Podermos
terminar la instanciacin utilizando Set... = Nothing.

Se recomienda el uso de esta solo para variables de objeto temporales dentro de un

procedimiento o funcin, pero para uso mas confiable o tener mayor control sobre en que
momento deseo instanciar mi clase es mejor de la primera forma.

Declarando instancias de clase que generan eventos

Si la clase que se va a instanciar genera eventos y se desea atrapar estos eventos para
codificarlo, entonces declare la variable de objeto insertando WithEvent entre la clausula Dim
y el nombre de la variable:

Dim WithEvents Empleado As [New] clsEmpleado

Para atrapar el evento o eventos que genera la clase a instanciar escriba un procedimiento
que se llame segun el nombre de la variable de objeto y el nombre del evento a atrapar
insertando entre los dos un caracter underscore ('_').

Private Sub Empleado_Cambio([listaArgumentos])

'Cdigo del evento

End Sub

Si observa lo anterior se ve el parecido con los eventos de cualquier control, solo que aqui
hay que codificarlo y en el caso de los controles el ambiente de Visual Basic te los presenta
en una lista.

Se puede observar con el Objet Browser las propiedades, metodos y eventos que la clase
esta exportando.

Terminar de usar una instancia de clase

Para terminar una instancia de clase o objeto, independientemente de como haya declarado
la variable de objeto, es muy sencillo. Solo deber establecer la variable de objeto a Nothing.
Esto generar que el evento Terminate se genere dentro de la clase que estamos
instanciando con la variable de objeto.

Set Empleado = Nothing

Posterior a esto y de acuerdo a alguna otra accin o vento del usuario se puede volver a
instanciar esta variable de objeto mediante Set.. New (vea arriba).

Pgina:20 de 66
Se recomienda terminar el objeto si ya no se esta usando para poder liberar recursos del
sistema, adems de asegurarse de que se esta liberando recursos al momento de salir, por
ejemplo, si un procedimiento contiene la declaracin y uso de la variable de objeto (se
supone que al perderse el alcance de cualquier variable se termina su uso) puede asegurarse
que realmente se termine este objeto.

Conceptos de Late Binding y Early Binding

Late Binding (Vinculacin Tarda)
Significa que la variable de objeto es conectado a la clase en tiempo de ejecucin.
Esto es malo. Debido a que no se tiene una libreria de clase se tiene que utilizar este
mtodo. Se utiliza la instruccin CreateObject para lograr la coneccin a la clase.
Cuando, en cdigo y despues de lograr la coneccin a la clase, haces referencia a un
mtodo con argumentos VB requiere de buscar el mtodo por nombre en la tabla de
datos de la clase y requiere de pasar los argumentos en tipo Variant (siendo o no los
parmetro de tipo Variant) y hacer otras varias cosas que consumen tiempo para
obtener todo lo necesario. Lo cual hace ms lenta la comunicacin con el servidor. VB
utiliza una interface COM llamada IDispatch para realizar realizar todo lo anterior.
Lo anterior no significa que IDispatch sea malo en general. Este se requiere para
VBScript y otros ambientes que siempre realizan late binding.

Early Binding (Vinculacin Temprana)

Significa que la variable de objeto se conecta a la clase en tiempo de compilacin
mediante una librera de clase. Esto es bueno. Se utiliza New para lograr la conexin
a la clase.
La librera de tipo utilizada para la coneccin a la clase se referencia con la vantana
de dialogo que aparece al seleccionar References en el men Project de VB. Cuando
la aplicacin es compilada, VB busca, en su librerias de clase activas, las referencias
hechas en cdigo.
La librera de clase es esencialmente una tabla con offsets a las direcciones de cada
propiedad y mtodo. Por eso es llamado vtable (Tabla virtual). Esto hace ms rapida
la conexin y la comunicacin con el servidor ActiveX.

Pgina:21 de 66
 Lab02: Usando la librera creada en Lab01
Proyecto ejemplo: uso de nuestra librera

Ahora empezaremos a usar la librera declarar en la primera parctica en el proyeto de tipo

Standard Exe que tambien fue definido.

Si no tiene abierto el grupo de proyecto que se guard en la practica anterior, es tiempo de

abrirla en este momento. Recuerde que el grupo de proyecto se encargar de cargar ambos
proyectos grabados en la primera practica.

En esta seccin trabajaremos en el proyecto Standard Exe definido anteriormente.

Primero necesitamos realizar la referencia a nuestra libreria dll diseada en la

seccin anterior. Recuerde que teniendo abierto ambos proyectos, VB en tiempo de
diseo registra el servidor dll en windows por lo que lo podra referenciar.
Abra la ventana de referencias (Referencias del menu Proyecto) y seleccione nuestra
librera. Esta debe llamarse Stdlib32 en la ventana de dialogo que aparece (a menos
que se haya dado una descripcin de proyecto en las propiedades del proyecto
ActiveX Dll para Stdlib.dll), si fue asi entonces esta pequea descripcin aparecer
en la ventana de dialogo References. Seleccionela y salga de esta ventana.
Una vez referenciada nuestra librera (acuerdese que esta referencia utiliza una
libreria de tipo) podemos utilizar las clases que expone. Como la unica clase que
tenemos es de tipo MultiUse, necesitamos generar un objeto como se vio en la
seccion anterior.
En la seccin de declaraciones de forma o formulario que se tiene para el proyecto
Standard exe, declare una variable privada de objeto de tipo CEmpleado.
Declarelo sin la clausula New para poder definir nosotros el momento en que
deseamo inicializar esta variable. Observara que en el momento de teclear As ms el
espacio, VB5 le presenta una lista flotante para poder seleccionar el tipo y mientras
escribe las primeras letras del tipo tratara de adivinarlo. Puede moverse a traves de
esta lista utilizando las flechas y avance/retrocesode paginas, una vez ubicado sobre
el tipo a seleccionar presione TAB (arriba de la activacin de mayusculas, lado
izquierdo). Esta situacin se presentar en varias otras ocaciones, utilicelo para
agilizar el cdigo.
En este caso vamos a utilizar el evento Initialize del formulario para inicializar
nuestro objeto. (Tambien puede usarse el evento Load del Formulario)
Vaya al evento Initialize y escriba el cdigo necesario para inicializar nuestro objeto
de tipo CEmpleado.
Ahora vamos a colocar en nuestra forma o formulario los siguientes controles:
Necesitamos de los correspondientes Labels y TextBox para cada una de las
propiedades de nuestro objeto de empleado. Insertelas en forma vertical para:
Nombre, Apellidos, Edad, Sexo, FechaIngreso, Antiguedad y Sueldo. Estas dos
ultimas son de solo lectura por lo que deber de colocar la propiedad Locked como
True para que no sea modificable. A estos controles escribales un nombre segun el
dato que mantendra.
Ahora colocaremos en la parte inferior los siguientes botones: Aadir, Borrar,
Aumentar Sueldo, Disminuir Sueldo y Salir.
Antes de meternos a codificar los botones, generemos un procedimiento privado
dentro del formulario que se llame Actualizar_Forma.
Inicialice dentro de este procedimiento cada uno de los controles TextBox con los
valores actuales del objeto empleado. Recuerde lo siguiente para codificar este
procedimiento:
La fecha de ingreso tiene el siguiente formato a desplegar: dd/mm/yyyy. Y en sueldo
solo muestre dos digitos en los decimales y el signo de pesos al inicio.

Pgina:22 de 66
 Por lo pronto mande llamar a este procedimiento en el evento Load de la forma para
que refresque los datos al entrar al sistema.
Ahora aadamos el codigo necesario para los botones.
Aadir: codifique este botn para igualar los datos actuales de los textbox al objeto
creado. Puede utilizar validacin de datos si lo desea.
Borrar: de lo que se trata es que el objeto del empleado actual deber borrarse y
crearse uno nuevo. Debera actualizar la forma al nuevo objeto.
Aumentar: mendiante una caja de entrada (instruccin InputBox) obtener un valor
entero entre 1 y 100, para poder aumentar el sueldo al empleado actual. Aumentele
el sueldo al empleado y despues actualice la forma para actualizar esta informacin
en pantalla.
Disminuir: igual que la anterior, pero se trata ahora de disminuir el sueldo.
Salir: para salir de la aplicacin o de la forma.
Pruebelo. Ejecute la aplicacin (F5) para ver nuestro objeto de empleado
funcionando.
Nota: Este Lab es guiado por el instructor.

Pgina:23 de 66
 Crear y generar eventos en la clases
En esta seccin veremos como crear un evento o una serie de eventos en una clase y, de
acuerdo a alguna accin, generar un evento para avisar al usuario de la clase. Generar
eventos en muy sencillo en VB5 y VB6 (en VB4 no se puede), solo siga las siguientes
indicaciones:

Declaracin de eventos con el estatuto Event.

Generar un evento declarado con la instruccin RaiseEvent.

Declarar la variable de objeto con WithEvents .

Declaracin de eventos con la palabra reservada

Event

La sintaxis para declarar es muy sencilla. En la seccin de declaraciones de un mdulo de

clase declare el o los eventos a generar en algun mtodo o propiedad de la siguiente forma:

Event nombreEvento([listaArgumentos])

Generar un evento declarado con la instruccin

RaiseEvent

Para generar algn o algunos de los eventos declarados se utiliza la instruccin RaiseEvent
dentro de algun procedimiento, mtodo o propiedad que requiera para notificar al cliente de
la clase que algo a ocurrido. La sintaxis para generar el eventos es:

RaiseEvent nombreEvento([listaArgumentos])

Declarar la variable de objeto con WithEvents

Esto ya se vi anteriormente, si no recuerda como declarar una variable de objeto con una
clase vaya a instancias de una clase con eventos.

En aquella seccin se vio la declaracin de la variable de objeto insertando WithEvents

entre el estatuto Dim y el nombre de la variable objeto. Y para atrapar y codificar los
eventos se utiliza un procedimiento con el nombre de la variable de objeto, underscore y el
nombre del evento a atrapar con los argumentos a recibir.

Pgina:24 de 66
 Amigos y Enumeraciones
La mejor forma de implementar Programacin Orientada a Objetos es con 2 o mas clases
cooperando entre s. Las clases necesitan compartir informacin pero no con otras clases. En
seccin veremos como VB5 comparte informacin entre clases del mismo componente.
Adems veremos para que nos sirven las enumeraciones y como definirlas y usarlas.

Compartir informacin entre clases como amigos: Friend.

Qu son enumeraciones?

Cmo declarar y usar las enumeraciones.

Compartir informacin entre clases como amigos:

Friend

Muchos lenguajes de Programacin Orientada a Objetos proporcionan un modificador Friend

para permitir que las clases compartan informacin entre ellos permitiendo especificar
quienes son tus amigos.

La interpretacin de Friend de VB6 es muy pobre, te permite decir que tienes amigos y
cualquiera dentro del componente es tu amigo y nadie te conoce. Esto es, en VB6 tu declaras
tus mtodos y propiedades como Amigos y todos dentro del componente que lo contiene
(ActiveX Exe o ActiveX Dll) puede verlos y usarlos y cualquiera fuera del componente no
pude utilizarlos.

La sintaxis para declarar propiedades o mtodos incluyen este modificador como opcional:

[Public | Private | Static] [Friend] Property [Get | Let | Set] nombreVar(...

De Public, Private y Static se vio informacin en alcances de los metodos y propiedades.

Qu son Enumeraciones?

Las enumeraciones son un grupo de constantes definidas que pueden describir entre otras
cosas posibles valores de retorno para una funcin especifica o evento generado por la clase.
Tambien pueden ser posibles valores disponibles para algun argumento de entrada a algn
mtodo o propiedad de la clase.

Por ejemplo, supongase que tenemos una propiedad llamada Color y en la cual se desea que
los nicos valores vlidos son Azul, Rojo y Verde al momento que se le asigne un valor.
Podriamos definir las constantes pblicas 1 para Azul, 2 para Rojo y 3 para verdes o definir
las enumeracines con esas mismas constantes.

Cmo declarar y usar las enumeraciones

La sintaxis para declarar una enumeracin es parecida a la declaracin de tipo definidos por
el usuario UDT:

[Public | Private] Enum nombreEnumeracin

nombreMiembro [= constante_o_Expresin]
End Enum
Si el nombreMiembro no se iguala a una constante o expresin iran tomando los valores
secuenciales, segun su orden de definicin (de arriba a abajo), los valores 0, 1, 2, 3, 4,...

Pgina:25 de 66
El default, como ya se dijo en mtodos y propiedades, es Public. Si se declara como tal los
usuarios de la clase podran usarlo, lo cual es recomendable si va a regresar o recibir un valor
de este tipo. Si solo es de uso interno en la clase entonces declararlo como Private.

Por ejemplo: para nuestro ejemplo anterior podriamos definir nuestro grupo de colores como
sigue:

Enum icColores
Azul = 10
Rojo = 15
Verde = 20
End Enum

Una enumeracin puedes utilizarlo para definir una variable de este tipo y si puedes definir
una variable cuyos posibles valores estan limitados a los valores que la enumeracin
contiene tambien puedes definir parametros.

Ejemplos:

Dim A as icColores

Property Get Color() As icColores

'Valores validos a regresar son los contenidos en icColores

End Property

Property Let Color(Valor as icColores)

'Valores validos a asignar son los contenidos en icColores

End Property

En asignaciones recuerdese que las enumeraciones son como variables globales y se puede
utilizar o su valor numerico o el nombre declarado en la enumeracin.

Ejemplos:

A = 10 es equivalente a escribir A = Azul

A = varobj.Color

varobj.Color = 20 es equivalente a varobj.Color = Rojo

Pgina:26 de 66
 Lab03: Aadir Eventos y enumeraciones
Proyecto ejemplo: aadir eventos y enumeraciones

Ya hemos aprendido como crear metodos y propiedades a un modulo de clase y crear

nuestros objetos en base a una clase compartida.

Es momento de practicar nuestras dos ultimas sesiones en la cual abarcamos los temas de
eventos, enumeraciones y Amigos. Veremos por lo pronto la implementacin de los dos
primeros en esta sesin de practica.

En esta seccin seguiremos trabajando en el proyecto ActiveX Dll y Standar Exe definidos en
los Labs anteriores.

Definamos una enumeracin en StdLib32.dll. Como ya vimos, en secciones

anteriores, las enumeraciones nos pueden servir, entre otras cosas, a limitar los
posibles valores para una propiedad.
En nuestro proyecto ejemplo, el mejor candidato a esto es la propiedad Sexo. Este
debe tomar o regresar solamente dos valores: Masculino o Femenino. Segun la
sintaxis que se vio en Amigos y enumeraciones, definir una constante para Masculino
y otra para Femenino en la seccin de declaraciones de la clase.

Realicemos los cambio necesarios para que el valor de la propiedad sexo est
limitado a la enumeracin.
Tenemos que definir las propiedades Get y Let de Sexo como de tipo enumeracin,
adems de la variable privada que contiene el valor de esta propiedad.
Ademas en el evento de Initialize de la clase inicialice la propiedad de sexo al valor
que desee (vera que al poner el signo de asignacin aparecer una lista flotante
indicandole los posibles valores, eliga uno con las flechas y TAB).
Una vez realizados estos cambio presione F2 para ver el Object Browser como me
coloco un nuevo elemento del lado izquierdo con un icono distinto a la de la clase,
esta es la enumeracin que definimos.
Realice los cambios necesarios en SysEmp.exe.
Ahora en lugar de utilizar un textbox para mostrar el valor que se obtiene de la
propiedad Sexo del objeto empleado, defina dos OptionButton con leyenda igual a
Mascullino y Femenino, respectivamente. Y en el cdigo de el botn Aadir deber
realizar un cambio en base al OptionButton seleccionado igualar la propiedad Sexo
con la constante adecuada. Adems el procedimiento Actualiza_Forma debera
contemplar el valor obtenido de la propiedad Sexo para habilitar un OptionButton.
Pruebelo. Presione F5 para ejecutar la aplicacin y probar.

Ahora definamos un evento en el mdulo de clase CEmpleado. Para nuestro caso

vamos a definir un evento en que nos indique del cambio de sueldo del empleado.
Primeramente vamos a definir otra enumeracin con dos posibles valores:
AumentoSueldo y DisminuyoSueldo.
Ahora como se vi en Eventos en las clases, declare un evento llamado
CambiosSueldo el cual enve como parmetro si el sueldo aumento o disminuyo,
segun la enumeracin recien creada.
Enseguida coloque en los metodos, como se vio en Eventos en las clases la
generacin del evento, el cual lo recibir el usuario.
Observe el Examinador de Objetos ahora tenemos dos nuevos miembros: la
enumeracin (ado izquierdo) y el evento (lado derecho al seleccionar la clase que la
contiene).
Ahora hagamos los cambios necesario en SysEmp.exe para atrapar los eventos
generados por la clase.

Pgina:27 de 66
Recuerda como se vi en Eventos en las clases, para declarar nuestras variables de
objeto para que intercepte los eventos. Bueno, pues vaya a la seccin de
declaraciones del formulario y haga los cambios pertinentes.
Ahora defina el procedimiento de evento para atraparlo. Como parte del cdigo
dentro del evento, segun el parmetro recibido, despliega un mensaje que diga: Se
aumento el sueldo o en caso distinto Se disminuyo el sueldo.
Pruebelo. Presione F5 para ejecutar la aplicacin. Recuerde de salvar su grupo de
proyecto.

Pgina:28 de 66
 Interfases y polimorfismo
VB presenta una nueva caracterstica muy poderosa para la implementacin de interfases. En
esta seccin describiremos que son las interfases y como se implementan en VB5.

Interfases?

Desarrollando e implementando interfaces en VB6.

Interfases?

Interfases es el concepto de moda en diseo del lenguaje. Cuando Java incorpor interfaces
como una caracterstica del lenguaje se proclamo que las interfaces son el mejor sustituto
para el concepto ms maligno de herencia mltiple.

En VB6 la nueva clusula Implements proporciona esencialmente esta misma caracterstica

(Delphi tambin incorpora algo similar). Adems se parece mucho la sintaxis de eventos y
requiere definir variables objetos extras en ciertas situaciones. El propsito principal de
Implements no es herencia mltiple sino polimorfismo.

Supongamos que se tiene dos clases donde una parte del cdigo es genrico para ambas y
otra parte es muy especfica a cada clase. En estos casos se escribe una interfase para la
parte genrica y las dos clases implementan la interfase para la parte especfica. La parte
genrica utiliza los objetos con implementaciones especificas sin conocer o preocuparse lo
que esos objetos hacen o como lo hacen.

Las interfaces encapsulan clases de la misma forma que las clases encapsulan miembros y
mtodos. Y tal como una clase esconde el estado interno de sus objetos, una interfase
esconde la implementacin de sus clases.

Desarrollando e implementando interfases en VB

Definiendo la interfase.
Para crear interfaces en VB simplemente aade un mdulo de clase con los mtodos y
propiedades vacias, o sea, sin codigo; recuerdese que la implementacin (el cdigo) de estos
es particular para cada clase que lo implementa.

Por ejemplo:

En un mdulo de clase se definen las siguientes caracteristicas:

Property Get Nombre() As String

End Property

Property Let Nombre(Valor As String)

End Property

Function Aumentar_Sueldo() as Boolean

Ends Function

Una interfase no tiene cdigo porque no hacen nada, deber crear al menos una clase por
separado que implemente la interfase, ponerle cdigo. En VB, como para las variables, se
utiliza un prefijo para darle un nombre al mdulo de clase: para las clases se utiliza 'C', para
las interfases 'I'. Se podria tener una clase llamada CEmpleado la cual implementa una
interfase llamada IPropEmpleado.
Implementando una Interface.

Pgina:29 de 66
 La clusula principal en la implementacin de interface es Implements. La sintaxis
para realizar una implementacin de una interface es (se coloca en un mdulo (o
modulos) de clase diferente a la interface que se va a implementar):
Implements nombreInterface
Esta instruccin se coloca en otro mdulo de clase diferente al modulo que definio la
interfase. Esto es porque esta nueva clase har la implementacin de la interfase (le
pondr codigo a la interfase).
Lo interesante acerca de este estatuto es lo que realiza con la ventana de codigo que
lo contiene. La lista de objeto presenta una nueva entrada para la interface a
implementar. Haga de cuenta que insert un control y desea introducir codigo en sus
eventos. De esta misma forma en la ventana de cdigo puede elegir la interface y
moverse a travs de los miembros a implementar por medio de las listas superiores
de la ventana de cdigo.

Los procedimientos de interface se parecen a procedimientos de eventos poque como tales

no puden cambiarse el nombre y no pueden ser ignorados. Si ignora implementar alguno de
estos miembros VB5 le reclamar con un error en tiempo de compilacin.
Posiblemente algunas de las propiedades de la interface a implementar deberan ser publicas
mediante otro procedimiento Property.

Por ejemplo: supongamos que deseamos implementar IPropEmpleado:

Implements IpropEmpleado

Private Property IpropEmpleado_Get Nombre() As String

'codigo
End Property

Private Property Let IpropEmpleado_Nombre(Valor As String)

'codigo
End Property

Private Function Aumentar_Sueldo()

'cdigo
End Function

Para implementar una propiedad pblica que tenga acceso a la propiedad imprementada
Nombre por ejemplo:

Public Property Get Nombre() As String

Nombre = IpropEmpleado_Nombre
End Property

Public Property Let Nombre(Valor as string)

IpropEmpleado_Nombre = Valor
End Property

No podemos poner la implementacin de nombre como pblica porque el nombre de la

propiedad a exponer sera IpropEmpleado_Nombre en lugar de algo que lo defina bien:
Nombre.

Usando una interfase en procedimientos genricos.

Podemos implementar un procedimiento genrico en un mdulo estandar del
proyecto que utiliza la clase que en base a una interface realice alguna accin.

Por ejemplo: vamos a ejemplificar lo anterior para que se entienda. Ya realizamos nuestra
interface de IPropEmpleado ahora deseamos utilizar esta interface en un procedimiento
generico que lo unico que va a hacer es imprimir el nombre y sueldo en una caja de dialogo.

Pgina:30 de 66
Este cdigo puede estar en un mdulo estandar para que se pueda accesar desde cualquier
parte del proyecto.

Sub ImprimePropEmpleado(propEmp as IPropEmpleado)

MsgBox "Nombre empleado: " & propEmp.Nombre & vbCrLf & "Sueldo actual: " _
& propEmp.Sueldo
End Sub

El objeto que pases como parmetro a este procedimiento deber implementar la interfase
IPropEmpleado.
De esta forma suponga que tiene dos implementaciones distintas de IPropEmpleado:
CEmpleadoGeneral y CEmpleadoEspecial. Si se definen dentro del evento Click de un
botn en una forma el siguiente cdigo se observaran los nombre y sueldos de las personas
definidas por las dos variables. una tras de otra en una ventana de dialogo.

Private EmpGen As New CEmpleadoGeneral

Private EmpEsp As New CEmpleadoEspecial
EmpGen.Nombre = "Juan Perez"
EmpEsp.Nombre = "Miriam Hernandez"
...
ImprimePropEmpleado EmpGen
ImprimePropEmpleado EmpEsp

Si observa las dos ultimas lneas, el procedimiento ImprimePropEmpleado recibir solo la

implementada de la interfase IPropEmpleado.
VB6 puede implementar las llamadas de interfaces en tiempo de compilacin.

Pgina:31 de 66
 Lab04: Interfases
Olvidmonos por lo pronto de lo que hemos diseado para la clase CEmpleado. En los
siguientes puntos a desarrollar nos basaremos en el codigo generado en la clase; esto es, en
donde se requiera solo realice Copiar de cdigo que ya se tiene y Pegar a los nuevos
mdulos de clases que se van a aadir al proyecto de ActiveX DLL.

Siga estos puntos paso por paso, no se salte ninguno sin haber ternimado por completo
estos, si tiene duda o no sabe como pregunte al instructor para poder seguir avanzando.

Vamos a trabajar en los siguientes puntos en el proyecto de ActiveX DLL:

Vamos a disear la interfase que presente algunas caracterticas genericas para dos clases
nuevas que disearemos: CAgente y CDirectivo. En el primer paso disearemos la interfase y
en las siguientes las dos clases y algunas funciones genricas para ambas. Para este
ejemplo, no crearemos ni enumeraciones, ni eventos, ni amigos... slo lo indicado.
Insertemos un nuevo mdulo de clase en nuestro proyecto de libreria DLL. Esta clase
sera nuestra interfase por lo que la llamaremos IEmpleado.

Definamos la interfase con las siguientes propiedades (acuerdese que en las

interfaces solo se definen sin ponerles cdigo ni relacionandolas con variables
privadas. Solo declare los procedimientos Property):
Nombre: Cadena (L/E)
Edad: Entero (L/E)
Sueldo: Moneda (L)

Y declare los siguientes mtodos (solo declarelos no los implemente):

AumentaSueldo: recibe como parmetro el porcentaje a aumentar.

DisminuyeSueldo: recibe como parmetro el porcentaje a disminuir.
Por lo pronto, asi de sencilla sera nuestra interfase. Ahora agrege dos mdulo de
clase y llamelos CAgente y CDirectivo.

Mencionele a VB que se desea implementar la interfase IEmpleado en ambos

mdulos de clases. Como se vi en Interfase y Polomorfismo.
Observe en la lista superior izquierda de los mdulos donde realizo la referencia a
implementar la interfase, busque el nombre de la interfase IEmpleado, seleccionelo y
en la lista de la derecha obtendremos lo que hay que implementar. En las
propiedades obtendremos los Get y los Let a implementar. Notara que todas
apareceren con el prefijo Private, esto porque mediante la implementacin de otras
propiedades o metodos usted decide si exponerlos al usuario de tu clase o no.
Bueno, pues empecemos a implementar las propiedades. Para cada una de estas
deber crear sus respectivas variables privadas dentro de los mdulos de clase
CAgente y CDirectivo.
Nombre: al igual que la clase de CEmpleado que ya tenemos de nuestra primera
practica debera implementar el cdigo para regresar o asignar el valor de nuestra
variable privada para guardar en memoria el valor de nombre.
Edad: al igual que la clase de CEmpleado que ya tenemos de nuestra primera
practica debera implementar el cdigo para regresar o asignar el valor de nuestra
variable privada para guardar en memoria el valor de nombre.
Sueldo: como sueldo se defini en la interfase de solo lectura, solo aparecer el Get
en la lista superior derecha. Seleccionela e implementela igual que el cdigo de la
clase CEmpleado que ya tenemos de nuestra primera practica.
Como observamos arriba todas estas implementaciones de las propiedades son
privadas. Requerimos de generar adentro de nuestras dos clases otras propiedades
para poder exponer estos datos al usuario de mis clases pero sin el nombre de
IEmpleado_Nombre sino simplemente como Nombre.

Pgina:32 de 66
 Genere estas propiedades utilizando los conocimientos ya adquiridos anteriormente.
Esto es, copiandolo de la clase que implementamos en la primera prctica: Nombre,
Edad y Sueldo. Solo verifique que los nombres de las variables internas sean los
mismos.
Aqui hay que hacer una observacin: note que tanto las propiedades de la interfase
implementada y las propiedades a exponer (Nombre, Edad, Sueldo) contiene el
mismo cdigo. En este caso los podemos dejar as porque no es mas que una lnea
de codigo en estas propiedades, pero si fuera mas compleja la programacin no
repitiriamos el mismo codigo en ambas parte, sino que simplemente las propiedades
a exponer mandaran llamar a las propiedades implementadas de IEmpleado para no
duplicar cdigo. Esto se vera ms claro al implementar los mtodos en el punto
siguiente.
Implemente los dos mtodos de aumentar/disminuir sueldo que presenta la interface
IEmpleado en ambas clases CAgente y CDirectivo.
El cdigo que se implementar en estos mtodos son similares a los que se
realizaron en CEmpleados en la primera practica. Solo que haremos algunas
modificaciones.
Para la clase CAgente: se le aumenta el sueldo si el sueldo actual es mayor o igual a
1500 y se le disminuye si el sueldo actual es mayor 499. Casos contrarios no se le
aumenta o disminuye, respectivamente.
Para la clase CDirectivos: se le aumenta el sueldo si el sueldo actual es mayor o igual
2000 y se le disminuye si el sueldo actual es mayor a 999. Casos contrarios no se le
aumenta o disminuye.
Ahora, tenemos que exponer estos mtodos al usuario de nuestras clases. Por lo que
deber crear dos mtodos pblico que se llamen: AumentaSueldo y DisminuyeSueldo
en cada modulo de clase (CAgente, CDirectivo).
Y como cdigo dentro de estos no escriba lo mismo que se hizo en el paso anterior.
Solo mande llamar al que ya se codifico. Por ejemplo, en AumentaSueldo mande
llamar a IEmpleado_AumentaSueldo y regrese al cliente lo que ste regrese.
Hasta el momento en nuestras dos clases ya tenemos codificada la implementacin
de las dos clases: CAgente y CDirectivo. Ahora vamos a aadir otras propiedades a
cada uno respectivamente. Esto es, podemos tener otras propiedades o metodos
expuestos al usuario diferentes a los que tiene la interface.
En la clase CAgente: aada la siguiente propiedad:
HorasTrabajadas: Single (L/E); en Let debera validar que este entre 4 hrs. y 10 hrs.
(inclusives) sino no realice el cambio.

En la clase CDirectivo: aada las siguientes propiedades:

Prestaciones: Booleano (L/E); deber tener True si este directivo tiene prestaciones,
caso contrario False.
En el evento Initialize de las clases creadas inicialicemos algunas variables:
En la clase CAgente: inicialicemos las siguientes variables.
Sueldo: inicialicelo a 1500.
HorasTrabajadas: inicialicelo a 6.5 (suponemos que la jornada minima diaria de cada
trabajador es de esta cantidad)

En la clase CDirectivo: inicialicemos las siguientes variables.

Sueldo: inicialicelo a 2000.
Prestaciones: inicialicelo a False.
Salvemos el proyecto. Dele un nombre descriptivo a cada mdulo de clase.

Ahora iremos a nuestro proyecto SysEmp.exe. Para hacer uso de estas dos clases. Siga los
siguientes pasos cuidadosamente.
Aadir una nueva forma al proyecto SysEmp.exe y llamsmola CatEmpleado2.

Pgina:33 de 66
Vayamos a las propiedades del proyecto (SysEmp Properties del men Project) y se
leccionesmos que la forma CatEmpleado2 es nuestra forma inicial al correr el
proyecto.

En la parte superior de la forma coloque dos OptionButton para indicar si el

empleado a aadir es de tipo Agente o es de tipo Directivo.

Ahora pongamos los respectivos Labels y Textbox para cada una de las siguientes
propiedades:
Nombre, Edad, Sueldo (recuerde que es de solo lectura), Horas Trabajadas.
Para la propiedad Prestaciones utilice un CheckButton para habilitar si tiene
prestaciones o no.
Aadiremos ahora los acostumbrados botones: Aadir, Borrar, Aumentar, Disminuir.

Definamos dos variables privadas en la seccin de declaracin del formulario, una

para CAgente y otra para CDirectivo.

Inicialicemos estas variables (o sea crear los objetos con Set.. New) en el evento
Initialize del formulario.

En el evento Load de la forma inicialice el OptionButton de Agente a True para

seleccionarlo.

Generemos nuestro procedimiento privado Actualiza_Forma que reciba como

parmetro la interface IEmpleado implementado en las clases CAgente y CDirectivo.
Actualice los textos de Nombre, Edad y Sueldo que son los que obtenemos del
parametro que recibimos de tipo IEmpleado.
Ahora dentro del evento Click de los OptionButton vamos a meter el codigo necesario
para realizar el cambio entre el objeto tipo CAgente y el objeto tipo CDirectivo.
En el evento Click del OptionButton de Agente, realizaremos lo siguiente: inhabilite o
esconda el control CheckBox de Prestaciones por que en este tipo de objeto no se
requiere y habilite o haga visibles los controles correspondientes a HorasTrabajadas.
Mande llamar a actualiza forma para desplegar a los textbox lo comun en ambos
objetos, en seguida despliegue el valor de HorasTrabajadas del objeto de Agente.

En el evento Click del OptionButton de Directivo, realizaremos lo siguiente: inhabilite

o esconda los controles correspondientes a HorasTrabajadas por que en este tipo de
objeto no se requieren y habilite o haga visibles el control CheckBox de Prestaciones.
Mande llamar a actualiza forma para desplegar a los textbox lo comun en ambos
objetos, en seguida despliegue el valor de Prestaciones del objeto de Directivo.
Vamos a agregar un mdulo estandar a la aplicacin SysEmp.exe para implementar
una funcin general para aumentar el sueldo independientemente del objeto que se
pase como parmetro, la restriccin es que este objeto implemente la interface
solicitada como prametro.
En este mdulo estndard insertado en el proyecto implemente una funcin publica
que regresa un valor booleano que se llame CambiarSueldo el cual reciba como
parametro una variable de interfase de tipo IEmpleado. Como segundo parmetro
recibir una variable que indique si se aumentar o se disminuira el sueldo.
Finalmente, como tercer parametro recibir el porcentaje a aumentar o disminuir.
Dentro del cdigo de esta funcion solo se ejecutar el metodo AumentaSueldo o
DisminuyeSueldo, de acuerdo al segundo parametro recibido, de la interface
implementada que se recibe como parmetro
Codifique los botones como sigue:
Aadir: codifique este botn para igualar los datos actuales de los controles al objeto
creado ya sea Agente o Directivo (los botones OptionButton lo indicaran). Puede
utilizar validacin de datos si lo desea.
Borrar: de lo que se trata es que el objeto del empleado actual (ya sea agente o
directivo, los OptionButton lo indicaran) deber borrarse y crearse uno nuevo.

Pgina:34 de 66
Debera actualizar la forma al nuevo objeto (solo mande llamar al evento Click del
OptionButton actualmente seleccionado).
Aumentar: mendiante una caja de entrada (instruccin InputBox) obtener un valor
entero entre 1 y 100, para poder aumentar el sueldo al Agente o Directivo actual,
utilice la funcin CambiarSueldo creado en el punto anterior para aumentar el sueldo,
solo pasele el objeto de Agente o Directivo que implementa la interface para enviarlo
como parmetro a este procedimiento.
Disminuir: igual que la anterior, pero se trata ahora de disminuir el sueldo.
Salir: para salir de la aplicacin o de la forma.
Salve su proyectos y deles un nombre descriptivo a los archivos a guardar.

Pruebelo. Ejecute la aplicacin (F5) para ver nuestro objeto de empleado

funcionando.

Pgina:35 de 66
 Controles de Usuario

Introduccin:

En esta seccin aprenderemos a crear Controles de Usuario (UserControl) , usando para

esto un proyecto especial denominado Control de Usuario

Los controles ActiveX, que se llamaban antes controles OLE, son elementos estndar de
interfaz de usuario que le permiten ensamblar rpidamente formularios y cuadros de dilogo.
Los controles ActiveX tambin dan vida a Internet, agregando una nueva y atractiva
funcionalidad a las pginas del World Wide Web.

Disear un control ActiveX puede resultar tan fcil como disear un formulario de Visual
Basic: puede usar los comandos grficos de Visual Basic con los que est familiarizado para
dibujar el control o bien crear un grupo de controles con los controles existentes.

Los controles ActiveX se pueden depurar en proceso, de forma que puede pasar
directamente desde el cdigo del formulario de prueba al cdigo del proyecto de control
ActiveX.

Puede agregar enlaces de datos a su control ActiveX de Visual Basic, de forma que un
usuario pueda enlazar fcilmente los campos individuales del control con los campos
correspondientes de una base de datos o de un origen de datos. Puede usar tambin enlaces
de datos para crear un control ActiveX que puede enlazar con otros controles, similares al
control Data de Visual Basic.

Lab05: Creacin de un Control ActiveX (OCX)

Paso a Paso

Para crear el proyecto ControlDemo

1. En el men Archivo, haga clic en Nuevo proyecto para abrir el cuadro de dilogo
Nuevo proyecto. (Esto cerrar el proyecto o grupo de proyectos actual; se le pedir
que guarde los cambios que haya efectuado.) Haga doble clic en el icono Control
ActiveX para crear un nuevo proyecto. Visual Basic agrega automticamente al
proyecto un diseador UserControl. El nombre predeterminado, UserControl1,
aparece como ttulo del diseador.

2. En el men Proyecto, haga clic en Propiedades de Proyecto1 para abrir el cuadro

de dilogo Propiedades del proyecto. Seleccione la ficha General, complete la
informacin que se muestra en la imagen de la pgina siguiente y haga clic en
Aceptar.

Pgina:36 de 66
3. Haga doble clic en UserControl1 en la ventana Explorador de proyectos para
traer el diseador al frente.

4. En la ventana Propiedades, haga doble clic en la propiedad Name y cambie el

nombre del control de usuario a ShapeLabel. El nuevo nombre aparece en el ttulo
del diseador y en la ventana Explorador de proyectos.

El nombre que especifique se convertir en el nombre de clase del control, igual que
CommandButton es el nombre de clase de los botones de comando. "Crear
controles ActiveX" proporciona instrucciones para elegir los nombres de clase de los
controles.

Observe que la ventana Propiedades tiene una apariencia muy parecida a la de un

formulario de Visual Basic. Faltan algunas propiedades que est acostumbrado a ver
y hay propiedades que no se encuentran en los formularios normales de Visual Basic.

5. Dentro del diseador de controles, ajuste el tamao del control mediante el

controlador de arrastre situado en la esquina inferior derecha del control,
arrastrndolo hacia arriba y a la izquierda para hacer el control ms pequeo.

De esta forma se establece el tamao predeterminado del control. Para mayor

comodidad en procedimientos posteriores, el control ShapeLabel debe tener un
tamao reducido.

6. En el men Archivo, haga clic en Guardar proyecto para guardar los archivos del
proyecto. Asgneles nombres como se muestra en la tabla siguiente. Visual Basic
proporcionar las extensiones apropiadas automticamente.

Archivo Nombre de archivo Extensin

Control de Usuario ControlDemo_ShapeLabel .ctl
Proyecto ControlDemo .vbp

Pgina:37 de 66
Para agregar un proyecto de prueba al grupo de proyectos

7. En el men Archivo, haga clic en Agregar proyecto para abrir el cuadro de dilogo
Agregar proyecto.

Importante No haga clic en Abrir proyecto o en Nuevo proyecto porque se

cerrara el proyecto de control.

8. Haga doble clic en el icono EXE estndar para agregar un proyecto .exe normal.
Ahora puede ver ambos proyectos en la ventana Explorador de proyectos y el
ttulo de la ventana Explorador de proyectos muestra el nombre predeterminado del
grupo de proyectos.

El nuevo proyecto se convierte inmediatamente en el proyecto inicial para el grupo

de proyectos. La ventana Explorador de proyectos identifica el proyecto inicial
mostrando su nombre en negrita. Un proyecto de control ActiveX, como
ControlDemo, no puede ser el proyecto inicial.

9. En el men Archivo, haga clic en Guardar grupo de proyectos para guardar el

proyecto de prueba y el grupo de proyectos. Asigne nombre a los archivos como se
muestra a continuacin. Visual Basic proporcionar automticamente las extensiones
indicadas.
Archivo Nombre de Archivo Extensin
Formulario TestCtlDemo_Form1 .frm
Proyecto TestCtlDemo .vbp
Grupo de Proyectos ControlDemo .vbg

Para agregar cdigo al evento Resize

1. En la ventana Explorador de proyectos, haga doble clic en ShapeLabel para

convertirlo en el diseador activo.

Pgina:38 de 66
 2. Haga doble clic en el control ShapeLabel para abrir la ventana de cdigo.

3. En el cuadro Procedimiento, haga clic en el evento Resize para ir a su procedimiento

de evento. Agregue el cdigo siguiente:
Private Sub UserControl_Resize()
Static intCt As Integer
intCt = intCt + 1
Debug.Print "Resize" & intCt
End Sub

Para ejecutar el control ShapeLabel en tiempo de diseo

1. En la ventana Explorador de proyectos, haga doble clic en ShapeLabel para traer su

diseador al frente y, despus, presione Ctrl-F4 para cerrar la ventana. Al cerrar la
ventana del diseador, el control ShapeLabel se pone en modo de ejecucin. En
cuanto el control est en modo de ejecucin, su icono (el icono predeterminado del
cuadro de herramientas para un control de usuario) se activa en el cuadro de
herramientas.
Importante No haga clic en el botn Iniciar de la barra de herramientas ni presione F5 porque
pondra todo el grupo de proyectos en modo de ejecucin y no podra agregar el nuevo control a un
formulario.

Cuando pone un control en modo de ejecucin, no importa cmo cierre la ventana

del diseador. (Siempre puede saber si el diseador est abierto porque el icono del
control en el cuadro de herramientas aparecer en color gris.)

2. En la ventana Explorador de proyectos, haga doble clic en Form1 para traerlo al

frente.

3. Haga doble clic en el icono ShapeLabel para agregar un control ShapeLabel a

Form1. El control aparece como un rectngulo plano gris con controladores de
tamao:

En la ventana Propiedades puede ver las propiedades predeterminadas para un

control nuevo. Al control ShapeLabel que acaba de agregar al formulario se le ha
asignado un nombre predeterminado, ShapeLabel1.

Nota Asignar nombre a un control cuando comienza el diseo evita

confusiones. Suponga que coloca un control con un nombre
predeterminado, como UserControl1, en un formulario. La
numeracin automtica de los nuevos controles agregara un nmero
al final del nombre del control, lo que dara como resultado un
nombre confuso como UserControl11.

Pgina:39 de 66
4. Al colocar en el formulario el control ShapeLabel se ha producido el evento Resize
del mismo, como puede ver en la ventana Inmediato. Utilice los controladores de
tamao para cambiar varias veces el tamao del control. Cada vez que cambia el
tamao se vuelve a producir el evento Resize. Si se limita a mover el control por el
formulario, no se produce el evento Resize.

5. En Form1, haga doble clic en el control ShapeLabel para abrir la ventana de cdigo
de Form1. El cursor estar situado en el procedimiento de evento predeterminado,
ShapeLabel1_GotFocus. Puede usar el cuadro Procedimiento para ver los otros tres
eventos que Visual Basic proporciona automticamente para el control. Cierre la
ventana de cdigo cuando haya terminado.

6. En la ventana Explorador de proyectos, haga doble clic en ShapeLabel para abrir el

diseador de ShapeLabel. Observe que el control ShapeLabel que ha colocado en
Form1 est sombreado con unas marcas rayadas para indicar que est inactivo.

Abrir el diseador de un control hace que todas las instancias del control queden
inactivas. Cambiar el cdigo en la ventana de cdigo del control tambin convierte en
inactivas las instancias del control.

7. El cdigo contenido en el mdulo de cdigo de ShapeLabel no se puede ejecutar

mientras est abierto el diseador. Utilice los controladores de tamao para cambiar
el tamao del control ShapeLabel sombreado en Form1. El evento Resize no se
activa, por lo que no aparecen mensajes nuevos en la ventana Inmediato.

8. Asegrese de que el diseador de ShapeLabel est en el frente y presione Ctrl-F4

para cerrar la ventana, reactivando as la instancia del control. Desaparecer el
sombreado del control en Form1, lo que indica que la instancia est activa otra
vez.Si el control se ha convertido en inactivo a causa de los cambios efectuados en
su cdigo, puede hacer clic con el botn secundario del mouse (ratn) en el
formulario de prueba para llamar a su men contextual y hacer clic en Actualizar
controles de usuario para volver a activar las instancias del control.

Nota Debido al nmero de ventanas que requieren estos procedimientos,

puede encontrarse a menudo con que el diseador de ShapeLabel ha
desaparecido detrs de otro formulario. Puede hacer doble clic en ShapeLabel
en la ventana Explorador de proyectos para traer el diseador al frente.

Pgina:40 de 66
Tiempos y vida de un objeto UserControl
La vida de un formulario normal de Visual Basic est marcada por ciertos eventos clave,
como Initialize, Load, QueryUnload y Unload. Para crear aplicaciones que funcionen bien
es importante saber cundo se producen estos eventos en el ciclo de vida de un formulario.

Lo mismo sucede con los controles. Los eventos clave en el ciclo de vida de un control de
usuario son Initialize, InitProperties, ReadProperties, WriteProperties y Terminate.
El procedimiento siguiente explora estos eventos.

Para observar los eventos clave de ShapeLabel

1. En la ventana Explorador de proyectos, haga doble clic en ShapeLabel para abrir su

diseador.

2. Haga doble clic en el diseador para abrir una ventana de cdigo para ShapeLabel y
escriba el cdigo en los siguientes procedimientos de evento:
Private Sub UserControl_Initialize()
Debug.Print "Initialize"
End Sub

Private Sub UserControl_InitProperties()

Debug.Print "InitProperties"
End Sub

Private Sub UserControl_ReadProperties(PropBag As PropertyBag)

Debug.Print "ReadProperties"
End Sub

Private Sub UserControl_WriteProperties(PropBag As PropertyBag)

Debug.Print "WriteProperties"
End Sub

Private Sub UserControl_Terminate()

Debug.Print "Terminate"
End Sub

Nota Para los objetos UserControl, Load y Unload se sustituyen por los eventos
ReadProperties y WriteProperties. Esto se explica con ms detalle en "Descripcin del
tiempo de vida y los eventos clave de un control", en "Crear controles ActiveX".
3. Asegrese de que el diseador de ShapeLabel est en el frente y, entonces,
presione Ctrl-F4 para cerrar la ventana, poniendo as el control en modo de
ejecucin. Aparecern mensajes de depuracin en la ventana Inmediato:

Qu est pasando aqu? No ha colocado otra instancia del control ShapeLabel en

Form1. De dnde han salido todos estos eventos?

Pgina:41 de 66
 Este ejemplo ilustra un punto importante sobre los controles. Un usuario coloca un
control en un formulario y piensa que a partir de ah el control es un componente fijo
y permanente del formulario. Pero desde la perspectiva del autor de controles, estos
se destruyen y se vuelven a crear continuamente.

Al poner ShapeLabel en modo de ejecucin cerrando su diseador, la instancia de

ShapeLabel en Form1 se ha destruido y se ha vuelto a crear. En ese momento ha
recibido un evento Initialize. Por qu no ha visto primero un evento Terminate?
Porque la instancia original de ShapeLabel que ha colocado en Form1 se ha creado
antes de que agregara el cdigo contenido en el procedimiento de evento
UserControl_Terminate. Bienvenido al mundo extravagante y complejo de la
creacin de controles!

Nota Las instancias de un control tambin se destruyen y se vuelven a crear cuando

hace clic en Actualizar controles de usuario en el men contextual del formulario.

4. Presione Ctrl-F5 o haga clic en el botn Iniciar de la barra de herramientas para

ejecutar TestCtlDemo. Durante la ejecucin del proyecto desaparece la cuadrcula de
Form1, por eso no puede ver el control ShapeLabel, pero puede ver ante sus ojos
cmo parpadea en la ventana Inmediato:

Cuando el UserControl se ejecuta,

la instancia en tiempo de diseo
se destruye...

...Y se crea una instancia en

tiempo de ejecucin del
mismo control

Despus de crear una instancia de control, el evento ReadProperties le ofrece la

oportunidad de obtener los valores de las propiedades del control guardados en el
archivo .frm, que pertenece al formulario que contiene la instancia del control.

Cuando se destruye la instancia en tiempo de diseo del control, el evento

WriteProperties le da la oportunidad de guardar los valores de propiedades
establecidos en tiempo de diseo por el desarrollador que est utilizando su control.
Los valores de las propiedades se guardan en el archivo .frm del formulario
contenedor, como veremos en "Guardar los valores de las propiedades del control
ShapeLabel", ms adelante en este mismo captulo.

El evento Terminate se produce cuando se est destruyendo el control.

5. Cierre Form1 para volver al modo de diseo. En la ventana Inmediato ver un evento
Terminate a medida que se destruye la instancia en tiempo de ejecucin de
ShapeLabel (pero no ver WriteProperties, por qu?). Despus ver los eventos

Pgina:42 de 66
 Initialize, ReadProperties y Resize, a medida que se crea la instancia en tiempo de
diseo del control.
La instancia en tiempo de ejecucin de un control no obtiene nunca un evento
riteProperties, porque no necesita guardar los valores de sus propiedades. Para
entender por qu no, considere el futuro de ShapeLabel. Cuando est compilado en
un archivo .ocx, lo agregar a otro proyecto, pondr una instancia en un formulario,
compilar el proyecto en un archivo .exe y lo ejecutar. Cuando cierre ese archivo
.exe, el nico sitio en que la instancia de ShapeLabel podra guardar sus propiedades
sera el archivo .exe. Los buenos sistemas operativos no toleran este tipo de
comportamiento.

6. Desplcese a la parte superior de la ventana Inmediato, haga clic en la esquina

superior izquierda y arrastre para seleccionar todo el texto de la ventana. Presione la
tecla SUPR para borrar el contenido de la ventana.

7. En la ventana Explorador de proyectos, haga doble clic en Form1 para traer al frente
el Form1.

8. En el Cuadro de herramientas, haga doble clic en el icono ShapeLabel para agregar

otra instancia del control al Form1. Esta vez ver un nuevo evento.

Cuando agrega una nueva

instancia de este control al
formulario, se obtiene el
evento InitProperties, en el
que se obtienen los valores
predeterminados de la
propiedad

Cuando se sita una nueva instancia del control en un contenedor, obtiene un evento
InitProperties. En el procedimiento de evento UserControl_InitProperties puede
escribir cdigo para:

Establecer los valores predeterminados para cada valor de las propiedades

del control

Realizar tareas siempre que un usuario crea una instancia del control.

9. Cierre el diseador de Form1 haciendo clic en su botn Cerrar o presionando Ctrl-F4

mientras el diseador est en el frente. En la ventana Inmediato ver dos conjuntos
de eventos WriteProperties y Terminate, uno para cada instancia de ShapeLabel.

10. En la ventana Explorador de proyectos, haga doble clic en Form1 para abrir otra vez
su diseador. Cuando se abre el diseador, se crean todos los controles del Form1 y
se activan sus eventos Initialize. Entonces todos los controles reciben eventos
ReadProperties, que les permiten recuperar los valores guardados de sus
propiedades. El evento InitProperties no se produce, porque ya existen las dos
instancias del control ShapeLabel.

Dibujar el control ShapeLabel

Puede usar mtodos grficos, como Circle y Line, para dibujar el control o bien puede crear
la apariencia del control usando los controles ActiveX y los controles intrnsecos de Visual
Basic existentes. Los controles que se agregan a UserControl para crear su apariencia se
denominan controles componentes.

Como sugiere su nombre, la apariencia de ShapeLabel se crea usando un control Shape y un

control Label.

Pgina:43 de 66
Para agregar controles componentes al control ShapeLabel

1. En la ventana Explorador de proyectos, haga doble clic en ShapeLabel para abrir su

diseador.

2. En el Cuadro de herramientas, haga doble clic en el control Visual Basic Shape para
colocar un control Shape en el diseador de ShapeLabel. Si no ha utilizado antes el
control Shape, mantenga el mouse sobre los botones del cuadro de herramientas
hasta que encuentre uno cuya Informacin sobre herramientas sea "Shape".

3. En la ventana Propiedades, establezca los siguientes valores de propiedades para el

control Shape:

Propiedad Valor
BorderStyle 0 - Transparent
FillColor &H000000FF (Rojo)
FillStyle 0 Solid
Name ShpBack
Shape 2 Oval

Nota Para establecer propiedades de color como FillColor y ForeColor a

colores especficos, seleccione la ficha Paleta del cuadro de dilogo de
seleccin de color.

4. En el Cuadro de herramientas, haga doble clic en el control Label para agregar una
etiqueta encima del control Shape. En la ventana Propiedades, establezca los
siguientes valores de propiedades para el control Label:

Propiedad Valor
Alignment 2 - Center
BackStyle 0 - Transparent
ForeColor &H00FFFFFF (Blanco)
Name lblCaption

5. Use el controlador inferior de tamao para cambiar el alto de la etiqueta de forma

que sea algo ms alta que el texto que contiene. ShapeLabel debe tener una
apariencia similar a sta:

Pgina:44 de 66
 6. Haga doble clic en el diseador de ShapeLabel para traer al frente la ventana de
cdigo y sustituya el cdigo del procedimiento de evento UserControl_Resize con el
siguiente cdigo:
Private Sub UserControl_Resize()
' Da tamao al control Shape para llenar el
' rea visible de ShapeLabel.
shpBack.Move 0, 0, ScaleWidth, ScaleHeight
' Centra verticalmente el control Label y
' lo hace del mismo ancho que ShapeLabel.
lblCaption.Move 0, (ScaleHeight - lblCaption.Height) / 2, ScaleWidth
End Sub
7. Cuando est diseando un control de usuario, recuerde que el rea con la que tiene
que trabajar est enlazada por los valores ScaleWidth y ScaleHeight del control.
Aparte de esto, nada es visible para el usuario del control. Adems, el tamao del
rea de cliente cambiar a voluntad del usuario. Por eso, el evento Resize es uno de
los eventos ms importantes del diseo de controles.

8. Asegrese de que el diseador de ShapeLabel est en el frente y, entonces, presione

Ctrl-F4 para cerrar la ventana, poniendo as ShapeLabel en modo de ejecucin. En la
ventana Explorador de proyectos, haga doble clic en Form1 para traerlo al frente.

9. Los dos controles ShapeLabel deben aparecer ahora como valos rojos, con ttulos
blancos centrados con el texto "Label1". Cambie el tamao de ambos controles
ShapeLabel para probar el cdigo del evento Resize.

Guardar los valores de las propiedades del control

ShapeLabel
Es posible agregar propiedades y mtodos a un control ActiveX de la misma forma que se
agregan a los mdulos de clase: creando procedimientos pblicos. Como ShapeLabel va a ser
un control de etiqueta mejorado, es lgico que tenga una propiedad Caption.

El procedimiento siguiente agrega una propiedad Caption y el cdigo de soporte para guardar
y recuperar el valor de la propiedad. Los valores de las propiedades de un control se guardan
junto con los dems datos que describen el contenedor, en este caso, Form1.

Para agregar una propiedad Caption al control ShapeLabel

Pgina:45 de 66
1. En la ventana Explorador de proyectos, haga doble clic en ShapeLabel para abrir su
diseador y haga doble clic en ShapeLabel para traer al frente la ventana de cdigo.

2. En el men Herramientas, haga clic en Agregar procedimiento para abrir el cuadro de

dilogo Agregar procedimiento. En el cuadro Nombre, escriba el nombre. Haga clic
en Propiedad y en Pblico y, despus, haga clic en Aceptar.

3. En la ventana de cdigo, cambie los procedimientos Property recin creados para que
aparezcan de la forma siguiente:
Public Property Get Caption () As String
Caption = lblCaption.Caption
End Property

Public Property Let Caption(ByVal NewCaption As String)

lblCaption.Caption = NewCaption
PropertyChanged "Caption"
End Property
El procedimiento Property Let se ejecuta siempre que se asigna un nuevo valor a la
propiedad Caption. Almacena el nuevo valor directamente en la propiedad Caption de
la etiqueta lblCaption de ShapeLabel.

El procedimiento Property Get se ejecuta siempre que se recupera el valor de la

propiedad. Lee el valor almacenado en la propiedad Caption de la etiqueta lblCaption.

4. Para inicializar la propiedad Caption, agregue el cdigo siguiente al procedimiento de

evento UserControl_InitProperties:
Private Sub UserControl_InitProperties()
' Permitir que el valor de inicio de la propiedad
' Caption sea el nombre dado a esta instancia
' de ShapeLabel.
Caption = Extender.Name
Debug.Print "InitProperties"
End Sub
Qu es este objeto Extender? Para el usuario de un control, las propiedades de
ampliacin (como Name, Top y Left) parecen formar parte del control. Pero las
proporciona realmente el contenedor en el que est colocado el control. El objeto
Extender de UserControl da al diseador del control acceso a estas propiedades
desde dentro del control.
La propiedad de slo lectura Name del objeto Extender devuelve el nombre que da el
contenedor (o el usuario) a una instancia especfica del control. Usar este nombre
(por ejemplo, ShapeLabel1) como valor inicial de la propiedad Caption imita el
comportamiento del control Label.

Sugerencia Si el control imita el comportamiento de controles que proporcionan una

funcionalidad similar, ser ms intuitivo usarlo.

Qu ocurrira si creara una propiedad Name para el control? Podra tener acceso a
ella desde dentro del control, pero la nica propiedad Name que vera el usuario sera
la propiedad Name del objeto Extender.

Esta pregunta introduce un tema recurrente de los controles: El contenedor

determina una gran parte del comportamiento y la apariencia del control. Es el
contenedor lo que determina la propiedad Name del control, y las propiedades Top y
Left se mantienen en relacin a las coordenadas relativas del contenedor. Este tema
se retomar en "Crear controles ActiveX".

Una ltima cuestin relacionada con este asunto: por qu se pone este cdigo en el
evento InitProperties? Por qu no se utiliza el evento Initialize? Como ya hemos
visto, se llama a Initialize cada vez que se crea una instancia del control, lo que
sucede a menudo. InitProperties slo se produce cuando el usuario coloca el control

Pgina:46 de 66
 en el contenedor. Por eso es el sitio apropiado para establecer los valores iniciales de
una instancia de control.

Adems, los objetos Extender y AmbientProperties del objeto UserControl no estn

disponibles an cuando se produce el evento Initialize. "Descripcin de la duracin y
los eventos clave de un control", en "Crear controles ActiveX", explica los usos
apropiados del evento Initialize.

5. Para guardar el valor de la propiedad Caption, agregue el cdigo siguiente al

procedimiento de evento UserControl_WriteProperties:

Private Sub UserControl_WriteProperties(PropBag As PropertyBag)

Debug.Print "WriteProperties"
PropBag.WriteProperty "Caption", Caption, Extender.Name
End Sub

PropertyBag es una "bolsa" en la que se guardan los valores de las propiedades. Esta
bolsa la proporciona el contenedor. No puede ver su contenido, ni puede saber dnde
o cmo se guardan los datos. Todo lo que puede hacer es colocar valores en ella y
extraerlos.

El primer argumento del mtodo WriteProperty es el nombre de la propiedad, que se

usar como clave de recuperacin de datos. Para este argumento debe usar el
nombre de la propiedad, ya que aparecer en el archivo de texto .frm (en Visual
Basic; otros contenedores pueden usar otros nombres de archivo para guardar datos
de proyectos) y lo podr ver el usuario del control.

El segundo argumento es el valor. El valor de una propiedad se guarda como un tipo

Variant.

El tercer argumento, por extrao que parezca, es un valor predeterminado. Por qu

proporcionar un valor predeterminado cuando se est guardando el valor de la
propiedad? Antes de guardar el valor, el mtodo WriteProperty compara el valor de
la propiedad con el predeterminado. Si son iguales, no es necesario guardar el valor
de la propiedad, porque los valores predeterminados se establecern
automticamente al volver a cargar el control. De esta forma se evita llenar el
archivo .frm con cientos de entradas predeterminadas, lo que a buen seguro
agradecern los usuarios.
6. Coloque el cdigo siguiente en el evento ReadProperties para recuperar el valor
persistente de la propiedad Caption:
Private Sub UserControl_ReadProperties(PropBag As PropertyBag)
Debug.Print "ReadProperties"
Caption = PropBag.ReadProperty("Caption", Extender.Name)
End Sub

El segundo argumento del mtodo ReadProperty es un valor predeterminado que se

usar si no se ha guardado ningn valor, si el usuario ha eliminado la propiedad del
archivo de texto o si el valor no ha cambiado nunca con respecto al valor
predeterminado y, por tanto, WriteProperty nunca lo ha guardado.

7. Asegrese de que el diseador de ShapeLabel est en el frente y, despus, haga clic

en el botn Cerrar o presione Ctrl-F4 para cerrar la ventana, poniendo as el control
en modo de ejecucin. Como por arte de magia, los ttulos de los controles
ShapeLabel cambian para coincidir con los nombres predeterminados de las dos
instancias, ShapeLabel1 y ShapeLabel2.
Utilice la ventana Propiedades para cambiar las propiedades Caption de los dos
controles ShapeLabel del Form1 y haga clic en el botn Cerrar del diseador de
Form1. En la ventana Explorador de proyectos, haga doble clic en Form1 para volver
a abrir el diseador de Form1.

A partir de los mensajes de la ventana Inmediato, puede ver que los controles se han
destruido y se han vuelto a crear, pero los valores de las propiedades Caption se han
guardado y recuperado.

Pgina:47 de 66
 8. Presione Ctrl-F5 para ejecutar TestCtlDemo, el proyecto inicial del grupo de
proyectos, y observe el comportamiento del control ShapeLabel en tiempo de
ejecucin.
9. Haga clic en el botn Cerrar del Form1 para volver al modo de diseo.

Dar una pgina de propiedades al control ShapeLabel

Las propiedades simples que se crean usando procedimientos Property aparecern

automticamente en la ventana Propiedades de Visual Basic. Tambin puede conectar el
control a pginas de propiedades, que muestran las propiedades del control en un formato
alternativo.

Cada pgina de propiedades que se conecta al control se convierte en una de las fichas del
cuadro de dilogo Propiedades con fichas. Visual Basic controla todos los detalles de
presentar las pginas como un cuadro de dilogo con fichas y administra los botones
Aceptar, Cancelar y Aplicar. Todo lo que tiene que hacer es disear los controles que se
usarn para establecer los valores de las propiedades.

La pginas de propiedades son tiles cuando un grupo de propiedades interacta de forma

compleja, como ocurre con el control Toolbar incluido en Visual Basic. Tambin son tiles
para los controles que se van a distribuir internacionalmente, porque se pueden traducir los
ttulos a diferentes idiomas. Las pginas de propiedades tambin le permiten usar los
controles con herramientas de desarrollo que no tienen una ventana Propiedades.

Para agregar una pgina de propiedades al proyecto

1. En la ventana Explorador de proyectos, haga clic en ControlDemo para seleccionar el

proyecto del control. En el men Proyecto, haga clic en Agregar pgina de
propiedades para abrir el cuadro de dilogo Agregar pgina de propiedades. Haga
doble clic en el icono Pgina de propiedades para agregar una pgina de propiedades
al proyecto.

2. En la ventana Propiedades, haga doble clic en la propiedad Name y cambie el

nombre de la pgina de propiedades a SLGeneral. Haga doble clic en la propiedad
Caption y cambie el ttulo a General.

El ttulo es lo que aparecer en la ficha de la pgina de propiedades cuando est en

uso.

Por qu llamar a la pgina SLGeneral en lugar de General? Puede que tenga varios
controles en un proyecto y cada uno de ellos tenga una pgina General. sta es la
pgina General del control ShapeLabel.

3. En el men Archivo, haga clic en Guardar grupo de proyectos para guardar el grupo
de proyectos. Asigne nombre a la pgina de propiedades como se indica en la tabla
siguiente. Visual Basic agregar automticamente la extensin indicada.

Archivo Nombre de archivo Extensin

Pgina de propiedades ControlDemo_SLGeneral .pag

La informacin binaria de una pgina de propiedades, como los mapas de bits, se

guardarn en un archivo binario con el mismo nombre y una extensin .pgx.

El diseador de una pgina de propiedades se parece mucho al diseador de un

control, excepto en que la barra de ttulo del diseador muestra la propiedad Caption
de la pgina de propiedades, en lugar de la propiedad Name.

Pgina:48 de 66
Para disear la pgina de propiedades General para el control ShapeLabel

1. Coloque un control Label en la pgina de propiedades y establezca la propiedad

Caption de la etiqueta a la palabra Ttulo.

2. Debajo de la etiqueta, coloque un control TextBox y asgnele los siguientes valores

de propiedades:

Propiedad Valor
Name txtCaption
Text <vaco>
La pgina de propiedades debe parecerse a la que se muestra a continuacin.

Colocar la etiqueta de descripcin de la propiedad encima del cuadro de texto de esta

forma facilita la traduccin del componente del control a otros idiomas, en los que la
palabra "Ttulo" puede ser ms corta o ms larga.

3. Haga doble clic en la pgina de propiedades para abrir una ventana de cdigo. En la
lista desplegable Eventos, seleccione el evento SelectionChanged y agregue el cdigo
siguiente:
Private Sub PropertyPage_SelectionChanged()
' Muestra el ttulo del primer control de
' la lista de controles seleccionados
' actualmente.
txtCaption.Text = SelectedControls(0).Caption
End Sub
La finalidad de este evento es obtener los valores existentes de propiedades del
control o controles ShapeLabel que estn seleccionados en este momento. No hay
ningn problema; puede haber ms de un control ShapeLabel seleccionado. La
seleccin mltiple es muy prctica para el usuario del control, pero implica ms
trabajo para el diseador.

Una pgina de propiedades recibe un evento SelectionChanged cada vez que se abre.
Tambin recibe este evento cuando cambia la lista de controles seleccionados. Esto
es necesario porque el cuadro de dilogo Pginas de propiedades no es modal, de
forma que el usuario puede seleccionar controles adicionales mientras est abierto el
cuadro de dilogo.

Tiene que decidir cmo controlar la seleccin mltiple basndose en cada propiedad.
Por ejemplo, si la pgina de propiedades muestra la propiedad Width del primer
control de la coleccin SelectedControls, es decir, SelectedControls(0), como se
muestra arriba en el cdigo, ser fcil para el usuario cambiar el ancho de todos los
controles seleccionados a ese valor.

Por otra parte, no tiene sentido establecer los ttulos de todos los controles
ShapeLabel de un formulario al mismo valor: lo ms lgico que se puede hacer con la

Pgina:49 de 66
 propiedad Caption es desactivar txtCaption si la propiedad Count de la coleccin
SelectedControls es mayor que uno.

Sin embargo, este procedimiento no hace lo lgico. Con fines ilustrativos se permite
que la pgina de propiedades establezca varios ttulos. Despus, si desea activar el
comportamiento descrito anteriormente, puede agregar las lneas de cdigo
siguientes al procedimiento de evento PropertyPage_SelectionChanged:
' No haga esto todava!
If SelectedControls.Count > 1 Then
txtCaption.Enabled = False
Else
txtCaption.Enabled = True
End If
4. Para establecer los valores de las propiedades de todos los controles seleccionados
actualmente, agregue el cdigo siguiente al evento ApplyChanges:
Private Sub PropertyPage_ApplyChanges()
' Use una variable genrica Object, en caso de
' estar seleccionado ms de un tipo de control.
Dim objControl As Variant
For Each objControl In SelectedControls
objControl.Caption = txtCaption.Text
Next
End Sub
La pgina de propiedades recibir el evento ApplyChanges cuando el usuario haga
clic en el botn Aplicar o en Aceptar del cuadro de dilogo Pginas de propiedades.

Cmo sabe que cada control de SelectedControls tiene una propiedad Caption?
Como diseador del componente del control, usted determina qu pginas de
propiedades estn conectadas a un control dado. Una pgina de propiedades slo
aparecer si todos los controles seleccionados actualmente tienen esa pgina en la
lista Pginas de propiedades. Lo ms fcil es asegurarse de que las pginas
asignadas a cada control no muestran propiedades que no tiene el control.

Si desea usar una pgina de propiedades de uso general para una serie de controles,
y en la pgina de algunos de esos controles no se muestran todas las propiedades,
puede agregar cdigo al evento ApplyChanges para probar el tipo de control y aplicar
el valor de propiedad que sea apropiado. Como alternativa, puede usar una
instruccin On Error para interceptar y pasar por alto los errores de los controles que
no tienen esa propiedad.

Slo tiene que preocuparse de los controles de su componente, ya que los controles
que no forman parte de l nunca usarn las pginas de propiedades del componente.

"Crear pginas de propiedades para los controles ActiveX" explica el diseo y la

asignacin de las pginas de propiedades con ms detalle.

5. Para activar el botn Aplicar del cuadro de dilogo Pginas de propiedades cuando se
ha modificado la propiedad Caption, agregue el cdigo siguiente al evento Change
del cuadro de texto txtCaption:
Private Sub txtCaption_Change()
' La propiedad Changed de la pgina de
' propiedades controla el botn Aplicar del
' cuadro de dilogo Pgina de propiedades.
Changed = True
End Sub
6. En la ventana Explorador de proyectos, haga doble clic en SLGeneral para traer al
frente el diseador de pginas de propiedades. Haga clic en el botn Cerrar del
diseador o presione Ctrl-F4 para cerrar el diseador y poner la pgina en modo de
ejecucin. Al igual que los objetos UserControl, los objetos PropertyPage deben
ejecutarse mientras el resto del grupo de proyectos est en modo de diseo.

Pgina:50 de 66
Para conectar la pgina de propiedades al control ShapeLabel

1. En la ventana Explorador de proyectos, haga doble clic en ShapeLabel para abrir el

diseador.

2. En la ventana Propiedades, haga doble clic en la propiedad PropertyPages para ver

el cuadro de dilogo Conectar pginas de propiedades.

El cuadro de dilogo Conectar pginas de propiedades se puede usar para

conectar mltiples pginas a un control de usuario y para controlar el orden de
presentacin de las fichas del cuadro de dilogo Pginas de propiedades para el
control.
3. Active SLGeneral y haga clic en Aceptar.

4. Traiga al frente el diseador de ShapeLabel y despus haga clic en su botn Cerrar

o presione Ctrl-F4 para poner el control ShapeLabel en modo de ejecucin.

5. En la ventana Explorador de proyectos, haga doble clic en Form1 para abrir su

diseador.

6. Haga clic con el botn secundario del mouse (ratn) en uno de los controles
ShapeLabel del Form1 para ver el men contextual y haga clic en Propiedades para
presentar el cuadro de dilogo Pginas de propiedades.

7. En el cuadro Caption de la ficha General, sustituya el ttulo actual por un nuevo

valor. Cuando lo hace, se activa el botn Aplicar. Haga clic en el botn Aplicar para
cambiar el ttulo del control.

Nota Tambin puede cambiar el ttulo presionando Aceptar, pero de esta

forma cerrara el cuadro de dilogo Pginas de propiedades. El cuadro de
dilogo debe permanecer abierto para el paso siguiente.

8. Mantenga presionada la tecla CTRL y haga clic en el segundo control ShapeLabel del
Form1, de forma que estn seleccionados ambos controles ShapeLabel. Cambie el
ttulo y haga clic en el botn Aplicar para establecer ambos ttulos al mismo valor.

Pgina:51 de 66
 Si lo desea, pruebe a agregar otros controles, como botones de comando, al Form1 y
observe los efectos de las selecciones mltiples en el cuadro de dilogo Pginas de
propiedades.

9. Cuando haya terminado de experimentar, haga clic en Aceptar para cerrar el cuadro
de dilogo Pginas de propiedades.

Agregar un evento al control ShapeLabel

Es importante distinguir entre los eventos que recibe el objeto UserControl (o los controles
que contiene) y los eventos que desencadena el control. Los eventos que recibe el control
son oportunidades para que usted haga algo interesante, mientras que los eventos que
desencadena el control proporcionan oportunidades para que el programador que usa ese
control haga algo interesante.

Hay muchos eventos que podran ser de inters para el usuario del control ShapeLabel. El
control Label de Visual Basic desencadena un evento Click y ShapeLabel es solamente una
etiqueta atractiva, por lo que el procedimiento siguiente agregar un evento Click. Para
hacer el evento ms interesante, slo se desencadenar si el usuario hace clic en el segundo
plano del valo.

Para agregar un evento Click al control ShapeLabel

1. En la ventana Explorador de proyectos, haga clic en ShapeLabel para seleccionarlo y,

despus, presione F7 o haga clic en el botn Cdigo de la barra de herramientas de
dicha ventana para abrir la ventana Cdigo.

2. En el cuadro Objeto, seleccione (General). En el cuadro Procedimiento, seleccione

(Declaraciones) para colocarse en la parte superior del mdulo de cdigo. Agregue el
cdigo siguiente:

Option Explicit
' Declara un evento Click pblico sin argumentos.
Public Event Click()

3. En el cuadro Objeto, seleccione lblCaption. En el cuadro Procedimiento, seleccione el

evento Click para el control Label. Agregue el cdigo siguiente al procedimiento de
evento lblCaption_Click:

Private Sub lblCaption_Click()

' Desencadena un evento Click siempre que el
' usuario hace clic en la etiqueta.
RaiseEvent Click
End Sub

El cdigo anterior desencadena un evento Click slo si el usuario hace clic en

lblCaption del control componente. Para los usuarios ser ms natural poder hacer
clic en cualquier parte del segundo plano del valo de ShapeLabel; por eso el paso
siguiente muestra cmo desencadenar el evento Click si el usuario hace clic en el
valo coloreado.

4. En el cuadro Objeto, seleccione UserControl. En el cuadro Procedimiento, seleccione

el evento MouseUp de UserControl. Agregue el cdigo siguiente al procedimiento de
evento UserControl_MouseUp:

Private Sub UserControl_MouseUp(Button As Integer, Shift As Integer, X

As Single, Y As Single)
' Desencadena un evento Click slo si el color
' del punto en que se ha hecho clic es igual al

Pgina:52 de 66
 ' color del control Shape. Ignora los clics
' que se hacen fuera del valo.
If Point(X, Y) = shpBack.FillColor Then
RaiseEvent Click
End If
End Sub

Determinar si se ha producido un evento en una ubicacin determinada se conoce

como prueba de llamada.

Cabra esperar que el cdigo de la prueba de llamada se coloque en el procedimiento

de evento shpBack_Click, ya que shpBack vuelve a cambiar de tamao siempre para
cubrir toda la superficie del control ShapeLabel. Pero los controles Shape no reciben
eventos Click. En su lugar, el evento Click lo recibe el objeto que contiene el control
Shape, que en este caso es el objeto UserControl.

"Dibujar el control", en "Crear controles ActiveX", explica el uso de fondos

transparentes para crear controles con forma irregular.

5. En la ventana Explorador de proyectos, haga clic en Form1 para seleccionarlo y,

despus, presione F7 o haga clic en el botn Cdigo de la barra de herramientas de
dicha ventana para abrir la ventana Cdigo.
6. En el cuadro Objeto, seleccione uno de los controles ShapeLabel que ha agregado al
Form1. En el cuadro Procedimiento, seleccione el evento Click.

Nota Si no aparece el evento Click, asegrese de que est cerrado el

diseador de ShapeLabel.

Agregue el cdigo siguiente al procedimiento de evento ShapeLabel1_Click:

Private Sub ShapeLabel1_Click()

MsgBox "Gracias por hacer clic! Mi " & "ttulo es: " &
ShapeLabel1.Caption
End Sub

Nota Si el control ShapeLabel que ha seleccionado no se llama ShapeLabel1, utilice

el nombre apropiado cuando escriba el cdigo anterior.

Puede hacer clic en la flecha del cuadro Procedimiento para ver todos los eventos del
control ShapeLabel. Adems del evento Click, hay otros cuatro eventos (DragDrop,
DragOver, GotFocus y LostFocus) que proporciona automticamente el contenedor,
Form1.

7. En la barra de herramientas, haga clic en el botn Iniciar o presione Ctrl-F5 para

ejecutar TestCtlDemo. Haga clic en varios lugares del formulario y del control
ShapeLabel para comprobar que el evento Click slo se desencadena slo cuando
hace clic dentro del fondo del valo.

8. Hay un fallo sutil en la prueba de llamada para el evento Click de ShapeLabel. Para
verlo, presione el botn del mouse mientras el puntero est en la mitad inferior del
valo rojo. Manteniendo presionado el botn del mouse, mueva con cuidado el
puntero hasta que la punta de la flecha est sobre el texto blanco del ttulo de
ShapeLabel y suelte luego el botn del mouse. El cuadro de mensajes no aparece!

El procedimiento de evento lblCaption_Click no se ejecuta porque el evento

MouseDown se ha producido sobre UserControl. Por tanto, cuando se produce el
evento MouseUp, lo recibe UserControl, aunque el mouse se haya movido hasta estar
completamente fuera de Form1.

El cdigo de la prueba de llamada del evento MouseUp funciona si se suelta el botn

del mouse encima del fondo rojo que asoma a travs del fondo transparente de
lblCaption, pero no funciona si se suelta el botn sobre el color blanco de primer
plano del texto. (Si el botn se suelta fuera de ShapeLabel, la funcin Point devuelve

Pgina:53 de 66
 -1, por lo que soltar el botn del mouse encima de cualquier punto rojo aleatorio no
desencadenar el evento Click.)

Arreglar este fallo se deja como ejercicio para el lector. (Sugerencia: mover la
prueba de llamada al evento Click de UserControl no servir de nada, porque el
evento Click no se produce cuando el evento MouseUp se desencadena sobre un
objeto diferente al del evento MouseDown.)

Compilar el componente ControlDemo

Una vez creado un proyecto de control ActiveX que contiene uno o ms objetos UserControl,
puede compilarlo en un archivo .ocx y usar los controles en otras aplicaciones. Los siguientes
procedimientos muestran la forma de hacerlo.

Para compilar el proyecto ControlDemo

1. Si el proyecto TestCtlDemo est todava en modo de ejecucin, haga clic en el botn

Cerrar del Form1 para volver al modo de diseo.

2. En la ventana Explorador de proyectos, haga clic en ControlDemo para seleccionar el

proyecto.

3. En el men Archivo, haga clic en Generar ControlDemo.ocx para abrir el cuadro de

dilogo Generar proyecto. Haga clic en Aceptar para generar el archivo .ocx.

4. En el men Archivo, haga clic en Quitar proyecto para quitar ControlDemo del grupo
de proyectos, de forma que Visual Basic utilice el componente binario compilado
(archivo .ocx) en lugar del proyecto.

Visual Basic muestra un mensaje de advertencia porque el proyecto TestCtlDemo

contiene una referencia a ControlDemo. Haga clic en S para quitar ControlDemo de
todos modos.

Cuando quita ControlDemo del grupo de proyectos, Visual Basic busca

ControlDemo.ocx en el Registro de Windows. Si existe el archivo .ocx, Visual Basic
actualiza automticamente la referencia que se ha establecido en el procedimiento
"Agregar el proyecto TestCtlDemo".

Para volver a usar el proyecto en lugar del componente binario, puede hacer clic en
Agregar proyecto en el men Archivo y agregar otra vez el proyecto ControlDemo al
grupo de proyectos.

5. Presione F5 para ejecutar TestCtlDemo usando el archivo .ocx.

Cuando ControlDemo se ejecuta desde el cdigo fuente, no puede tener acceso al control
ShapeLabel desde otras aplicaciones o desde otra instancia de Visual Basic. Esto se debe a
que los componentes del control ActiveX tienen que ejecutarse en proceso. Una vez
compilado el componente .ocx, puede probarlo desde otras aplicaciones.

Para usar ControlDemo.ocx en otra instancia de Visual Basic

1. Abra una nueva instancia de Visual Basic. En el cuadro de dilogo Nuevo proyecto,
haga doble clic en el icono EXE estndar para abrir un proyecto .exe.

2. En el men Proyecto, haga clic en Componentes para abrir el cuadro de dilogo

Componentes. En la ficha Controles, active ActiveX Control Creation Demo y haga
clic en Aceptar.

Pgina:54 de 66
 El icono para ShapeLabel aparece en el cuadro de herramientas. Ahora puede
agregar controles ShapeLabel al formulario predeterminado y usar la ventana
Propiedades para establecer sus propiedades. Tambin puede hacer clic con el botn
secundario del mouse en una instancia de ShapeLabel y elegir Propiedades en el
men contextual para modificar las propiedades del control con la pgina de
propiedades.

3. Presione F5 para ejecutar el proyecto.

Tambin puede compilar el proyecto y ejecutar el archivo .exe.

Pgina:55 de 66
 Temas de Programacin Avanzada

Acceder a la API de Windows

La API de Windows, o Interfaz de Programacin de Aplicaciones, es un conjunto de funciones

que Windows expone a los programadores. Estas funciones del Sistema Operativo Windows
pueden ser llamadas desde Visual Basic para realizar tareas que no se pueden programar
mediante cdigo estndar de Visual Basic. Por ejemplo, VB carece de funciones que reinicien
la computadora. No obstante el reinicio se puede hacer a traves de una llamada a la API de
Windows.

Comprender la API de Windows

Desde el punto de vista del programador de Visual Basic, las funciones de la API de Windows
son similares a las funciones normales de VB. Contienen parmetros de entrada y salida y
a veces un valor de retorno. Sin embargo, las funciones de la API ya estn compiladas en un
archivo separado, que se conoce como biblioteca de vnculos dinmicos (o DLL).

Para usar estas funciones, hay que aadir unas cuantas lineas de codigo que definan en
Visual Basic la funcin externa. En otras palabras, para usar una funcion de la API, en primer
lugar hay que declararla. Las declaraciones de la API se introducen en la seccin de
declaraciones de un Mdulo. Al igual que se declaran variables.

La instruccin Declare enumera todos los parmetros de la funcin de la API, la DLL en la

que esta ubicada y el tipo de datos del valor de retorno. Al contrario de lo que ocurre con
una funcin de VB normal , una declaracin de la API no tiene codigo de funcion. En lugar
de ello, la instruccin de lnea nica seala al archivo DLL que contiene la funcin.

Programa de Visual Basic

Archivo DLL del

Sistema
Lineas de declaracin API

Cdigo de Visual Basic

Utilizacin de la API de Windows en un ejemplo simple:

Para demostrar el uso de la API desde Visual Basic, haremos un Proyecto .EXE Estndar

1. Inicie Visual Basic y cree un proyecto .EXE Estndar

Pgina:56 de 66
2. Agregue un Mdulo, haciendo clic en la opcin Agregar Mdulo del Men Proyecto
3. Vaya a la seccin de declaraciones del Mdulo
4. Haga Clic en el Men Complementos y elija Administrador de Complementos y
en la pantalla del Administrador marque las opciones como se muestra en la figura

Esto permitir habilitar el Visor de API de VB6 para facilitar la declaracin de las
funciones de la API de Windows.

Una vez hecho esto, haga clic en Aceptar

5. Nuevamente despliegue el men Complementos y haga clic en la opcin Visor de

API
6. Aparece en pantalla el Visor de API
7. Haga clic en el men Archivo y elija la opcin Cargar Archivo de texto
8. En el cuadro de dialogo Abrir, marque el archivo WIN32API.txt y luego haga clic en
Abrir
9. Una vez hecho esto el visor se cargara con los nombres de las funciones disponibles
(ver imagen de la pagina siguiente)

Pgina:57 de 66
10. Busque la funcin llamada ExitWindowsEx y luego haga clic en el botn Agregar
que est a mano derecha
11. Ahora haga clic en el botn Copiar (parte inferior derecha)
12. Regrese a la pantalla de Visual Basic y en la seccin de declaraciones del modulo,
use la combinacin de tecla CTRL+V para pegar la declaracin

Como Podr observar la declaracin aparece de manera muy extensa y algo

compleja, sin embargo en algunos casos es necesario completar esto con
declaraciones de constantes referidas a la API elegida, debajo de la declaracin de la
funcin, agregue:

Public Declare Function ExitWindowsEx Lib "user32" (ByVal uFlags As

Long, ByVal dwReserved As Long) As Long

Public Const EWX_FORCE = 4

Public Const EWX_LOGOFF = 0
Public Const EWX_REBOOT = 2
Public Const EWX_SHUTDOWN = 1

13. Vaya a su formulario y agregue un botn de comando

14. en el evento clic de dicho botn coloque el siguiente cdigo:

Private Sub Command1_Click()

Dim lRetVal As Long
lRetVal = ExitWindowsEx(EWX_REBOOT, 0)
End Sub

15. Guarde los cambios a su proyecto

16. Ejecute el formulario
17. Su computadora deber estar reinicindose

Pgina:58 de 66
Programacin Cliente/Servidor en Visual Basic
utilizando el Control WinSock

Conceptos Bsicos de Programacin Cliente/Servidor

Un programa simple es un conjunto de instrucciones que generalmente devuelven un valor al
usuario, ya sea numrico o una cadena de letras, este dato es el resultado de la accin del
usuario sobre el programa, ya que el usuario fue el que solicit el dato.

Al igual que un usuario se comunica con un programa por medio del teclado y dos personas
se comunican por medio del telfono, dos programas se pueden comunicar entre s por
medio de sockets. Visual Basic cuenta con un control especial que se denomina WinSock
Control, el cual simplifica la programacin de los sockets para ahorrarle tiempo al
programador. Este control se encuentra bajo el nombre de archivo winsock.ocx, dicho
nombre proviene de Windows Sockets.
El Winsock Control como opcin predeterminada no se encuentra disponible en la barra de
controles estndar de Visual Basic, para acceder a l debemos agregarlo manualmente
mediante Proyecto> Componentes> y luego seleccionar WinSock Control y Aceptar. No es
visible en tiempo de ejecucin, lo que significa que no podremos verlo mientras nuestra
aplicacin se este ejecutando, no obstante podemos modificar sus propiedades en tiempo de
ejecucin.
Este tipo de aplicaciones Cliente-Servidor permiten comunicar programas entre s y en
consecuencia tambin permiten intercomunicar computadoras, porque habiendo un
programa en la computadora llamada Oscar_1 y otro en la computadora llamada
Daniel_1 ambos programas se pueden comunicar a travs de Internet.
Para que el lector entienda por completo y de forma sencilla cul es la estructura del
software Cliente-Servidor vamos a dar un ejemplo bien sencillo y concreto. Un programa
para administrar un cyber-caf es un programa que se basa en la arquitectura Cliente-
Servidor, permitiendo al dueo del local controlar/administrar las computadoras que posee.
El dueo del local puede facturar el tiempo que se utiliz en cada computadora, apagar las
computadoras, reiniciarlas, todo de forma ordenada y sin la necesidad de ir mquina por
mquina. Como si esto no fuera poco adems y por ms increble que parezca el dueo
podra administrar el local desde su casa, a travs de Internet, de la misma forma que lo
hara si estuviese en el local, ya que el programa es el mismo, pero se utiliza a distancia
gracias a la red Internet.

Programas Troyanos

Un troyano es un aplicacin disfrazada de un programa til, consta de dos programas, el

Servidor es el que se encarga de abrir un puerto en la PC a la que se quiere tener acceso y
dejar el puerto a la escucha, es decir, esperando a que se realice una conexin a dicho
puerto para dar acceso a la mquina. Y el Cliente que es el programa que se conecta al
puerto que el Servidor dej abierto, solicita que se realice la conexin y despus comienza a
transmitir informacin, solicitando datos de la PC remota, que pueden ser informacin del
sistema, contraseas, archivos importantes, etc.
Se pueden utilizar de dos formas completamente distintas;

Como herramienta de administracin remota: que permite manipular el sistema a

distancia, ideal para personas que necesitan urgente un archivo de la PC de su oficina y se
encuentran en su casa. Se puede considerar como tal solo cuando el usuario tenga el acceso
permitido a esa PC.

Como herramienta para hackers: (hacking: penetrar un sistema informtico sin

acceso) esta es la forma de utilizacin que prefiere cualquier persona con una conexin a
Internet y ganas de espiar lo que hace otra persona conectada a Internet o a su red privada,
tambin llamada LAN (Local Area Network). Pudiendo acceder a sus archivos confidenciales,
contraseas, recursos compartidos, conversaciones que toman lugar en tiempo real, o borrar
archivos fundamentales tales como por ejemplo: COMMAND.COM (dejando a la PC vctima
sin poder arrancar, a menos que el usuario atacado sepa iniciar desde un disco de
rescate/inicio).

Pgina:59 de 66
Los puertos que se dejan a la escucha generalmente son muy altos, es decir puertos que
pasan del nmero 20000, para garantizar que ningn otro programa pueda estar usndolos y
cancelar la conexin del troyano.
El uso de estos programas no es ilegal a menos que el usuario final opte por entrar a la
mquina remota sin autorizacin. En dicho caso se puede proceder legalmente de acuerdo al
pas en el que se encuentre la PC hacheada/vctima, es decir la computadora a la que se
infiltr el hacker (hacker: persona interesada en el funcionamiento y vulnerabilidad de los
sistemas operativos, lenguajes de programacin y seguridad informtica). Por ejemplo en
EEUU se puede condenar a una larga sentencia por hacer eso, pero tambin hay que conocer
la otra cara de la moneda, es el caso de Argentina, donde todava no esta tipificado en el
cdigo penal la intrusin en computadoras sin autorizacin, esto quiere decir que no es un
delito condenable, a menos que en dicha intrusin se eliminen datos.
Aqu debajo una lista de los troyanos ms conocidos del Underground, es decir de la
sociedad que ronda el hacker, o ms bien todo aquello que sea difcil de encontrar para el
usuario comn. La palabra UnderGround significa debajo de la tierra, lo que para la mayora
significa algo oculto y qu otro ejemplo ms conciso que los programas que usa un hacker.
Cabe aclarar que el uso de estos programas comnmente denominados para hackers no
convierte a nadie pero absolutamente a nadie en hacker. No solo eso, sino que cualquier
persona que se jacte de usar estos programas se ganar el desprecio de los verdaderos
hackers, quienes arduamente programan sus propios programas luego de haber estudiado
aos para hacerlo. El hacker no se hace de la noche a la maana, es ms, el hacker no se
hace, nace

NetBus: Este troyano o herramienta de administracin remota fue uno de los ms

difundidos en Internet, gan un gran nmero de usuarios adictos al programa por su
sencillez de uso y la rapidez del mismo. El tamao del servidor (el encargado de permitir el
acceso a la mquina con o sin autorizacin) parece grande en comparacin con el servidor de
los troyanos actuales.
Tamao del servidor: 495 KB aproximadamente.

Back Oriffice 2000: Sin lugar a duda el troyano que ms pnico caus en los ltimos
tiempos. Fue el preferido de todos por ser el primero que sali en Internet con una facilidad
de uso impresionante y caractersticas que otros troyanos aun no imaginaban, como la
renovada parte grfica entre otras cosas. En la ltima versin del programa se puede notar
que fue programado para funciones de administracin remota, ya que se nota la
programacin estructurada y concisa, sin botones de ms, ni funciones innecesarias para el
usuario final.

SubSeven: Otro troyano que caus un gran impacto, probablemente el ms usado en

la actualidad, ya que el programa servidor ocupa menos aun que el servidor del NetBus o el
Back Oriffice. La parte grfica es distinta a las dems, la complementan un gran juego de
skins (texturas, colores, etc.) y mejor facilidad de uso, adems incluye nuevas funciones
como la desconexin de Internet del equipo remoto, el cuelgue del modem, el cambio de
resolucin de la pantalla, lista de los passwords que se encuentran en el cache (las
contraseas que el usuario escribi recientemente), y los passwords de la conexin
telefnica a redes, es decir la contrasea de Internet si es que la vctima se conecta por
telfono.
Tamao del servidor: 327 KB

Cybersensor: Este troyano esta programado especialmente para funcionar bajo

WindowsNT. No es tan conocido como los anteriores.
Tamao del servidor: 29.5 KB

DeepThroat v2: Este programa tambin es bastante conocido, incluye muchas

funciones muy parecidas al resto de los troyanos, como la de adquirir las contraseas en el
chache de la PC remota y las tpicas funciones que encontramos en el resto.
Tamao del servidor: 304 KB

Dolly Trojan: Excelente troyano, lstima que no se gan el aprecio del pblico porque
el servidor es muy grande.

Girlfriend 1.35: Al contrario del Dolly Troyan este programa es muy pequeo, al igual
que su servidor, por lo tanto no incluye tantas funciones.

Pgina:60 de 66
 InCommand v1.0: Diferente a todos los dems este programa es de tamao medio,
pero lamentablemente no pudo adquirir la atencin del usuario porque no tiene suficientes
funciones.
Tamao del servidor: 168 KB

NetSphere: Nuevamente, al igual que el Dolly este troyano posee un servidor muy
grande por lo que se hace pesado el envo por Internet o por e-mail, lo que lleva a la gente a
buscar una alternativa menos pesada para enviar, recurriendo a otro troyano.
Tamao del servidor: 621 KB

Master Angel 97: Este troyano es uno de los menos conocidos.

Comenzando a Programar con el Control Winsock

Protocolos TCP/IP y UDP

Como anteriormente qued aclarado dos programas se pueden conectar entre s a travs de
internet o de una LAN.
Internet usa el protocolo TCP/IP que significa Transmision Control Protocol / Internet
Protocol, es el que se encarga de recibir paquetes de informacin y redirigirlos al usuario
final que los solicit. Este protocolo es el preferido por todos ya que posee una caracterstica
que UDP le envidia, TCP/IP puede verificar que el paquete de informacin haya llegado con
xito al destinatario final, concretando as la transaccin.
Por el contrario UDP no puede hacer esto, solo manda el paquete con la informacin y no
verifica que haya llegado satisfactoriamente, poniendo de esta manera en peligro al paquete,
ya que puede no llegar entero al destinatario y por lo tanto no sirve si el paquete no llega en
su totalidad.
Todas las mquinas que estn conectadas a Internet tienen asignadas una direccin IP que
es nica, ya que cada proveedor de servicios de Internet tiene asignado un rango de
nmeros IP para sus clientes. Los nmeros IP estan compuestos por 4 grupos de 3 dgitos
cada uno. Cada grupo no puede superar el nmer 255. La mxima direccin que se puede
formar es: 255.255.255.255

Propiedades, mtodos y eventos de WinSock.

Una vez que tenemos el WinSock control en nuestra barra de controles en Visual Basic
podemos comenzar a ver las propiedades, eventos y mtodos ms importantes del control.
Para agregarlo manualmente ir a Proyecto> Componentes> y luego seleccionar WinSock
Control y Aceptar. Como mencionamos anteriormente este control no es visible en tiempo de
ejecucin.

Primero abrimos un proyecto (EXE Estndar) y colocamos en control en cualquier parte del
formulario. Vamos a comenzar por ver las propiedades, estas pueden ser establecidas en
tiempo de diseo como tambin en tiempo de ejecucin. A continuacin se muetran las
propiedades ms importantes.

Lista de propiedades ms importantes:

LocalIP: Devuelve la direccin IP de la mquina local en el formato de cadena con puntos de
direccin IP (xxx.xxx.xxx.xxx).

LocalHostName: Devuelve el nombre de la mquina local.

RemoteHost: Establece el equipo remoto al que se quiere solicitar la conexin.

LocalPort: Establece el puerto que se quiere dejar a la escucha.

RemotePort: Establece el nmero del puerto remoto al que se quiere conectar.

State: Verifica si el Control WinSock esta siendo utilizado o no.

Pgina:61 de 66
Estas son algunas de las propiedades ms importantes, y a continuacin la sintaxis de cada
propiedad.
Objeto.Propiedad = Valor

Donde Objeto va el nombre del Control WinSock, el nombre predeterminado cuando lo

incluimos en alguna aplicacin es WinSock1. Luego le sigue la propiedad que deseamos
asignar y finalmente el valor que la misma tomar.

Entonces por ejemplo si queremos probar la propiedad LocalIP debemos seguir el ejemplo 1.

Ejemplo 1
Crear un Proyecto (EXE Estndar) y agregar el WinSock Control. Luego agregar una etiqueta
vaca, es decir un Label. Despus introducimos el siguiente cdigo.

Private Sub Form_Load()

Label1.caption = WinSock1.LocalIP
End Sub

Este simple ejemplo nos muestra de forma rpida nuestro nmero IP. Si no estamos
conectados a Internet nuestro nmero IP es 127.0.0.1 (es un nmero que se reserva la placa
de red para pruebas internas). Podemos usar este nmero IP cuando queramos probar
nuestras propias aplicaciones Cliente-Servidor sin tener que recurrir a otra computadora, es
decir, ejecutar tanto el Server como el Cliente en una misma PC.
Ahora que sabemos manejar las propiedades podemos seguir con los Mtodos. A
continuacin la lista de algunos de los Mtodos ms importantes del Control WinSock.

Lista de Mtodos ms importantes

Accept: Slo para las aplicaciones de servidor TCP. Este mtodo se utiliza para aceptar una
conexin entrante cuando se est tratando un evento ConnectionRequest.

GetData: Recupera el bloque actual de datos y lo almacena en una variable de tipo Variant.

Listen: Crea un socket y lo establece a modo de escucha.

SendData: Enva datos a un equipo remoto.

Lista de Eventos ms importantes

ConnectionRequest: Se produce cuando el equipo remoto solicita una conexin. Sin este
evento no se puede llevar a cabo la coneccin.

Connect: Se produce cuando el equipo local se conecta al equipo remoto y se establece una
conexin.

Close: Se produce cuando el equipo remoto cierra la conexin. Las aplicaciones deben usar el
mtodo Close para cerrar correctamente una conexin TCP.

DataArrival: Se produce cuando llegan nuevos datos. Este evento es importante, ya que
debemos hacer algo con la informacin que llega.

La sintaxis de los mtodos y eventos es igual a la sintaxis de las propiedades, por lo cual no
vamos a hacer referencia a ella.

Programando la primera aplicacin Cliente/Servidor.

Pgina:62 de 66
Conociendo las propiedades, mtodos y eventos del Control WinSock podemos pasar a la
engorrosa labor de la programacin.
Para poder programar la siguiente aplicacin necesitan tener el Control WinSock en el
formulario (no importa el lugar), asegrese de tenerlo ya que es fundamental para que el
programa funcione correctamente.
Para entender el correcto funcionamiento del protocolo TCP/IP vamos a empezar por
programar la aplicacin Servidor a la cual luego se conectar el Cliente.
Comenzamos por crear un proyecto nuevo (EXE estndar) para el Servidor, y agregamos la
siguiente lista de controles al formulario principal. La ubicacin de dichos controles es a
gusto del programador, siempre tratando de que el usuario final este a gusto con el producto
y que se pueda manejar libremente sin problemas por el entorno del mismo.

o WinSock Control
o 2 cajas de texto (Text Box)
o 2 botones (Command Button)

A continuacin hace falta que cambiemos algunas propiedades de los controles, debajo la
lista de controles con las respectivas propiedades a cambiar.

Control (nombre predeterminado) Propiedad (nuevo valor)

WinSock1 LocalPort = 888
Text1 Text =
Text2 Text =
Command1 Caption = Escuchar
Command2 Caption = Enviar

Para orientar mucho mejor al programador que esta leyendo este tutorial incluimos
imgenes del formulario para que se puedan guiar en caso de que lo necesiten, si no lo
necesitan pueden ubicar los controles a su gusto.

Una vez hecho esto podemos empezar a tipear cdigo. El sangrado del programa (espacio
entre el cdigo y el margen) es una cuestin de entendimiento/comprensin para el
programador, algunos recurren a ste como otros no, eso tambin queda a criterio de la
persona que programa.

En el Evento Click del Command1 incluimos el siguiente cdigo; (slo lo que esta en negrita,
el resto es en modo de ayuda, ya que aparece cuando se hace doble click en algn control).

Private Sub Command1_Click()

Winsock1.Listen

Pgina:63 de 66
End Sub

Esto hace que el Control WinSock empiece a funcionar, escuchando el puerto que se indic
anteriormente en las propiedades de dicho control. Este puerto es el 888. Si seguimos los
pasos anteriores correctamente entonces el puerto 888 esta siendo vigilado/escuchando para
aceptar conexiones remotas.

Luego en el Evento DataArrival del WinSock

Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long)

Dim datos As String
Winsock1.GetData datos
Text1.Text = Text1.Text + datos
End Sub

Datos queda transformada en una variable de cadena, y WinSock almacena la informacin

que recibe del Cliente en el buffer (zona de memoria) y luego ingresan a la variable datos.
Posteriormente el contenido de dicha variable (datos) se mostrar en el objeto TextBox1
(Text1).

En el evento ConnectionRequest

Private Sub Winsock1_ConnectionRequest(ByVal requestID As Long)

Winsock1.Close
Winsock1.Accept requestID
End Sub

Este evento es muy importante, permite aceptar la peticin de conexin. Sin este evento el
resto del programa no tendra efecto.

En el evento Click del command2

Private Sub Command2_Click()

Dim enviar As String
enviar = Text2.Text
Winsock1.SendData enviar
End Sub

Esto permite enviar el texto que se introduzca en el TextBox2 (text2).

Por ahora este es un simple programa Servidor, lo que hace es: designar un puerto, dejarlo
a la escucha para aceptar conexiones, si se realiza una peticin de conexin la acepta, y por
ltimo enva datos al Cliente y recibe los datos que ste enve.
Para seguir programando el Cliente hace falta crear un nuevo proyecto y en el formulario
principal incluir la siguiente lista de controles:

o WinSock Control
o 3 cajas de texto (Text Box)
o 2 botones (Command Button)

Como lo hicimos anteriormente hace falta cambiar algunas propiedades. Debajo la lista de
controles con las respectivas propiedades para cambiar.

Control (nombre predeterminado) Propiedad (nuevo valor)

WinSock1 RemotePort = 888
Text1 Text =

Pgina:64 de 66
Text2 Text =
Text3 Text =
Command1 Caption = Conectar
Command2 Caption = Enviar

Para tener una referencia de cmo situar los controles conviene seguir la Figura siguiente

En el evento del command1

Private Sub Command1_Click()

Winsock1.RemoteHost = Text3.Text
Winsock1.Connect
End Sub

El evento Connect nos permite conectarnos al programa servidor que esta esperando nuestra
solicitud. Este evento requiere un parmetro fundamental, el nmero IP o nombre de host, el
cual es introducido previamente a la conexin en TextBox3 (Text3).

En el evento DataArrival del WinSock Control

Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long)

Dim datos As String
Winsock1.GetData datos
Text1.Text = Text1.Text + datos
End Sub

Esto permite a la aplicacin (a travs de WinSock) recibir informacin del servidor y

mostrarla en pantalla.

En el mtodo del command2;

Private Sub Command2_Click()

Dim enviar As String
enviar = Text2.Text
Winsock1.SendData enviar
End Sub

Estas instrucciones son necesarias para enviar informacin al servidor.

Pgina:65 de 66
Este es un ejemplo muy sencillo de la arquitectura Cliente-Servidor. Si desean pueden
establecer la propiedad Multiline en TRUE para los TextBox, la cual ordena la informacin
recibida en los TextBox para que se pueda leer ms fcilmente.

Bibliografa
Baltazar & Mariano Birnios, Creacin de Aplicaciones Multimedia con Visual Basic, editorial MP
Ediciones, primera edicin, Buenos Aires, 1998.

Baltazar & Mariano Birnios, Microsoft Visual Basic Manual de Referencia, editorial MP
Ediciones, primera edicin, Buenos Aires, 1999.

(En Ingls)
http://msdn.microsoft.com/vb
http://www.vb-herlper.com
http://www.vbexplorer.com
http://www.cgvb.com
http://www.vb-world.net
http://www.planet-source-code.com/vb
http://www.programmersheaven.com/

(En Castellano)
http://www.programacion.net/
http://www.abcdatos.com
http://www.monografias.com

Tambin se puede consultar la ayuda en lnea de Microsoft Developer Network (MSDN) o

consultarla desde los CDs del Visual Studio.

Pgina:66 de 66