Introducción al Curso

Visual Basic se ha convertido en un importante entorno de desarrollo que cubre todos los aspectos de la programación profesional, desde las aplicaciones financieras a la construcción de componentes para Internet. En la actualidad puede considerarse como la herramienta por excelencia para la programación en entornos Windows, gracias a su potencia, comparable a la de lenguajes tradicionalmente considerados superiores como C o C++, pero fundamentalmente por su sencillez y facilidad de uso.

Este manual está dirigido a aquellas personas que, teniendo nociones básicas de Visual Basic, deseen adquirir conocimientos sólidos de los principios y técnicas involucradas en el desarrollo de aplicaciones con este entorno de desarrollo. En concreto, en este curso se darán las bases para adquirir conocimientos en:

· Clases y objetos

· Tecnología active X

· Acceso a bases de datos (DAO, JET, ODBC-DIRECT, RDO)

· El registro de Windows

Si bien en todos los capítulos se expondrán los conocimientos teóricos que los autores hemos estimado suficientes para desenvolverse con soltura en cada tema propuesto, este manual no pretende ser un libro de referencia de Visual Basic (para eso existen multitud de libros técnicos, o la propia ayuda de Visual Basic). Los autores hemos preferido limitar en la medida de lo posible la carga teórica del manual, potenciando el aspecto práctico con la inclusión de ejemplos propuestos y resueltos, totalmente funcionales, que ayudarán al lector en la comprensión de los contenidos del curso.

Todos los capítulos de este manual siguen la misma estructura:

· Una introducción en la que se expondrán los temas a tratar y el objetivo del capítulo.
· Conocimientos teóricos del capítulo.
· Un ejemplo en el que se ponen en práctica los conocimientos recién adquiridos
· Y por supuesto, una solución al ejemplo propuesto.

Visual Basic proporciona una gran cantidad de elementos que permiten aumentar la potencia de nuestras aplicaciones considerablemente. Aunque el estudio individual de dichos objetos se escapa al propósito de este curso, en los ejemplos iremos proponiendo el uso de diferentes tipos de objetos para ir aumentando nuestro vocabulario en Visual Basic.

1. Formularios y eventos

Introducción

El primer paso para crear una aplicación con Visual Basic es crear la interfaz, la parte visual de la aplicación con la que va a interactuar el usuario. Los formularios y controles son los elementos de desarrollo básicos que se usan para crear la interfaz; son los objetos con los que se trabaja para desarrollar la aplicación.

Los formularios son objetos que exponen las propiedades que definen su apariencia, los métodos que definen su comportamiento y los eventos que definen la forma en que interactúan con el usuario. Mediante el establecimiento de las propiedades del formulario y la escritura de código de Visual Basic para responder a sus eventos se personaliza el objeto para cubrir las necesidades de la aplicación.

Todos los lenguajes de programación para Windows comparten la misma característica: la orientación a eventos. Las aplicaciones creadas para Windows no siguen una estructura de ejecución lineal. Esto implica que un programa no va a seguir una secuencia fija de instrucciones, ejecutándose línea a línea, sino que debe responder a las acciones que el usuario, el sistema operativo u otras aplicaciones realizan sobre él; estas acciones se conocen en Visual Basic como eventos.

Todos los elementos que podemos utilizar en la construcción de una aplicación en Visual Basic (formularios, controles ActiveX, etc) reciben unos eventos predeterminados como GetFocus, LostFocus o Activate. Podemos controlar estos eventos introduciendo el código que deseemos en la correspondiente subrutina de atención al evento.

El objetivo de este capítulo es recordar los conocimientos básicos, pero imprescindibles, para el manejo de formularios en Visual Basic. Haremos incapié en el concepto de formulario como objeto, con sus propiedades, métodos y eventos. Se comprobará que un formulario sólo se elimina de memoria cuando se eliminan todas las referencias al mismo, exáctamente igual que cualquier objeto. Comentaremos especialmente los eventos que puede recibir un formulario, tanto en el proceso de carga como en la ejecución de la aplicación y en el proceso de descarga del mismo.

Conocimientos teóricos

Formularios, controles y eventos

Los formularios y controles de Visual Basic son objetos que exponen sus propios métodos, propiedades y eventos. Las propiedades se pueden considerar como atributos de un objeto, los métodos como sus acciones y los eventos como sus respuestas.

Un objeto de uso diario como el globo de un niño tiene también propiedades, métodos y eventos. Entre las propiedades de un globo se incluyen atributos visibles como el peso, el diámetro y el color. Otras propiedades describen su estado (inflado o desinflado) o atributos que no son visibles, como su edad. Por definición, todos los globos tienen estas propiedades; lo que varía de un globo a otros son los valores de estas propiedades.

Un globo tiene también métodos o acciones inherentes que puede efectuar. Tiene un método inflar (la acción de llenarlo de helio) o un método desinflar (expeler su contenido) y un método elevarse (si se deja escapar). De nuevo, todos los globos pueden efectuar estos métodos.

Los globos tienen además respuestas predefinidas a ciertos eventos externos. Por ejemplo, un globo respondería al evento de pincharlo desinflándose o al evento de soltarlo elevándose en el aire.

Como objetos que son, los formularios pueden ejecutar métodos y responder a eventos.

El evento Resize de un formulario se desencadena siempre que se cambia el tamaño de un formulario, ya sea por una acción del usuario o a través del código. Esto permite realizar acciones como mover o cambiar el tamaño de los controles de un formulario cuando han cambiado sus dimensiones.

El evento Activate se produce siempre que un formulario se convierte en el formulario activo; el evento Deactivate se produce cuando otro formulario u otra aplicación se convierte en activo. Estos eventos son adecuados para iniciar o finalizar acciones del formulario. Por ejemplo, en el evento Activate podríamos escribir código para resaltar el texto de un determinado cuadro de texto; con el evento Deactivate podríamos guardar los cambios efectuados en un archivo o en una base de datos.

Para hacer visible un formulario se invoca el método Show. Por ejemplo, la sentencia

Form1.Show

mostraría el formulario Form1. Invocar el método Show tiene el mismo efecto que establecer a True la propiedad Visible del formulario.

Ciclo de vida de un formulario

Comprender el ciclo de vida de un formulario es básico para el programador de Visual Basic, puesto que son estos elementos los que permitirán al usuario interactuar con la aplicación. Sólo comprendiendo qué acciones podrán realizarse sobre los formularios y en qué momentos podremos controlar adecuadamente la ejecución de nuestros programas.

En la vida de un formulario puede pasar por cinco estados diferentes. En orden cronológico son:

Creado: el formulario existe como objeto, pero todavía no es visible. Cuando un formulario está siendo creado, se genera el evento Initialize. En esta fase del proceso de carga de un formulario no podemos actuar sobre los objetos que lo componen.
Cargado: ya podemos acceder a los controles del formulario, pero éste no es visible. Un formulario se encuentra en este estado en el proceso de carga, cuando se oculta o cuando se establece a False su propiedad Visible. Cuando se inicia el proceso de carga de un formulario, se genera el evento Load.
Mostrado: el estado normal de un formulario. Podemos acceder a todos los elementos que lo componen y podemos actuar sobre ellos, pues el formulario es visible. Durante este estado, cada vez que hay que repintar el formulario (por ejemplo, cuando una ventana que se ha situado sobre éste desaparece) se genera el evento Paint. Además, si el formulario recupera el foco después de haberlo perdido (por ejemplo, al cambiar a otra aplicación con Alt+Tab y volver después al formulario), se genera el evento Activate.
Descargado: una vez terminado este proceso el formulario no es visible, y sus componentes no son accesibles. El proceso de descarga se produce cuando se cierra el formulario (pulsando el botón , ejecutando el método Unload del formulario, etc). El proceso de descarga de un formulario, a su vez, generará dos eventos: QueryUnload y Unload (en este orden). En los dos eventos podemos detener el proceso de descarga estableciendo el valor del parámetro Cancel a cualquier número distinto de 0. En general, aprovecharemos estos eventos para liberar la memoria ocupada por los elementos que pertenecen al formulario antes de que este se cierre, salvar el trabajo que esté pendiente de guardado, etc.
Eliminado: aunque un formulario esté descargado, mientras existe cualquier referencia al mismo no será eliminado totalmente de memoria. Cuando se produce esta circunstancia (el formulario está descargado y nadie hace referencia a él) se genera el evento Terminate, y el formulario desaparece de memoria.

La ventana Debug

Si bien este elemento del entorno de desarrollo de Visual Basic no tiene una relación directa con el tema que se trata en este capítulo, queremos recordar su funcionalidad, puesto que para el programador es una herramienta importante en el proceso de desarrollo de una aplicación.

En dicho proceso es necesario disponer de un elemento donde poder mostrar mensajes, valores de variables, etc. que nos ayuden en la depuración de los programas. El objeto Debug de Visual Basic nos permite escribir en la pantalla Inmediato (Debug®Inmediate Window) utilizando el método Print.

También podemos comprobar el valor de una variable si utilizamos la sentencia

?nombre_variable

en la ventana Inmediato, o establecer dicho valor con la sentencia

nombre_variable=valor

Ejemplo propuesto

Con este ejemplo veremos los estados por los que pasa un formulario durante su ciclo de vida. Además, comprobaremos cómo un formulario no se elimina de memoria hasta que no se liberan todas las referencias al mismo en el programa.

1. Crearemos los siguientes formularios

2. En el formulario 1, insertaremos código en las subrutinas Initialize, Load, Activate, Paint, QueryUnload, Unload y Terminate, para que cada vez que se lance el evento correspondiente mostremos en la ventana Debug el formulario sobre el que se ha generado el evento y el nombre del evento.

3. Añadiremos código en el Click del botón para mostrar el formulario 2. También mantendremos una referencia al formulario 2 (para evitar que se lance su evento Terminate al cerrarse).

4. Insertaremos código en las subrutinas Load, Unload y Terminate del formulario 2, para mostrar en la pantalla Debug el formulario y el evento que se produce en cada caso.

Ejemplo resuelto

Formulario 1

'_________________________________________________________________

' Ejemplo 1 del Curso de Visual Basic Avanzado

'' El objetivo de este ejemplo es reconocer los eventos que un

' formulario puede recibir, así como el orden en el que se

' reciben

'_________________________________________________________________

Option Explicit

Private Sub Command1_Click()

Dim FrmNuevoFormulario As Form

' Guardamos un enlace al formulario 2, para que no

' salte su Terminate cuando lo cerremos (saltará

' el Terminate del formulario 2 cuando salte el

' Terminate del formulario 1 y se pierda la referencia

' al segundo formulario)

Set FrmNuevoFormulario = Formulario2

FrmNuevoFormulario.Show

End Sub

Private Sub Form_Activate()

Debug.Print "Formulario1: Evento Activate"

End Sub

Private Sub Form_Initialize()

Debug.Print "Formulario1: Evento Initialize"

End Sub

Sub Form_Load()

Debug.Print "Formulario1: Evento Load"

End Sub

Private Sub Form_QueryUnload(Cancel As Integer, UnloadMode As Integer)

Debug.Print "Formulario1: Evento QueryUnload"

End Sub

Private Sub Form_Paint()

Debug.Print "Formulario1: Evento Paint"

End Sub

Private Sub Form_Terminate()

Debug.Print "Formulario1: Evento Terminate"

End Sub

Private Sub Form_Unload(Cancel As Integer)

Debug.Print "Formulario1: Evento Unload"

End Sub

Formulario 2

'_________________________________________________________________

' Ejemplo 1 del Curso de Visual Basic Avanzado

'' El objetivo de este ejemplo es reconocer los eventos que un

' formulario puede recibir, así como el orden en el que se

' reciben

'_________________________________________________________________

Option Explicit

Private Sub Form_Load()

Debug.Print "Formulario2: Evento Load"

End Sub

Private Sub Form_Terminate()

Debug.Print "Formulario2: Evento Terminate"

End Sub

Private Sub Form_Unload(Cancel As Integer)

Debug.Print "Formulario2: Evento Unload"

End Sub

2. Identificación de objetos (controles) en un formulario

Introducción

Los controles son objetos que están contenidos en los objetos de formularios. Cada tipo de control tiene su propio conjunto de propiedades, métodos y eventos, que lo hacen adecuado para una finalidad determinada. Algunos de los controles que puede usar en las aplicaciones son más adecuados para escribir o mostrar texto, mientras que otros controles permiten tener acceso a otras aplicaciones y procesan los datos como si la aplicación remota formara parte del código.

Este capítulo presenta los conceptos básicos del trabajo con formularios y controles, y las propiedades, métodos y eventos que tienen asociados. Se explican también algunos de los controles estándar, y cómo es posible diferenciar en tiempo de ejecución los tipos de controles utilizados en nuestros formularios.

Conocimientos teóricos

Cómo utilizar controles: eventos y propiedades

Un evento es una acción reconocida por un formulario o un control, es decir, un suceso que ha sido provocado por el usuario, el sistema operativo u otros programas en ejecución y que repercute en un elemento de nuestra aplicación. Por ejemplo, son eventos la pulsación de una tecla o el paso del puntero de ratón sobre un objeto. A través de los eventos podemos determinar el comportamiento del objeto con su entorno.). Las aplicaciones controladas por eventos ejecutan código Basic como respuesta a un evento. Cada formulario y control de Visual Basic tiene un conjunto de eventos predefinidos. Si se produce uno de dichos eventos y el procedimiento de evento asociado tiene código, Visual Basic llama a ese código.

Aunque los objetos de Visual Basic reconocen automáticamente un conjunto predefinido de eventos, nostros decidimos cuándo y cómo se responderá a un evento determinado. A cada evento le corresponde una sección de código (un procedimiento de evento). Cuando deseamos que un control responda a un evento, escribimos código en el procedimiento de ese evento.

Los tipos de eventos reconocidos por un objeto varían, pero muchos tipos son comunes a la mayoría de los controles. Por ejemplo, la mayoría de los objetos reconocen el evento Click: si un usuario hace clic en un formulario, se ejecuta el código del procedimiento de evento Click del formulario; si un usuario hace clic en un botón de comando, se ejecuta el código del procedimiento de evento Click del botón. El código en cada caso será diferente.

Las propiedades de los controles determinan su aspecto, cómo se mostrará al usuario. Estas propiedades definen sus atributos: color, tamaño, forma, etc. Al igual que en el caso de los eventos, los objetos de Visual Basic comparten una serie de propiedades comunes, como Name o Visible, y otras específicas de su tipo.

Controles comunes: Label, TextBox, CommandButton, CheckBox

En Visual Basic hay un conjunto de controles comunes que son usados en la gran mayoría de aplicaciones. En la siguiente tabla se muestra el uso normal de estos controles:

Identificar el tipo de un control

Existen dos funciones que nos permiten identificar el tipo de control que estamos tratando: TypeName y TypeOf

La función TypeName nos permite conocer el nombre de la clase a la que pertenece un objeto, lo que nos posibilita adecuar el código que escribimos al tipo de objeto que estemos tratando, así como crear funciones generales para diversos tipos de controles.

Si tenemos un botón (CommandButton1) en nuestro formulario, utilizando la sentencia

TypeName (CommandButton1)

Obtendríamos la cadena "CommandButton", es decir, la clase a la que pertenece el botón.

La función TypeOf es algo más restrictiva. Debe ir en una sentencia de condición (una sentencia del tipo if ... then ....). Esta función nos permite identificar la clase a la que pertenece el objeto, para poder operar en consecuencia.

Un ejemplo de uso sería:

If TypeOf MiControl Is CommandButton Then

...

else

...

endif

Colección Controls de un formulario

Un formulario no es más que un lienzo donde se pintan controles. Es decir, podemos entender un formulario como un objeto que posee una colección de controles. Esta colección se llama Controls.

Podemos acceder a cada uno de los controles de un formulario a través de esta colección. Sin necesidad de conocer a priori su nombre, bastaría recorrer toda la colección y hacer una rutina para lanzar el código a ejecutar para cada tipo de controles del formulario.

Ejemplo propuesto

En este ejemplo distinguiremos los tipos de objetos que tiene un formulario, accediendo a las propiedades del objeto en el que nos encontremos durante el recorrido de la colección de objetos.

1. Crearemos el siguiente formulario:

2. En el Load del formulario, insertaremos código para que una vez cargado el formulario tengamos en la ventana de Debug el nombre y el tipo de todos los objetos que se han cargado.

3. En función del tipo de objeto, cambiaremos su color de fondo:

· Label: rojo

· CheckBox: verde

· TextBox: azul

· CommandButton: amarillo

Nota: para poder cambiar el color de fondo de un CommandButton, es necesario establecer a 1 (Graphical) su propiedad Style.

Ejemplo resuelto

'_____________________________________________________

' Ejemplo 2 del Curso de Visual Basic Avanzado

'' El objetivo de este ejemplo es identificar los objetos contenidos

' en un formulario y operar con ellos en función de su tipo.

'_________________________________________________________________

Option Explicit

Private Sub Form_Load()

Dim ObjControl As Object

' Recorremos todos los controles del formulario

For Each ObjControl In Me.Controls

' En función del tipo de control, cambiaremos su color de

' fondo

Select Case TypeName(ObjControl)

Case "Label"

ObjControl.BackColor = vbRed

Case "TextBox"

ObjControl.BackColor = vbBlue

Case "CheckBox"

ObjControl.BackColor = vbGreen

Case "CommandButton"

ObjControl.BackColor = vbYellow

End Select

' Sacaremos su nombre y tipo de objeto a la pantalla

' Debug

Debug.Print TypeName(ObjControl) & ": " & ObjControl.Name

Next ObjControl

End Sub

3. Clases y objetos (I)

Introducción

Hasta ahora hemos visto los objetos que proporciona Visual Basic, pero nosotros también podemos crear objetos. En este capítulo se darán los conocimientos básicos necesarios para entender cómo podemos utilizar objetos en Visual Basic.

Cada objeto de Visual Basic se define mediante una clase. Podemos entender las clases como un "modelo conceptual" de los objetos. Para comprender la relación entre un objeto y su clase, podemos pensar en un cubo de playa y un castillo de arena. El cubo es la clase. Define las características de cada castillo de arena, como su tamaño y forma. Se utiliza la clase para crear (instanciar) objetos. Los objetos son los castillos de arena y como era de esperar todos tienen las mismas propiedades y eventos.

En el capítulo anterior hemos hablado de las propiedades y los eventos de un objeto. Pero además de estas características los objetos proporcionan un conjunto de métodos, que determinan las acciones que el objeto puede realizar.

La programación orientada a objetos proporciona un enfoque totalmente distinto al utilizado en la programación clásica (estructuras, tipos de datos, programación secuencial...). Bien aplicada, la programación orientada a objetos minimiza el tiempo dedicado a la depuración de los programas, y facilita la reutilización del código.

Así mismo este modelo de programación nos permite controlar qué características de nuestros objetos son visibles para las aplicaciones que los utilizan, lo que se denomina encapsulación.

Conocimientos teóricos

Los objetos en Visual Basic

Los objetos están encapsulados; es decir, contienen su propio código y sus propios datos, lo cual facilita su mantenimiento más que los métodos de escritura de código tradicionales.

Los objetos de Visual Basic tienen propiedades, métodos y eventos. Las propiedades son los datos que describen un objeto. Los métodos son lo que puede hacer con el objeto. Los eventos son tareas que realiza el objeto; podemos escribir código para ejecutarlo cuando se produzcan eventos.

Los objetos de Visual Basic se crean a partir de clases; así, un objeto se dice que es una instancia de una clase. La clase define las interfaces de un objeto, si el objeto es público y en qué circunstancias se puede crear.

Para utilizar un objeto tiene que mantener una referencia a él en una variable de objeto. El tipo de enlace determina la velocidad con la que se tiene acceso a los métodos de un objeto mediante la variable de objeto. Una variable de objeto puede ser un enlace en tiempo de compilación (el más lento) o un enlace en tiempo de diseño.

Al conjunto de propiedades y métodos se le llama interfaz. La interfaz predeterminada de un objeto de Visual Basic es una interfaz dual que admite las formas de enlace anteriormente mencionadas. Si una variable de objeto está correctamente definida (es decir, Dim … As nombre_clase), utilizará la forma más rápida de enlace.

Además de su interfaz predeterminada, los objetos de Visual Basic pueden implementar interfaces adicionales para proporcionar polimorfismo. El polimorfismo le permite manipular muchos tipos deferentes de objetos sin preocuparse de su tipo. Las interfaces múltiples son una característica del Modelo de objetos componentes (COM); permiten que los programas evolucionen con el tiempo, agregando nueva funcionalidad sin afectar al código existente.

Concepto de encapsulación (Public v.s. Private)

Una de las características más importantes de la programación orientada a objetos es el concepto de encapsulación: un objeto bien desarrollado es aquel que puede ser utilizado por otros elementos de forma eficiente, pero sin que éstos conozcan cómo funciona internamente. Esto nos permite cambiar la forma en que un objeto funciona sin que los elementos que utilizan el objeto noten dicho cambio.

En Visual Basic, las propiedades y métodos de una clase pueden ser de dos tipos:

· Public: accesibles por cualquier elemento del proyecto.

· Private: accesibles sólo por los elementos de la clase donde están definidos.

Utilización de variables de objeto

Utilizar una variable de objeto es similar a utilizar una variable convencional, pero con un paso adicional: asignar un objeto a la variable.

Primero, declararemos la variable con una sentencia

Dim variable As clase

Luego, asignaremos un objeto a esa variable, utilizando la instrucción Set:

Set variable = objeto

Pero atención: el objeto ha de existir para poder ser asignado a una variable de objeto. Es decir, previamente hemos tenido que utilizar la instrucción New, bien en la misma sentencia en la que declaramos la variable de objeto:

Dim variable As New Clase

O bien en otro lugar del código:

Set variable = New Clase

La sentencia New crea una instancia de la clase especificada (es decir, crea un objeto nuevo a partir del modelo que es la clase).

Cuando ya no sean de utilidad necesitamos liberar la memoria y los recursos que los objetos consumen. En la mayoría de los casos el sistema operativo se encargará de esta tarea si se nos olvida a nosotros, pero no hay que confiarse (podéis imaginar el rendimiento de una máquina en la que tengamos, por ejemplo, 5 instancias de Word al mismo tiempo...). Para liberar la memoria y los recursos que consume un objeto utilizaremos la sentencia:

Set variable = Nothing

Instrucción Property

Como se mencionó anteriormente, es deseable que un elemento externo a un objeto no pueda acceder de forma incontrolada a sus propiedades. Podemos controlar esto creando todas las propiedades de tipo Private, pero... ¿y si queremos que sean accesibles por los elementos que utilicen el objeto, pero sin arriesgarnos a que éstos realicen acciones no permitidas?. Por ejemplo, podemos necesitar que el TPV (Terminal Punto de Venta) de una tienda pueda modificar el saldo de una tarjeta (lo que se correspondería con la compra de un cliente); sin embargo, no tiene sentido que dicho TPV permita al vendedor comprobar el saldo de la cuenta del cliente, o hacer una transferencia a su propia cuenta.

Visual Basic permite acceder y modificar el valor de una propiedad privada a través de los procedimientos de propiedad o Property.

Se proporcionan tres tipos de procedimientos:

Normalmente se define una pareja Property Get/Property Let por cada propiedad privada de una clase. Property Get nos permite acceder al valor almacenado en dicha propiedad, mientras que Property Let nos posibilita asignarle un valor.

Property Set también permite establecer el valor de una propiedad privada. La diferencia entre este procedimiento y Property Let es el modo en el que se asigna valor a la propiedad. Visual Basic llama a Property Set si se utiliza la instrucción Set y a Property Let en caso contrario.

Esta propiedad se utiliza para matener el estándar de los objetos, ya que para asignarles un valor se usa la palabra reservada Set.

Variables estáticas

Aunque este tema no está directamente relacionado con el tema del capítulo, queremos recordar este concepto para poder aplicarlo en el ejemplo propuesto.

La vida de una variable está directamente relacionada con la forma y el lugar donde se declara. El valor de las variables declaradas a nivel de módulo y públicas se preserva durante todo el tiempo de ejecución. Sin embargo, las variables locales declaradas con Dim sólo existen mientras se ejecuta el procedimiento en el cual se han declarado. La próxima vez que se ejecute el procedimiento se reinicializarán todas sus variables locales.

Sin embargo es posible preservar el valor de una variable local si se declara como estática, utilizando la palabra clave Static:

Static nombre_variable as tipo_dato

Ejemplo propuesto

El objetivo de este ejemplo es conocer el proceso de creación e instanciación de una clase en Visual Basic. También se pretende que el lector se familiarice con el ciclo de vida de un objeto y la necesidad de liberar la memoria asociada con cada uno de los objetos creados.

Para practicar estos conceptos crearemos una agenda telefónica básica.

1. Diseñaremos el siguiente formulario:

2. Definiremos una clase Ficha con cinco propiedades: nombre, apellidos, dirección, teléfono y número. Para cada una de las propiedades crearemos sus correspondientes métodos de propiedad Property Get y Property Let.

3. Implementaremos también un método Muestra() que muestre mediante un msgbox el valor de las propiedades de un objeto Ficha creado previamente.

4. En el formulario, una vez establecidas las propiedades de la ficha (nombre, apellidos...) se pulsará el botón para crear una nueva ficha. Será necesario crear un nuevo objeto de la clase Ficha y establecer sus propiedades.

5. Para establecer la propiedad número de la ficha, crearemos una variable estática que incrementaremos en una unidad cada vez que se pulse el botón, de forma que nunca creemos dos fichas con el mismo número.

6. Una vez creada la nueva ficha, llamaremos a su método Muestra(), para que nos enseñe el valor de sus propiedades.

7. Por último, no podemos olvidarnos de destruir el objeto creado igualándolo a Nothing.

Ejemplo resuelto

Formulario

'________________________________________________________________

' Ejemplo 3 del Curso de Visual Basic Avanzado

'' El objetivo de este ejemplo es familliarizarnos con el uso de objetos.

'_________________________________________________________________________________

Option Explicit

Private Sub ButCrearFicha_Click()

Dim ObjFicha As ClaFicha

Static IntNumFicha As Integer

' Creamos un nuevo objeto de la clase ficha

Set ObjFicha = New ClaFicha

' Incrementamos el número de fichas creadas

IntNumFicha = IntNumFicha + 1

' Establecemos las propiedades de la nueva ficha

ObjFicha.StrNombre = TxtNombre

ObjFicha.StrApellidos = TxtApellidos

ObjFicha.StrDireccion = TxtDireccion

ObjFicha.StrTelefono = TxtTelefono

ObjFicha.IntNumero = IntNumFicha

' Llamamos al método MetMostrar del objeto para

' que muestre los datos de la ficha

ObjFicha.MetMostrar

' Eliminamos el objeto creado

Set ObjFicha = Nothing

End Sub

Clase Ficha

'_________________________________________________________________

' Ejemplo 3 del Curso de Visual Basic Avanzado

'' Definición de la clase FICHA, todos los objetos fichas tendrán esta interface.

'_________________________________________________________________________________

Option Explicit

' Propiedades de la clase ClaFicha

Private VarIntNumero As Integer

Private VarStrNombre As String

Private VarStrApellidos As String

Private VarStrDireccion As String

Private VarStrTelefono As String

' Métodos para acceder a la propiedad VarIntNumero

Public Property Get IntNumero() As String

IntNumero = VarIntNumero

End Property

Public Property Let IntNumero(ParIntNumero As String)

VarIntNumero = ParIntNumero

End Property

' Métodos para acceder a la propiedad VarStrNombre

Public Property Get StrNombre() As String

StrNombre = VarStrNombre

End Property

Public Property Let StrNombre(ParStrNombre As String)

VarStrNombre = ParStrNombre

End Property

' Métodos para acceder a la propiedad VarStrApellidos

Public Property Get StrApellidos() As String

StrApellidos = VarStrApellidos

End Property

Public Property Let StrApellidos(ParStrApellidos As String)

VarStrApellidos = ParStrApellidos

End Property

' Métodos para acceder a la propiedad VarStrDireccion

Public Property Get StrDireccion() As String

StrDireccion = VarStrDireccion

End Property

Public Property Let StrDireccion(StrDireccion As String)

VarStrDireccion = StrDireccion

End Property

' Métodos para acceder a la propiedad VarStrTelefono

Public Property Get StrTelefono() As String

StrTelefono = VarStrTelefono

End Property

Public Property Let StrTelefono(ParStrTelefono As String)

VarStrTelefono = ParStrTelefono

End Property

' Método para mostrar los datos de una ficha

Public Sub MetMostrar()

MsgBox "Número: " & VarIntNumero & vbCrLf & _

"Nombre: " & VarStrNombre & vbCrLf & _

"Apellidos: " & VarStrApellidos & vbCrLf & _

"Dirección: " & VarStrDireccion & vbCrLf & _

"Teléfono: " & VarStrTelefono, , "Ficha"

End Sub

4. Clases y objetos (II)

Introducción

Hasta ahora hemos aprendido cómo se crea e instancia una clase sencilla, y los conceptos más importantes de la programación orientada a objetos en Visual Basic.

En este capítulo aprenderemos a desarrollar clases mas complejas utilizando colecciones de clases mas sencillas. Para ello aprenderemos a usar colecciones de clases, y haremos hincapié en la optimización en tiempo y recursos del sistema al hacer búsquedas, inserciones y/o borrados mediante indices o claves de una colección.

También se pretende que el lector se familiarice con el uso de controles menos utilizados como la barra de desplazamiento horizontal (HScrollBar).

Conocimientos teóricos

Cómo crear colecciones de objetos: la clase Collection

Una colección es una forma de agrupar elementos relacionados. Visual Basic proporciona una gran cantidad de colecciones predefinidas (Forms, Controls, etc), pero además permite la creación de colecciones personalizadas utilizando la clase genérica Collection.

Los objetos Collection almacenan cada elemento en una variable Variant. De esta forma, la lista de cosas que se pueden agregar a un objeto Collection es igual que la lista de cosas que se pueden almacenar en una variable Variant. Entre ellas se incluyen los tipos de datos, los objetos y las matrices estándar, pero no los tipos definidos por el usuario.

Las variables Variant siempre ocupan 16 bytes, independientemente de lo que contienenÄ, por lo que el uso de objetos Collection no es tan eficiente como el uso de matrices. Sin embargo, no es necesario aplicar ReDim a un objeto Collection, lo que produce un código más limpio y más fácil de mantener. Además, los objetos Collection ofrecen un acceso por clave extremadamente rápido, que no ofrecen las matrices.

A pesar del tamaño de las variables Variant, habrá muchas ocasiones en las que tenga más sentido utilizar un objeto Collection para almacenar todos los tipos de datos enumerados anteriormente. Sin embargo, siempre tenemos que tener presente que si bien los objetos Collection nos permitirán escribir un código limpio y fácil de mantener, estamos pagando el precio de almacenar los elementos en variables Variant.

Propiedades y métodos del objeto Collection

Los objetos Collection disponen de propiedades y métodos que se puede utilizar para insertar, eliminar y recuperar los elementos de la colección.

Estas propiedades y métodos sólo proporcionan los servicios más básicos de las colecciones. Por ejemplo, el método Add no puede comprobar el tipo de objeto que se agrega a la colección para asegurar que la colección contenga un único tipo de objeto. Podemos proporcionar una funcionalidad más robusta, y propiedades, métodos y eventos adicionales, si creamos nuestra propia clase de colección, como haremos en el ejemplo correspondiente a este capítulo.

Ä Más exactamente, una variable Variant ocupa siempre 16 bytes incluso si los datos se encuentran almacenados en cualquier otra parte. Por ejemplo, si asignamos una cadena o una matriz a una variable de tipo Variant, ésta contiene un puntero a una copia de la cadena o de los datos de la matriz. En los sistemas de 32 bits sólo se utilizan como puntero 4 bytes de la variable Variant y realmente no hay ningún dato en ella. Si almacenamos un objeto, la variable de tipo Variant contiene la referencia de objeto, como si fuera una variable de objeto. Igual que ocurre con las cadenas y las matrices, solamente se utilizan 4 bytes. Los tipos de datos numéricos se almacenan ocupando siempre los 16 bytes.

Cómo acceder a los elementos de una colección: claves e índices

Los servicios básicos de agregar, eliminar y recuperar elementos de una colección dependen de claves e índices. Una clave es un valor String. Puede ser un nombre, un número de documento de identidad, un número de la seguridad social o simplemente un dato de tipo Integer convertido en tipo String. El método Add nos permite asociar una clave con un elemento, como se describe más adelante.

Un índice es un dato de tipo Long entre uno (1) y el número de elementos de la colecciónÄ. Podemos controlar el valor inicial del índice de un elemento mediante los parámetros before y after, pero su valor puede cambiar si agregamos o eliminamos otros elementos.

Podemos utilizar el índice para recorrer los elementos de una colección. Por ejemplo, si insertamos el código siguiente en el Load de un formulario aparecería en la pantalla Debug el nombre de los controles que están pegados en él:

Dim IntContador as Integer

For IntContador = 0 To Controls.Count - 1

Debug.Print Controls(IntContador).Name & vbCrLf

Next

Existe otra forma de acceder a los elementos de una colección que proporciona un mayor rendimiento: utilizar la sentencia For Each. Esta opción es notablemente más rápida que la iteración mediante índice, aunque esto no es cierto en todas las implementaciones de colecciones: depende de cómo almacena la colección los datos internamente. Podemos codificar de nuevo el ejemplo anterior utilizando esta sentencia:

Dim VarDato as Variant

For Each VarDato In Controls

Debug.Print VarDato.Name & vbCrLf

Next VarDato

Agregar elementos a una colección

Para agregar un elemento a una colección utilizaremos el método Add. La sintaxis es la siguiente:

colección.Add (elemento As Variant [, clave As Variant] [, before As Variant]

[, after As Variant] )

Por ejemplo, imaginemos un objeto Persona que tiene una propiedad DNI que lo identifica de forma única, y una colección de personas denominada ColPersonas. Para agregar un objeto nuevo a la colección utilizaríamos la sentencia:

ColPersonas.Add Persona, Persona.DNI

Ä Una colección puede tener base cero o base uno, dependiendo de su índice inicial (lo primero quiere decir que el índice del primer elemento de la colección es cero y lo segundo quiere decir que es uno). Ejemplos de colecciones con base cero son las colecciones Forms y Controls. El objeto Collection es un ejemplo de colección con base uno.

Las colecciones más antiguas de Visual Basic suelen tener base cero, mientras que las más recientes suelen tener base uno. Es más intuitivo utilizar las colecciones con base uno, ya que su índice va desde uno a Count, donde Count es la propiedad que devuelve el número de elementos de una colección.

Por otra parte, el índice de una colección con base cero va desde cero al valor de la propiedad Count menos uno.

Se supone que la propiedad DNI es un tipo String. Si esta propiedad es un número (por ejemplo, un tipo Long), utilizaríamos la función CStr para convertirlo al valor String requerido por las claves:

ColPersonas.Add Persona, CStr(Persona.DNI)

El método Add acepta argumentos con nombre. Para agregar una persona nueva como tercer elemento de la colección, podemos escribir:

ColPersonas.Add Persona, Persona.DNI, after:=2

Podemos utilizar los argumentos con nombre before y after para mantener ordenada una colección de objetos. Por ejemplo, before:=1 inserta un elemento al principio de la colección, ya que los objetos Collection están basados en uno.

Eliminación de elementos de una colección

Para eliminar un elemento de una colección, utilizaremos el método Remove. La sintaxis es la siguiente:

colección.Remove índice

El argumento índice puede ser la posición del elemento que desea eliminar o su clave. Si la clave del tercer elemento de la colección de personas es "1234567W", podemos utilizar cualquiera de estas dos instrucciones para eliminarlo:

ColPersonas.Remove 3

o bien

ColPersonas.Remove "1234567W"

Recuperación de elementos de una colección

Para recuperar un elemento de una colección, utilizaremos el método Item. La sintaxis es la siguiente:

[Set] variable = colección.Item(índice)

Como ocurre con el método Remove, el índice puede ser la posición dentro de la colección o la clave del elemento. En el mismo ejemplo que para el método Remove, cualquiera de estas dos instrucciones recuperará el tercer elemento de la colección:

Set Persona = ColPersonas.Item(3)

o bien

Set Persona = ColPersonas.Item( "1234567W")

Si utilizamos números enteros como claves, debemos emplear la función CStr para convertirlos a cadenas antes de pasarlos a los métodos Item o Remove. Los objetos Collection siempre asumen que un número entero es un índice.

El método Item es el método predeterminado de los objetos Collection, por lo que podemos omitirlo cuando queramos acceder a un elemento de una colección. De esta forma, el ejemplo de código anterior también se puede escribir de la siguiente manera:

Set Persona = ColPersonas(3)

o bien

Set Persona = ColPersonas( "1234567W")

Los objetos Collection mantienen sus números de índice automáticamente al agregar y eliminar elementos. El índice numérico de un elemento dado puede variar a lo largo del tiempo. No es conveniente, por tanto, guardar un valor numérico de índice y esperar recuperar el mismo elemento más tarde. Lo mejor es utilizar claves para este propósito.

Control HScrollBar

Las barras de desplazamiento proporcionan un medio sencillo de recorrer largas listas de elementos o grandes cantidades de información al desplazarse horizontal o verticalmente dentro de una aplicación o de un control.

Las barras de desplazamiento son un elemento común de la interfaz de Windows 95 y de Windows NT.

Los controles HScrollBar y VScrollBar no son igual que las barras de desplazamiento incorporadas que se pueden encontrar en Windows o que las adjuntas a los cuadros de texto, los cuadros de lista, los cuadros combinados o los formularios MDI de Visual Basic. Dichas barras de desplazamiento aparecen automáticamente cuando la aplicación o el control contiene más información de la que se puede presentar con el tamaño actual de la ventana (o bien, en el caso de los cuadros de texto y los formularios MDI, cuando la propiedad ScrollBars está establecida a True).

En las versiones anteriores de Visual Basic, las barras de desplazamiento se solían utilizar como dispositivos de entrada. Sin embargo, las recomendaciones de la interfaz de Windows sugieren ahora que se utilicen como dispositivos de entrada los controles Slider en lugar de los controles ScrollBar. El control Slider de Windows 95 se incluye en la Edición Profesional y la Edición Empresarial de Visual Basic.

No es conveniente permitir que los objetos Collection decidan si el valor que están recibiendo es un índice o una clave. Si deseamos que un valor se interprete como clave y la variable que contiene el valor no es de tipo String, debemos utilizar CStr para convertirla. Si deseamos que un valor se interprete como índice y la variable que contiene el valor no es de un tipo de datos numéricos, debemos utilizar CLng para convertirla.

Los controles ScrollBar siguen siendo útiles en Visual Basic porque proporcionan capacidad de desplazamiento a las aplicaciones o a los controles que no la proporcionan de forma automática.

Los controles ScrollBar utilizan los eventos Scroll y Change para supervisar el movimiento del cuadro de desplazamiento a lo largo de la barra de desplazamiento.

El evento Scroll proporciona acceso al valor de la barra de desplazamiento cuando ésta se arrastra. El evento Change se produce después de liberar el cuadro de desplazamiento o cuando se hace clic en la barra o en las flechas de desplazamiento.

La propiedad Value (que de forma predeterminada es 0) es un valor entero que se corresponde con la posición del cuadro de desplazamiento dentro de la barra de desplazamiento. Cuando la posición del cuadro de desplazamiento tiene el valor mínimo, éste se mueve a la posición situada más a la izquierda (en las barras de desplazamiento horizontal) o a la posición más alta (en las barras de desplazamiento vertical). Cuando el cuadro de desplazamiento tiene el valor máximo, se mueve a la posición situada más a la derecha o a la más baja. De forma similar, un valor a medio camino entre los límites del intervalo coloca el cuadro de desplazamiento en la mitad de la barra de desplazamiento.

Además de utilizar los clics del ratón para cambiar el valor de la barra de desplazamiento, el usuario también puede arrastrar el cuadro de desplazamiento a cualquier posición de la barra. El valor resultante depende de la posición del cuadro de desplazamiento, pero siempre se encuentra dentro del intervalo definido por las propiedades Min y Max establecidas por el usuario.

Más conceptos de clases: eventos Initialize y Terminate

Todas las clases proporcionan dos eventos predefinidos: Initialize y Terminate.

Normalmente el procedimiento de evento Initialize contiene el código que se ejecuta en el momento de la creación del objeto.

El evento Terminate suele contiene el código necesario para liberar el objeto cuando éste se destruye. Supone una buena norma de programación asegurarnos, utilizando este método, que toda la memoria utilizada por un objeto se libera en el momento de su destrucción.

Ejemplo propuesto

Objetivo

El objetivo es crear una agenda de teléfonos en la que podamos consultar fácilmente las fichas, así como insertar nuevas fichas o borrar fichas existentes.

Para ello, crearemos una nueva clase ClaAgenda:

· Propiedades:

· ColFichas: colección de las fichas almacenadas en la agenda

· Métodos:

· Property IntNumFichas: devuelve el número de fichas almacenadas en la agenda

· Function CrearFicha(StrNombre, StrApellidos, StrDireccion, StrTelefono) as Integer: crea una nueva ficha y la inserta en la colección ColFichas. Devuelve el número de la ficha.

· Function BorrarFicha(IntNumFicha): borra la ficha cuyo número se pasa como argumento.

· Function Ficha(IntIndice) As ClaFicha: devuelve la ficha correspondiente a la posición IntIndice en la colección de fichas ColFichas

· Sub Class_Terminate(): eliminaremos todas las fichas de la colección ColFichas, así como la propia colección, antes de que el objeto se elimine de memoria

En el formulario podremos realizar tres acciones:

· Crear una nueva ficha: primero pulsaremos el botón Nueva ficha, con lo que se borrarán los cuadros de texto y se incrementará el límite superior de la barra de scroll. Una vez introducidos los datos de la nueva ficha, pulsaremos el botón Crear ficha, donde se llamará al método CrearFicha de la clase ClaAgenda, obteniendo el número de ficha resultante, que nos servirá para poder borrarla en caso necesario.

· Consultar una ficha existente: utilizando la barra de scroll podremos consultar todas las fichas de la agenda. Cada vez que cambie el valor de la barra de scroll, actualizaremos el formulario para mostrar los datos de la ficha correspondiente (por ejemplo, si el valor de la barra de scroll es 3, mostraremos la cuarta ficha de la colección; hay que recordar que el límite inferior de la barra de scroll es 0, mientras que una colección empieza en 1). Cada vez que cambiemos de ficha, actualizaremos el número de la ficha actual.

· Borrar la ficha actual: utilizaremos el número de ficha actual para llamar al método BorrarFicha de la clase ClaAgenda. Decrementaremos el límite máximo de la barra de scroll, y actualizaremos el formulario para que muestra los datos de la ficha siguiente o anterior a la borrada.

Desarrollo del ejemplo

1. Crearemos el siguiente formulario:

2. Crearemos una clase Agenda con una propiedad privada ColFichas de tipo Collection, que no tendrá métodos Property asociados. Crearemos un método Property Get llamado IntNumFichas que nos devuelva el número de fichas de la colección ColFichas.

3. Implementaremos un método público CrearFicha que recibe como argumentos el nombre, apellido, dirección y teléfono y crea una ficha nueva (utilizaremos la clase Ficha definida en el ejemplo 3), asignándole un número (este número será una especie de “campo autonumérico”, que generaremos incrementalmente). Además de crear la nueva ficha, la introduce en la colección ColFichas, poniendo como clave el número de la ficha (como la clave tiene que ser una cadena, hay que hacer la conversión a string de dicho número).

4. Implementaremos también un método público BorrarFicha, que recibe como argumento la clave de la ficha que queremos eliminar. Este método elimina la ficha de memoria y también de la colección.

5. También crearemos un método público Ficha, que recibe como argumento el índice de la ficha dentro de la colección ColFichas y devuelve la ficha correspondiente.

6. Como último elemento de la clase, en el evento Terminate liberaremos todo el espacio de memoria que podamos tener reservado para las fichas y la colección.

7. En el formulario crearemos un objeto de la clase Agenda, y una variable IntNumFichaActual que indicará el número de la ficha cuyos datos aparecen en el formulario. Como estas variables van a ser utilizadas en todas las funciones del formulario, las crearemos como variables globales del formulario.

8. Al pulsar el botón “Nueva ficha”, debemos aumentar la propiedad Max de la barra de scroll, posicionarnos en el último elemento y limpiar los datos (nombre, apellidos, dirección y teléfono), preparando el formulario para insertar una nueva ficha. (¡Ojo!: para la primera ficha, no es necesario incrementar el límite máximo de la barra de scroll, ni limpiar el formulario).

9. Una vez insertados los datos de la nueva ficha, pulsaremos el botón “Crear ficha”, donde llamaremos al método CrearFicha del objeto Agenda y actualizaremos el título del frame, donde pondrá “Ficha N” (siendo N el número de la nueva ficha, que obtendremos como valor de retorno del método CrearFicha).

10. Cada vez que cambie la barra de scroll (evento Change) debemos actualizar los datos del formulario, mostrando la información de la ficha correspondiente en la colección ColFichas del objeto Agenda. Crearemos una función ActualizarBarraScroll que se encargará de ello (¡Ojo!: la función debe comprobar si hay fichas en la colección, y también si estamos insertando una ficha nueva, en cuyo caso en lugar de actualizar los datos del formulario, los limpiará.). También tenemos que obtener el número de la ficha actual.

11. Cuando pulsemos el botón “Borrar ficha” llamaremos al método BorrarFicha del objeto Agenda pasándole el número de la ficha actual. Una vez borrada, decrementaremos el valor máximo de la barra de scroll (¡Ojo!: cuidado cuando borramos la última ficha) y actualizaremos los datos del formulario llamando a la función ActualizarBarraScroll.

12. Para terminar, sólo nos falta controlar cuando están habilitados los cuadros de texto, los botones y demás elementos para que quede lo más coherente posible.

Ejemplo Resuelto

Formulario

'_________________________________________________________________________________

' Ejemplo 4 del Curso de Visual Basic Avanzado

'' Definición del formulario, este será el interfaz del usuario.

'_________________________________________________________________________________

Option Explicit

Dim ObjAgenda As New ClaAgenda

Dim IntNumFichaActual As Integer

Private Sub ButBorrarFicha_Click()

' Confirmamos el borrado

If MsgBox("¿Desea eliminar la ficha actual?", vbYesNo, "Borrado de ficha") = vbNo Then

Exit Sub

End If

' Borramos la ficha actual

ObjAgenda.BorrarFicha IntNumFichaActual

' Actualizamos el número de elementos de la barra de scroll

If ObjAgenda.IntNumFichas > 0 Then

HScroll1.Max = ObjAgenda.IntNumFichas - 1

Else

HScroll1.Max = 0

End If

' Actualizamos la barra de scroll

ActualizarBarraScroll

End Sub

Private Sub ButCrearFicha_Click()

' Creamos una nueva ficha con los datos introducidos por el

' usuario, y obtenemos el código de la ficha creada

IntNumFichaActual = ObjAgenda.CrearFicha(TxtNombre, TxtApellidos, TxtDireccion, _

TxtTelefono)

' Actualizamos el título del frame

Frame1.Caption = "Ficha " & IntNumFichaActual

' Deshabilitamos el botón de crear ficha y el frame

ButCrearFicha.Enabled = False

Frame1.Enabled = False

' Habilitamos los botones de nueva ficha y borrar

' ficha, así como la barra de scroll

ButNuevaFicha.Enabled = True

ButBorrarFicha.Enabled = True

HScroll1.Enabled = True

End Sub

Private Sub ButNuevaFicha_Click()

' Actualizamos la barra de scroll

If ObjAgenda.IntNumFichas = 0 Then

' Con la primera ficha creada, habilitamos

' la barra de scroll

HScroll1.Enabled = True

Frame1.Enabled = True

Else

' Incrementamos el número de elementos de

' la barra de scroll

HScroll1.Max = HScroll1.Max + 1

HScroll1.Value = HScroll1.Max

End If

' Habilitamos el botón de crear ficha y el frame

ButCrearFicha.Enabled = True

Frame1.Enabled = True

' Deshabilitamos los botones de nueva ficha y borrar

' ficha, así como la barra de scroll

ButNuevaFicha.Enabled = False

ButBorrarFicha.Enabled = False

HScroll1.Enabled = False

End Sub

Private Sub Form_Load()

' Deshabilitamos el frame, la barra de scroll,

' el botón de crear ficha y el botón de borrar ficha

Frame1.Enabled = False

HScroll1.Enabled = False

ButCrearFicha.Enabled = False

ButBorrarFicha.Enabled = False

' Establecemos los límites de la barra de scroll

HScroll1.Max = 0

End Sub

Private Sub Form_Unload(Cancel As Integer)

' Eliminamos la agenda

Set ObjAgenda = Nothing

End Sub

Private Sub HScroll1_Change()

' Actualizamos la barra de scroll

ActualizarBarraScroll

End Sub

Private Function ActualizarBarraScroll()

Dim ObjFicha As ClaFicha

' Comprobamos si no hay fichas o estamos creando una ficha nueva

If HScroll1.Max = ObjAgenda.IntNumFichas Then

' Limpiamos los datos del frame

TxtNombre = vbNullString

TxtApellidos = vbNullString

TxtDireccion = vbNullString

TxtTelefono = vbNullString

' Actualizamos el título del frame

Frame1.Caption = vbNullString

' Deshabilitamos el botón de borrado

ButBorrarFicha.Enabled = False

Else

' Obtenemos la ficha correspondiente de la agenda

' (buscamos por índice, no por código de ficha)

Set ObjFicha = ObjAgenda.Ficha(HScroll1.Value + 1)

' Sacamos los datos de la ficha

TxtNombre = ObjFicha.StrNombre

TxtApellidos = ObjFicha.StrApellidos

TxtDireccion = ObjFicha.StrDireccion

TxtTelefono = ObjFicha.StrTelefono

' Actualizamos el código de la ficha actual

IntNumFichaActual = ObjFicha.IntNumFicha

' Actualizamos el frame

Frame1.Caption = "Ficha " & IntNumFichaActual

End If

End Function

Clase Agenda

'_______________________________________________________________________

' Ejemplo 4 del Curso de Visual Basic Avanzado

'' Definición de la clase AGENDA, aquí estarán los datos de cada agenda y los métodos

' para actuar con ellos.

'_________________________________________________________________________________

Option Explicit

Private ColFichas As New Collection ' Colección de fichas de la agenda

' Método para obtener el número de fichas de la agenda

Public Property Get IntNumFichas() As Integer

IntNumFichas = ColFichas.Count

End Property

' Método para crear una ficha nueva en la agenda

Public Function CrearFicha(ByVal StrNombre As String, _

ByVal StrApellidos As String, ByVal StrDireccion As String, _

ByVal StrTelefono As String) As Integer

Static IntNumTotalFichas As Integer

Dim ObjFicha As ClaFicha

' Incrementamos el "campo autonúmerico" IntNumTotalFichas

IntNumTotalFichas = IntNumTotalFichas + 1

' Creamos un nuevo objeto de la clase ficha

Set ObjFicha = New ClaFicha

' Establecemos las propiedades de la nueva ficha

ObjFicha.StrNombre = StrNombre

ObjFicha.StrApellidos = StrApellidos

ObjFicha.StrDireccion = StrDireccion

ObjFicha.StrTelefono = StrTelefono

ObjFicha.IntNumFicha = IntNumTotalFichas

' Insertamos la nueva ficha en la colección de fichas, poniendo

' como key el código de la ficha, para poder buscarla después

' por código (convertimos a string el código porque el key

' tiene que ser un string)

ColFichas.Add ObjFicha, CStr(ObjFicha.IntNumFicha)

' Devolvemos el código de la ficha creada

CrearFicha = IntNumTotalFichas

End Function

' Método para borrar una ficha de la agenda

Public Function BorrarFicha(ByVal IntNumFicha As Integer)

Dim ObjFicha As ClaFicha

' Obtenemos la ficha correspondiente de la colección

' de fichas (para poder buscar por key, tenemos que

' convertir el número a string, pues en caso contrario

' buscamos por índice)

Set ObjFicha = ColFichas.Item(CStr(IntNumFicha))

' Eliminamos la ficha de la colección

ColFichas.Remove (CStr(IntNumFicha))

' Eliminamos la ficha

Set ObjFicha = Nothing

End Function

' Método para eliminar todas las fichas de una agenda cuando

' éste es eliminada

Private Sub Class_Terminate()

Dim ObjFicha As ClaFicha

' Eliminamos todas las fichas de la colección

For Each ObjFicha In ColFichas

Set ObjFicha = Nothing

Next ObjFicha

End Sub

' Método para obtener una ficha específica de la agenda (no busca

' por key sino por índice)

Public Function Ficha(ByVal IntIndice As Integer) As ClaFicha

Set Ficha = ColFichas.Item(IntIndice)

End Function

5. Tecnología ActiveX

Introducción

El objetivo de este capítulo es mostrar al lector el proceso de creación de componentes ActiveX, y su utilización en un proyecto. También se pretende que el lector se familiarice con el proceso de publicación de un control ActiveX en una página Web, como muestra de la versatilidad de este tipo de componentes.

Con este capítulo se hace una introducción al curso Active X, que es la continuación de los cursos Visual Basic 5.0 (básico y avanzado).

Conocimientos teóricos

Qué es un componente ActiveX

Un componente ActiveX es un archivo .EXE, .DLL u .OCX que cumple la especificación ActiveX para proporcionar objetos. Para entendernos, un control ActiveX es una extensión del cuadro de herramientas de Visual Basic. Los controles ActiveX se usan como cualquiera de los controles estándar incorporados, como el control CheckBox. Cuando agregamos un control ActiveX a un programa, pasa a formar parte del entorno de desarrollo y de tiempo de ejecución y proporciona nueva funcionalidad a la aplicación.

Los controles ActiveX incrementan la capacidad del programador de Visual Basic conservando algunos métodos, propiedades y eventos ya familiares, como la propiedad Name, que se comportan como cabría esperar. Pero, además, los controles ActiveX incorporan métodos y propiedades que aumentan enormemente la flexibilidad y capacidad del programador de Visual Basic.

La tecnología ActiveX permite a los programadores ensamblar estos componentes software reutilizables en sus aplicaciones.

Los controles ActiveX, que se llamaban antes controles OLE, son elementos estándar de interfaz de usuario que nos permiten ensamblar rápidamente formularios y cuadros de diálogo. Los controles ActiveX también dan vida a Internet, agregando una nueva y atractiva funcionalidad a las páginas del World Wide Web.

Visual Basic siempre ha presentado diversos controles que podíamos utilizar en nuestras aplicaciones. Ahora podemos crear nuestros propios controles para utilizarlos con Visual Basic y otras herramientas de programación.

Diseñar un control ActiveX puede resultar tan fácil como diseñar un formulario de Visual Basic: podemos utilizar los comandos gráficos de Visual Basic con los que estamos familiarizados 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 código del formulario de prueba al código del proyecto de control ActiveX.

Visual Basic facilita crear paquetes de controles ActiveX perfeccionados al agregar a los controles páginas de propiedades, constantes con nombre y eventos.

Podemos compilar nuestros controles ActiveX directamente en el archivo ejecutable de nuestra aplicación o en archivos .ocx, que se pueden utilizar con herramientas de programación como Visual Basic y Microsoft Visual C++, con productos para el usuario final como Microsoft Office y en Internet.

Tipos de componentes ActiveX

Existen tres tipos de componentes ActiveX:

· Controles ActiveX: Los controles ActiveX son elementos estándar de interfaz de usuario que permiten construir rápidamente aplicaciones, como si de un puzzle se tratara.

Visual Basic proporciona un conjunto de controles predefinidos, y permite la creación de controles de usuario. Por ejemplo, podríamos hacer una caja de texto que controlara si los caracteres introducidos son numéricos, mostrando los números introducidos con la coma de los decimales o de los millares, y utilizarlo como el convencional textbox.

· ActiveX DLL (librerías): Los componentes ActiveX proporciona código que se puede volver a utilizar en forma de objetos. Una aplicación (cliente) puede crear un objeto a partir de un componente ActiveX (servidor) y utilizar sus propiedades y métodos. Los componentes ActiveX DLL se ejecutan dentro del espacio de direcciones del programa que los utiliza.

· ActiveX EXE: Un componente ActiveX EXE es muy similar a un componente ActiveX DLL. La única diferencia es que un componente ActiveX EXE se ejecuta en su propio espacio de direcciones, lo que permite que el cliente puede ejecutar un método del componente y continuar con su ejecución mientras el componente realiza el trabajo, manteniendo el control de la ejecución del programa principal si se quedara bloqueada la llamada a una función del Active X. La pega es que gasta mas recursos, pues la comunicación entre el cliente y el servidor es más compleja.

Creación dinámica de matrices

Hay ocasiones en las que no conocemos a priori lo grande que debe ser una matriz. Puede que deseemos poder cambiar el tamaño de la matriz en tiempo de ejecución.

Una matriz dinámica se puede cambiar de tamaño en cualquier momento. Las matrices dinámicas son una de las características más flexibles y cómodas de Visual Basic, y nos ayudan a administrar de forma eficiente la memoria. Por ejemplo, podemos utilizar una matriz grande durante un tiempo corto y liberar memoria del sistema cuando no necesite volver a utilizar la matriz.

La alternativa consiste en declarar la matriz con el mayor tamaño posible y pasar por alto los elementos de la matriz que no necesitemos. Sin embargo, esta solución, si se utiliza demasiado, puede hacer que el sistema operativo funcione con muy poca memoria.

El primer paso en la creación de una matriz dinámica es su declaración: en un primer momento, la matriz no tendrá ninguna dimensión. Por ejemplo, la siguiente sentencia define un array de enteros, pero no especifica cuántos elementos va a contener:

Dim IntMatriz() As Integer

Para asignar el número real de elementos utilizaremos la instrucción ReDim. Por ejemplo, con la siguiente sentencia permitiremos que el array anterior almacene 10 enteros:

ReDim IntMatriz (0 To 9)

La instrucción ReDim puede aparecer sola en un procedimiento. A diferencia de las instrucciones Dim y Static, ReDim es una instrucción ejecutable; hace que la aplicación realice una acción en tiempo de ejecución.

La instrucción ReDim acepta la misma sintaxis que se utiliza en las matrices fijas. Cada ReDim puede cambiar el número de elementos, así como los límites inferior y superior de cada dimensión. Sin embargo, si la matriz ha sido declarada con un número de elementos determinado, no podremos utilizar la sentencia Redim para alterarlo. Por ejemplo, si definimos la matriz anterior de esta forma:

Dim IntMatriz(5) As Integer

No podremos utilizar posteriormente la sentencia Redim para alterar su tamaño.

Preservar el contenido de las matrices dinámicas

Cada vez que ejecutamos la instrucción ReDim se perderán todos los valores almacenados en ese momento en la matriz. Visual Basic restablece los valores al valor Empty (en matrices Variant), a cero (en matrices numéricas), a una cadena de longitud cero (en matrices de cadenas) o a Nothing (en matrices de objetos).

Esto resulta muy útil cuando deseemos preparar la matriz para contener datos nuevos o cuando deseemos reducir el tamaño de la matriz para que ocupe menos memoria. Puede que a veces nos interese cambiar el tamaño de la matriz sin perder los datos de la misma. Para ello podemos utilizar ReDim con la palabra clave Preserve. Por ejemplo, podemos ampliar una matriz en un elemento sin perder los valores de los elementos existentes mediante la función UBound para hacer referencia al límite superior:

ReDim Preserve IntMatriz(UBound(IntMatriz) + 1)

Sólo se puede cambiar el límite superior de la última dimensión de una matriz multidimensional cuando se utiliza la palabra clave Preserve; si cambiamos alguna otra dimensión o el límite inferior de la última dimensión, se producirá un error en tiempo de ejecución. Así pues, podemos utilizar un código como el siguiente:

ReDim Preserve IntMatriz(10, UBound(IntMatriz, 2) + 1)

Pero no podemos utilizar este código:

ReDim Preserve IntMatriz(UBound(IntMatriz, 1) + 1, 10)

Matrices de controles

Visual Basic permite crear matrices de controles dinámicamente y situar los nuevos controles a voluntad en un formulario. Supongamos que tenemos un control llamado MiCtl (por ejemplo, un CommandButton). Para crear un nuevo control, utilizaríamos la sentencia:

Load MiCtl(N)

donde N es el índice del nuevo control. Una vez creado, podemos situar el nuevo control en la posición que deseemos estableciendo apropiadamente su propiedad Top y Left, y hacerlo visible estableciendo a True la propiedad Visible.

Publicar un control ActiveX en un página Web

Una vez creado el control ActiveX, hay que seguir los siguientes pasos:

1. Generar el archivo .OCX correspondiente y guardar el proyecto después.

2. Ejecutar el Asistente para instalar aplicaciones.

3. Seleccionar el proyecto correspondiente al control ActiveX, marcando la opción Instalación para transferencia desde Internet.

4. Durante el proceso de creación de los archivos, especificaremos el directorio donde se crearán los archivos, así como el lugar desde donde el cliente que abra la página Web donde estará el control ActiveX bajará los archivos .CAB de los componentes de nuestro control (si es necesario). También contestaremos afirmativamente a la pregunta de si queremos incluir la DLL de la página de propiedades (necesario si queremos ejecutar el control desde fuera de Visual Basic, como es el caso).

El asistente nos creará principalmente dos archivos con el nombre del control ActiveX, uno con extensión .CAB que contiene el propio control (y otros elementos utilizados por él, si procede) y otro con extensión .HTM en el que se muestra un ejemplo de página HTML que utiliza el control ActiveX.

Ejemplo propuesto

Objetivo

El objetivo es crear un control ActiveX que simule el juego de las Tres en raya. Una vez creado, generaremos una página Web donde pegaremos el control con este ejemplo podemos ver la potencia que tiene esta herramienta, ya que con el uso de un control podemos tener una aplicación bastante complicada corriendo detrás, siendo muy fácil el implantación para usos posteriores.

Desarrollo del ejemplo

1) Crearemos un control ActiveX TresEnRaya:

· Interfaz:

· Simularemos un tablero de 3x3, pero sólo crearemos el frame que lo contiene y UN botón. Estableceremos las propiedades del botón (color, nombre…), especialmente la propiedad Index=0 (va a ser el primero de una matriz de controles).

Propiedades:

· StrTurno: almacena el carácter correspondiente al turno actual (“O” o “X”)

· IntNumeroJugadas: recoge el número de movimientos realizados

· Métodos:

· Sub UserControl_Initialize: a partir de un único botón creado en tiempo de diseño en el control ActiveX, generará una matríz ordenada de 3x3 botones (índices de 0 a 8).

· Sub InicializarFormulario: inicializará el caption de los botones, el turno y el número de jugadas.

· Function HayTresEnRaya() As Boolean: comprobará cuando hay tres en raya, en función del caption de los botones que es donde nos indica el jugador que lo eligió (O o X).

· Sub ButCelda_Click(Index As Integer): realizará todo el proceso del juego (comprobar si hay tres en raya, comprobar si el botón ya ha sido pulsado, y en caso contrario cambiar el caption del mismo, comprobar si se han marcado ya todas las casillas, incrementar el número de jugadas realizadas...)

2) Una vez creado el control, abriremos un proyecto nuevo (de tipo EXE estándar) en el que añadiremos un formulario en blanco y nuestro proyecto TresEnRaya. Pegaremos el control TresEnRaya, que aparecerá en la caja de herramientas, y depuraremos el control abierto como proyecto, ya que si no tendríamos que depurarlo ejecutándolo directamente, y para solucionar un posible error volvernos al VB para realizar la modificación, recompilar y hacer el ejecutable, mientras que de esta forma con reescribir y ejecutar tenemos el problema resuelto.

3) Cuando el control funcione bien, abriremos el proyecto inicial, generaremos el archivo TresEnRaya.ocx, guardaremos el proyecto y cerraremos Visual Basic.

4) Ejecutaremos el Asistente para instalar aplicaciones y crearemos los ficheros necesarios para publicar nuestro control en una página Web.

Ejemplo resuelto

'________________________________________________________________________

' Ejemplo 5 del Curso de Visual Basic Avanzado

'' Código del control de TRES EN RAYA, funciones necesarias para el control de la partida

' y control de movimientos de los jugadores.

'_________________________________________________________________________________

Option Explicit

Dim StrTurno As String

Dim IntNumeroJugadas As Integer

Private Sub ButCelda_Click(Index As Integer)

If ButCelda(Index).Caption = vbNullString Then

' Pintamos la marca en la ButCelda correspondiente

ButCelda(Index).Caption = StrTurno

' Comprobamos si hay 3 en línea

If HayTresEnRaya() Then

MsgBox "¡Has ganado!", vbOKOnly Or vbExclamation, "Tres en Raya"

InicializarFormulario

Exit Sub

End If

' Cambiamos de StrTurno

If StrTurno = "O" Then

StrTurno = "X"

Else

StrTurno = "O"

End If

' Comprobamos si se han realizado todos los movimientos

' posibles

If IntNumeroJugadas = 9 Then

If MsgBox("Ha habido un empate. ¿Quieres jugar otra vez?", vbYesNo Or vbQuestion, "Tres en Raya") = vbYes Then

InicializarFormulario

End If

' Incrementamos el número de movimientos realizados

IntNumeroJugadas = IntNumeroJugadas + 1

End If

End Sub

Private Function HayTresEnRaya() As Boolean

Dim IntI, IntJ As Integer

' Filas horizontales

For IntI = 0 To 2

If ButCelda(3 * IntI).Caption <> vbNullString And _

ButCelda(3 * IntI).Caption = ButCelda(3 * IntI + 1).Caption And _

ButCelda(3 * IntI).Caption = ButCelda(3 * IntI + 2).Caption Then

HayTresEnRaya = True

Exit Function

End If

' Filas verticales

For IntI = 0 To 2

If ButCelda(IntI).Caption <> vbNullString And _

ButCelda(IntI).Caption = ButCelda(3 + IntI).Caption And _

ButCelda(IntI).Caption = ButCelda(6 + IntI).Caption Then

HayTresEnRaya = True

Exit Function

End If

' Diagonales

If ButCelda(0).Caption <> vbNullString And _

ButCelda(0).Caption = ButCelda(4).Caption And _

ButCelda(0).Caption = ButCelda(8).Caption Then

HayTresEnRaya = True

Exit Function

End If

If ButCelda(2).Caption <> vbNullString And _

ButCelda(2).Caption = ButCelda(4).Caption And _

ButCelda(2).Caption = ButCelda(6).Caption Then

HayTresEnRaya = True

Exit Function

End If

HayTresEnRaya = False

End Function

Public Sub InicializarFormulario()

Dim IntI As Integer

' Limpiamos las celdas

For IntI = 0 To 8

ButCelda(IntI).Caption = vbNullString

' Inicializamos el StrTurno

StrTurno = "X"

' Inicializamos el número de movimientos

IntNumeroJugadas = 1

End Sub

Private Sub UserControl_Initialize()

Dim IntI, IntJ As Integer

' Creamos los nuevos botones

For IntI = 1 To 8

Load ButCelda(IntI)

ButCelda(IntI).Visible = True

' Colocamos los botones

For IntI = 0 To 2

' Colocamos el botón izquierdo de la fila correspondiente

ButCelda(3 * IntI).Top = ButCelda(3 * IntI).Top + IntI * ButCelda(0).Height

' Colocamos los dos botones restantes de la fila

For IntJ = 1 To 2

ButCelda(3 * IntI + IntJ).Top = ButCelda(3 * IntI).Top

ButCelda(3 * IntI + IntJ).Left = ButCelda(3 * IntI + IntJ - 1).Left + ButCelda(3 * IntI + IntJ - 1).Width

' Inicializamos el tablero

InicializarFormulario

End Sub

6. Acceso a bases de datos (DAO y Jet)

Introducción

En Visual Basic existen múltiples métodos de acceso a bases de datos. En este capítulo, y en los dos siguientes, se pretende familiarizar al lector con tres de los métodos más utilizados para acceso a bases de datos, tanto locales como remotas. Utilizar uno u otro depende de nuestras necesidades: unos métodos son más aptos para aplicaciones sencillas sin conexión a bases de datos externas, mientras que otros aportan un mayor rendimiento al ser utilizados contra servidores inteligentes como SQL Server.

Visual Basic proporciona también un conjunto de controles enlazados a datos (como los controles DBGrid, DBCombo, DBList, RemoteData...) que facilitan el acceso y el procesamiento de la información almacenada en una base de datos. Dichos controles no van a ser tratados en este manual, por dos razones: la primera razón es que estos controles no nos permiten definir su funcionamiento para controlar cómo acceden a la base de datos, lo que en la mayoría de las ocasiones suele ser un requisito fundamental, y la segunda razón es que una vez asimile el lector los tres capítulos que vamos a presentar, no debería tener ningún problema en profundizar por sí mismo, si fuera necesario, en su funcionamiento.

Este capítulo mostrará al lector en qué consiste y cómo se utiliza el primero de los métodos de acceso a datos, DAO (Data Access Objects), para acceder a bases de datos locales a través del motor Jet. De forma paralela se pretende que el lector sea consciente de la ventaja del uso de clases para la reutilización del código.

Conocimientos teóricos

DAO y Jet

El modelo DAO es una interfaz de programación que posibilita un control total de la base de datos. Es decir, DAO facilita una colección de clases de objetos que proporcionan las propiedades y los métodos que nos permitirán llevar a cabo todas las operaciones necesarias para administrar una base de datos: funciones para crear bases de datos, definir tablas, campos e índices, establecer relaciones entre las tablas, desplazarse por la base de datos y crear consultas sobre ella, etc.

El motor de base de datos Jet convierte estas operaciones, definidas sobre objetos de acceso de datos, en operaciones físicas que se efectúan directamente sobre los propios archivos de las bases de datos y que controlan todos los mecanismos de interfaz con las distintas bases de datos compatibles. Hay tres categorías de bases de datos que Visual Basic reconoce a través de DAO y del motor Jet:

· Bases de datos nativas de Visual Basic: aquellas que utilizan el mismo formato que Microsoft Access. El motor Jet crea y manipula directamente estas bases de datos, que proporcionan la máxima flexibilidad y velocidad.

· Bases de datos externas: las que utilizan el método de acceso secuencial indexado (ISAM), como dBASE III, dBASE IV, Microsoft FoxPro, Paradox, archivos de texto, hojas de cálculo de Microsoft Excel o Lotus, etc.

· Bases de datos ODBC: bases de datos cliente-servidor que cumplen el estándar ODBC. Aunque es posible trabajar contra una base de datos utilizando Jet y ODBC, existen otros métodos más recomendables que veremos en los ejemplos 7 y 8.

Estructura de una aplicación de bases de datos en Visual basic con DAO y Jet

Una aplicación de bases de datos en Visual Basic que utiliza DAO y Jet consta de tres partes, como se muestra en la siguiente figura:

El interfaz de usuario es lo que el usuario ve y con lo que interactúa con la base de datos. Como se ve en la figura, todo acceso a la base de datos se realiza a través del motor de base de datos (Jet) ya que es aquí donde están los métodos y funciones de acceso a base de datos.

El motor de base de datos es un intermediario entre el interfaz de usuario y el almacén de datos, lo que permite abstraer a la aplicación de la base de datos utilizada, facilitando la reutilización del código.

El modelo de objetos DAO

El modelo de objetos de acceso a datos es la interfaz orientada a objetos del motor de base de datos Jet. Se trata de una jerarquía de clases que corresponde a una visión lógica de un sistema de base de datos relacional (la base de datos propiamente dicha, las tablas definidas en ella y sus campos, índices, etc). Estas clases se utilizan para crear objetos de acceso a datos que se defieren a la base de datos en particular que se desea manipular.

Las clases de los objetos de acceso a datos se organizan en una jerarquía, en la que la mayoría de las clases pertenecen a una clase de colección, que a su vez pertenece a otra clase en la jerarquía. Aquí se muestra la jerarquía completa de DAO.

Programación con DAO y Jet

En las siguientes líneas vamos a comentar cómo programar una aplicación que acceda a una base de datos Jet a través de DAO, explicando las acciones más comunes que deberemos implementar. Existen muchas posibilidades que no comentaremos. Sin embargo, el ejemplo propuesto es lo suficientemente completo como para servir a los propósitos de la mayoría.

Si programamos con Visual Basic 5.0, es necesario incluir en el proyecto una referencia a Microsoft DAO 3.5 Object Library.

Como ejemplo vamos a utilizar una base de datos creada en Access y guardada en 'c:\bd\MiBD.mdb'. La base de datos contiene una sola tabla, MiTabla, cuya estructura es la siguiente:

Ahora veremos la estructura de un programa en el que se mantiene esta base de datos.

· Apertura de la base de datos:

El objeto DBEngine contiene y controla todos los otros objetos en la jerarquía de los objetos de DAO. Es único por aplicación (no pueden crearse otros objetos DBEngine). Utilizaremos el Workspace (espacio de trabajo) por defecto de este objeto para abrir la base de datos, especificando el path completo del archivo:

Dim VarBD as Database

Set VarBD = DBEngine.Workspaces(0).OpenDatabase(“c:\bd\MiBD.mdb”)

· Utilización de Recordsets:

Un objeto Recordset representa los registros de una tabla o los registros que resultan de ejecutar una consulta. Es análogo a los cursores utilizados en otros lenguajes. Existen varios tipos, cada uno de los cuales tiene sus ventajas e inconvenientes:

· dbOpenTable: tiene acceso a la base de datos directamente, es decir, que tiene acceso a la tabla directamente. Las búsquedas son más rápidas que con otros tipos de Recordset, pero no permite uniones ni puede ser utilizado con otros modelos de acceso a datos como RDO.

· dbOpenSnapshot: contiene una copia fija de los datos tal y como existen en el momento en el que se accedió. Consume menos recursos que otros Recordset (dbOpenTable, dbOpenDynaset), por lo que puede ejecutar consultas y devolver datos más rápidamente, sobre todo si utiliza ODBC. No es actualizable, por lo que no recoge los cambios que puedan realizarse en la base de datos mientras se utiliza, es óptimo para usos de lectura de datos.

· dbOpenDynaset: es un conjunto de referencias a los registros de una o más tablas. Los cambios realizados en la base de datos son automáticamente actualizados en un Recordset de este tipo. Sin embargo, las búsquedas son más lentas ya que las acciones que se hacen no solo se ejecutan en la memoria, si no que se reflejan a la vez en la base de datos.

· dbOpenForwardOnly: es un tipo de Snapshot en el que sólo se permite el desplazamiento hacia delante sobre el conjunto de resultados obtenido en una consulta. Es el Recordset que menos funcionalidad proporciona, con la ventaja de que es el más rápido.

En el siguiente cuadro se recogen los tipos de Recordset que deben utilizarse para realizar las acciones más comunes, de forma que se maximice en la medida de lo posible el rendimiento de la aplicación:

Siempre hay que cerrar los Recordsets abiertos una vez dejen de ser útiles utilizando el método Close. No cerrar un Recordset abierto puede suponer estar trabajando con datos no actualizados, no poder abrir o cerrar transacciones, etc.

En las siguientes líneas se exponen varios ejemplos de uso de Recordsets utilizando en muchos casos sentencias específicas de DAO para acceder a bases de datos Jet. Este tipo de sentencias están pensadas para el acceso a bases de datos locales a través del motor Jet, y no deben ser utilizadas para acceder a servidores de bases de datos no localizados en el cliente (es más, en ocasiones no pueden ser utilizadas fuera de este contexto). Su utilización en este tipo de entornos puede suponer una importante bajada en el rendimiento de la aplicación, siendo preferible el uso de DAO con ODBCDirect o RDO, como veremos en los siguientes ejemplos.

Ejemplos de utilización de Recordsets:

Para insertar un registro nuevo (DNI=”12345678”, Nombre=”Anastasio”, Apellidos=”Pérez Martín”) en la tabla 'MiTabla':

Dim RsetTabla as Recordset

Set RsetTabla = VarBD.OpenRecordset(“MiTabla”,dbOpenTable)

With RsetTabla

.AddNew

!DNI = “12345678”

!Nombre = “Anastasio”

!Apellidos = “Pérez Martín”

.Update

End With

Para contar el número de elementos en la tabla MiTabla utilizaremos la propiedad RecordCount del Recordset:

Dim RsetTabla as Recordset

Dim NumElementos as integer

Set RsetTabla = VarBD.OpenRecordset(“MiTabla”,dbOpenTable)

NumElementos = RsetTabla.RecordCount

Para mostrar en la pantalla Debug los datos de cada registro de la tabla “MiTabla” utilizaremos el método MoveNext del Recordset, que obtiene el siguiente registro del conjunto. Accederemos a los campos del registro utilizando la sintaxis Recordset_Abierto!Nombre_del_campo. La propiedad EOF del Recordset nos indicará cuando se ha llegado al final del conjunto de registros:

Dim RsetTabla as Recordset

Set RsetTabla = VarBD.OpenRecordset(“MiTabla”,dbOpenForwardOnly)

With RsetTabla

Do Until .EOF

Debug.Print “DNI: ” & !DNI & vbCRLF & _

“Nombre: “ & !Nombre & vbCRLF & _

“Apellidos: “ & !Apellidos

.MoveNext

Loop

End With

Para buscar los datos del registro con DNI=”12345678” utilizaremos el método FindFirst del Recordset, que obtiene el primer registro del conjunto de registros del Recordset que cumple una cierta condición, una vez encontrado el registro mostraremos los datos en el debug. Utilizaremos la propiedad NoMatch para saber si se ha encontrado el registro buscado, ya que será true si se ha llegado al final del recorset sin encontrar un regostro con los datos especificados:

Dim RsetTabla as Recordset

Set RsetTabla = VarBD.OpenRecordset(“MiTabla”,dbOpenSnapshot)

With RsetTabla

.FindFirst “DNI=12345678”

If .NoMatch Then

Debug.Print “Registro no encontrado”

Else

Debug.Print “DNI: ” & !DNI & vbCRLF & _

“Nombre: “ & !Nombre & vbCRLF & _

“Apellidos: “ & !Apellidos

End If

End With

Para borrar el registro con DNI=”12345678” utilizaremos el método FindFirst y el método Delete del Recordset, que elimina el registro actual del conjunto de registros:

Dim RsetTabla as Recordset

Set RsetTabla = VarBD.OpenRecordset(“MiTabla”,dbOpenSnapshot)

With RsetTabla

.MoveLast

.FindFirst “DNI=12345678”

If Not .NoMatch Then .Delete

End With

Hemos visto los métodos de acceso a registros, ahora veremos los métodos de movimiento dentro del recodset, el uso es similar a los de acceso a los registros, por eso sólo los enunciaremos:

MoveFistr: El cursor se sitúa en el primer registro.

MoveLast: El registro en el que nos situamos es el último del recordset.

MoveNext: Nos vamos al siguiente registro al que nos encontremos.

MovePrevious: Retrocedemos un registro en el recordset.

Move #n: Avanzamos n registros a partir de la posición actual.

Es importante controlar la situación en la que nos encontremos en el recordset a la hora de desplazarnos, ya que el acceso a una posición que no esté dentro del recordset produciría un error en tiempo de ejecución.

Ejemplo propuesto

Objetivo

El objetivo de este ejemplo es ampliar el ejemplo de la agenda de forma que los datos estén ahora almacenados en una base de datos.

La aplicación se diseñará en tres capas:

· Interfaz de usuario (FrmAgenda): capa que permite al usuario interactuar con el programa (idéntico al utilizado en la agenda que ya tenemos).

· Clase agenda (ClaAgenda): capa intermedia entre el interfaz de usuario y la clase de acceso a la base de datos.

· Clase de acceso a la base de datos (ClaDAO_Jet): capa que se comunica con el motor de base de datos. El objetivo es que esta capa sea lo suficientemente independiente del tipo de acceso a la base de datos elegido (DAO con Jet, DAO con ODBCDirect o RDO) como para permitir que sea sustituido por otro sin cambiar la capa superior.

Cada capa sólo podrá relacionarse con su capa inmediata superior e inferior, como muestra el dibujo:

El objetivo es aislar cada capa de la implementación de las demás, de forma que las capas inferiores puedan ser cambiadas sin que las modificaciones repercutan en las capas superiores. En particular, el objetivo que se pretende en este ejemplo y los dos siguientes es crear una capa de acceso a la base de datos diferente en cada ejemplo, pero utilizando el mismo interfaz de usuario y la misma agenda.

Esta independencia entre las diferentes capas es lo que confiere su potencia al modelo de desarrollo estructurado en capas, permitiendo una gran flexibilidad en el desarrollo y mantenimiento de las aplicaciones.

Desarrollo del ejemplo

Crearemos la base de datos para la agenda (bdAgenda.mdb) en Access, que contendrá una única tabla Agenda cuya arquitectura se muestra en la tabla siguiente:

El lector utilizará los siguientes elementos:

· ClaFicha: ya definida en anteriores ejemplos.

· ModDefiniciones: módulo con las definiciones utilizadas en la aplicación.

· FrmAgenda: formulario correspondiente a la capa de interfaz.

Desarrollaremos la clase correspondiente a la capa de agenda (ClaAgenda). Contendrá un objeto privado ObjAccesoBD, de tipo ClaDAO_Jet, a través del cual podrá interactuar con la base de datos. Esta clase proporcionará los siguientes métodos:

· Public Property Get IntNumFichas() As Integer: Método para obtener el número de fichas de la agenda. Llamará al método NumFichas del objeto ObjAccesoBd.

· Public Function CrearFicha(ByVal StrNombre As String, ByVal StrApellidos As String, ByVal StrDireccion As String, ByVal StrTelefono As String) As Integer: Método para crear una ficha nueva en la agenda. Creará un objeto de la clase ClaFicha y se lo pasará al método GuardarFicha del objeto ObjAccesoBD.

· Public Function BorrarFicha(ByVal IntNumFicha As Integer): Método para borrar una ficha de la agenda. Utilizará el método BorrarFicha del objeto ObjAccesoBD.

· Public Function Ficha(Optional ByVal IntIndice As Integer, Optional ByVal IntNumFicha As Integer) As ClaFicha: Método para obtener una ficha específica de la agenda, ya sea por índice o por número de ficha. Utilizará el método ObtenerFicha del objeto ObjAccesoBD.

· Private Sub Class_Terminate(): Al eliminar la agenda es necesario cerrar la base de datos y eliminar el objeto ObjAccesoBD.

Desarrollaremos también la clase correspondiente a la capa de acceso a la base de datos, que utilizará DAO y Jet (ClaDAO_Jet). Esta capa proporcionará los siguientes métodos:

· Public Property Get NumFichas() As Integer: Método para obtener el número de fichas de la tabla Agenda.

· Public Function AbrirAgenda() As CodigoRetorno: Método para abrir la base de datos.

· Public Function CerrarAgenda() As CodigoRetorno: Método para cerrar la base de datos.

Se recomienda al lector, para facilitar la comprensión de estos capítulos dedicados al acceso a bases de datos desde Visual Basic, que utilice los códigos proporcionados en el manual para estos tres elementos, y desarrolle personalmente las clases que implementan las demás capas.

· Public Function GuardarFicha(ByVal ObjFicha As ClaFicha, Optional ByRef IntNumFicha As Integer) As CodigoRetorno: Método para guardar una ficha. Devuelve el número de ficha asignado por la base de datos como campo autonumérico.

· Public Function ObtenerFicha(ByRef ObjFicha As ClaFicha, Optional ByVal IntIndice As Integer, Optional ByVal IntNumFicha As Integer) As CodigoRetorno: Método para obtener una ficha específica de la tabla Agenda. Permite buscar por índice o por número de ficha.

· Public Function BorrarFicha(ByVal IntNumFicha) As CodigoRetorno: Método para borrar una ficha de la tabla Agenda.

· Private Sub Class_Initialize(): Al crear un objeto de esta clase, debe de llamarse automáticamente a su correspondiente método AbrirAgenda.

Seguiremos unas normas sencillas junto con unos comentarios breves, claros y concisos que facilitarán la posterior comprensión del programa.

Todos los métodos de la clase de acceso a la base de datos incluirán al comienzo la sentencia On error goto TratamientoError, con su correspondiente sección de tratamiento de error, para interceptar los posibles errores del motor de la base de datos. Además, todas las funciones devolverán un código de retorno especificado por el tipo CódigoRetorno definido en el módulo ModDefiniciones, que determinará si han podido realizar correctamente su función.

domingo, 21 de julio de 2013

Microsoft Visual Basic

Introducción al Curso

1. Formularios y eventos

Introducción

Conocimientos teóricos

Formularios, controles y eventos

Ciclo de vida de un formulario

La ventana Debug

Ejemplo propuesto

Ejemplo resuelto

Formulario 1

Formulario 2

2. Identificación de objetos (controles) en un formulario

Introducción

Conocimientos teóricos

Cómo utilizar controles: eventos y propiedades

Controles comunes: Label, TextBox, CommandButton, CheckBox

Identificar el tipo de un control

Colección Controls de un formulario

Ejemplo propuesto

Ejemplo resuelto

3. Clases y objetos (I)

Introducción

Conocimientos teóricos

Los objetos en Visual Basic

Concepto de encapsulación (Public v.s. Private)

Utilización de variables de objeto

Instrucción Property

Variables estáticas

Ejemplo propuesto

Ejemplo resuelto

Formulario

Clase Ficha

4. Clases y objetos (II)

Introducción

Conocimientos teóricos

Cómo crear colecciones de objetos: la clase Collection

Propiedades y métodos del objeto Collection

Cómo acceder a los elementos de una colección: claves e índices

Agregar elementos a una colección

Eliminación de elementos de una colección

Recuperación de elementos de una colección

Control HScrollBar

Más conceptos de clases: eventos Initialize y Terminate

Ejemplo propuesto

Objetivo

Desarrollo del ejemplo

Ejemplo Resuelto

Formulario

Clase Agenda

5. Tecnología ActiveX

Introducción

Conocimientos teóricos

Qué es un componente ActiveX

Tipos de componentes ActiveX

Creación dinámica de matrices

Preservar el contenido de las matrices dinámicas

Matrices de controles

Publicar un control ActiveX en un página Web

Ejemplo propuesto

Objetivo

Desarrollo del ejemplo

Ejemplo resuelto

6. Acceso a bases de datos (DAO y Jet)

Introducción

Conocimientos teóricos

DAO y Jet

Estructura de una aplicación de bases de datos en Visual basic con DAO y Jet

El modelo de objetos DAO

Programación con DAO y Jet

Ejemplo propuesto

Objetivo

Desarrollo del ejemplo

Si te intereso el POST y quieres terminarlo de leer y seguir la tutoría abajo esta el link... 2da Parte Microsoft Visual Basic

Si te intereso el POST y quieres terminarlo de leer y seguir la tutoría abajo esta el link...

2da Parte Microsoft Visual Basic