Modulo de Diseño y Realizacion de Servicios

TÉCNICO SUPERIOR EN DESARROLLO DE
APLICACIONES INFORMÁTICAS
CICLO FORMATIVO DE GRADO SUPERIOR
FORMACIÓN PROFESIONAL A DISTANCIA
1
Unidad
Introducción Visual Basic.Net
MÓDULO
Diseño y realización de servicios de
presentación en entornos gráficos
Título del Ciclo: DESARROLLO DE APLICACIONES INFORMATICAS
Título del Módulo: DISEÑO Y REALIZACIÓN DE SERVICIOS DE

PRESENTACIÓN EN ENTORNOS GRÁFICOS
Unidad 1: INTRODUCCIÓN VISUAL BASIC .NET
Dirección: Dirección General de Políticas Educativas, Ordenación

Académica y Formación Profesional
Servicio de Formación Profesional Inicial y Aprendizaje
Permanente
Dirección de la obra:
Alfonso Careaga Herrera
Antonio Reguera García
Arturo García Fernández
Ascensión Solís Fernández
Juan Carlos Quirós Quirós
Luís Mª Palacio Junquera
Yolanda Álvarez Granda
Coordinador de los contenidos: Mateo García Parra
Autor: Mateo García Parra
Colección: Materiales didácticos de aula
Serie: Formación profesional especifica
Edita: Consejería de Educación y Ciencia
ISBN: 978-84-692-3442-6
Deposito Legal: AS-3565-2009
Copyright: ©2009. Consejería de Educación y Ciencia
Esta publicación tiene fines exclusivamente educativos. Queda prohibida la venta, así como la
reprodución total o parcial de sus contenidos sin autorización expresa de los autores y del Copyright
Unidad
1 Introducción Visual Basic NET
OBJETIVO DE LA UNIDAD
El objetivo de la unidad es conocer el entorno de Visual Basic .NET. Veremos cómo crear
nuestro primer proyecto, dibujando algunos controles básicos en el formulario de inicio, así
como proporcionarle código a los eventos o acciones de dichos controles. También nos
iniciaremos en el uso de la depuración del proyecto y de la ayuda.
INDICE DE CONTENIDOS
¿QUÉ ES VISUAL BASIC .NET? ...................................................................................... 4

¿DÓNDE PUEDO OBTENER VISUAL BASIC .NET? ...................................................... 4
INICIO CON VISUAL BASIC EXPRESS EDITION ............................................................ 4
ENTORNO DE DESARROLLO DE VISUAL BASIC. FORMULARIOS. ........................... 4
DIBUJAR CONTROLES EN EL FORMULARIO ............................................................... 6
PROPIEDADES DE LOS CONTROLES............................................................................ 7
AÑADIR CÓDIGO A LOS CONTROLES......................................................................... 10
GUARDAR EL PROYECTO ............................................................................................. 14
UTILIZACIÓN DEL DEPURADOR DE PROYECTOS ..................................................... 14
UTILIZACIÓN DE LA AYUDA.......................................................................................... 15
3
¶ Módulo: Diseño y realización de servicios de
¶
¿Qué es Visual Basic .NET?
Microsoft Visual Basic es un lenguaje de programación que está diseñado para crear
aplicaciones orientadas a objetos en el entorno del sistema operativo Microsoft Windows. Está
implementado sobre el framework .NET que es un amplio proyecto de Microsoft para crear una
plataforma que permita un cómodo y rápido desarrollo de aplicaciones.
¿Dónde puedo obtener Visual Basic .NET?
Microsoft nos ofrece una versión gratuita de la herramienta llamada “Visual Basic Express
Edition”. Podemos descargarla en la dirección web siguiente:
http://www.microsoft.com/express/vb/default.aspx
Podéis seleccionar el idioma Español antes de la descarga.
Visual Basic Express Edition es funcional durante 30 días. Pero si te registras ya estará
operativo de forma indefinida. Este registro es gratuito, sólo necesitaras una cuenta de correo
donde te enviarán el número de registro.
En está página puedes encontrar información sobre el Visual Basic que será útil tanto para el
principiante como para el programador ya experimentado.
Inicio con Visual Basic Express Edition

Técnico Superior en Desarrollo de Aplicaciones Informáticas
Una vez instalada la herramienta, la ejecutamos. Aparecerá la pantalla de bienvenida (página

de inicio) del Visual Basic Express. En ella tenemos también enlaces a distinta información
para los usuarios de Visual Basic.
A continuación vamos a la opción del menú “Archivo” y seleccionamos “Nuevo Proyecto”.

Aparecerá un cuadro de diálogo, seleccionamos “Aplicación de Windows Forms” en “Plantillas
instaladas de Visual Studio”. El nombre por defecto que asigna al proyecto es
“WindowsApplication1”, vamos a cambiar ese nombre por “MiPrimerPrograma”, y hacemos clic
en el botón “Aceptar”.
Entorno de desarrollo de Visual Basic. Formularios.
Una vez iniciado el proyecto nos mostrará el entorno de desarrollo de aplicaciones (fig.1).
Estamos en la pestaña de diseño: “Form1.vb [Diseño]”, y en primer término vemos el
“formulario principal” o “formulario de inicio”, identificado en su parte superior con el nombre
“Form1”. Este formulario es el que se mostrará cuando ejecutemos la aplicación. En él
dibujaremos los objetos o controles que necesitemos para nuestro proyecto.
4
Unidad
Fig.1. Entorno de desarrollo de Visual Basic
En la parte izquierda tenemos el “Cuadro de herramientas” (fig.2). Si situamos el ratón sobre la

pestaña (sin necesidad de hacer clic) se desplegará el cuadro con los controles disponibles.
Los controles constituyen aquellos elementos que insertamos dentro de un formulario, y que
permiten al mismo interactuar con el usuario, tales como botones de pulsación, cajas de texto,
casillas de verificación, cajas con listas de valores, etc.
En la ficha “Controles comunes” tenemos los controles más utilizados.
Fig.2. Pestaña cuadro de herramientas
Si no ves la pestaña de la figura anterior (fig.2.). También puedes acceder al cuadro de

herramientas desde el icono de la barra de herramientas representado en la figura siguiente
(fig.3):
5
¶
Fig.3. Icono “cuadro de herramientas” de la barra de herramientas.
Dibujar controles en el formulario
Vamos a dibujar un control “TextBox” y un control “Button” (fig.4). Hay varias maneras de
realizar este proceso, una de ellas es haciendo doble clic sobre los controles en el cuadro de
herramientas. Primero en el control “Button” y después en el control “TextBox”, que están
señalados en la siguiente figura:
Fig.4. Cuadro de herramientas. Controles Button y Textbox.
Ahora volvemos al formulario “Form1”, moviendo el cursor del ratón hacia él se pliega el
“cuadro de herramientas” y podemos ver los dos controles en la esquina superior izquierda,
uno encima del otro. Uno a uno, los seleccionamos y arrastramos con el ratón hacia el lugar del
formulario que consideremos mas apropiado. (fig.5).
6
Unidad
Fig.5. Formulario con los dos controles.
Si nos hemos equivocado y deseamos borrar controles del formulario, simplemente

seleccionamos el control a borrar (haciendo clic sobre él) y pulsamos la tecla “Supr” (suprimir).
El control que hemos creado, “Button1”, es un objeto de la clase Button, y representa un típico
botón de Windows. Y el otro elemento, “TextBox1”, es un objeto de la clase TextBox, y
representa un cuadro de texto de Windows.
Otras formas de dibujar controles en el formulario son:
• Haciendo clic sobre el icono del control, y a continuación hacemos clic sobre la superficie del
formulario. El nuevo control se insertará desde el punto en que hemos pulsado, extendiéndose
hacia la derecha y abajo.
• Haciendo clic sobre el icono del control, y seguidamente clic sobre la posición del formulario
en la que queramos comenzar a dibujar el control, arrastraremos y soltaremos dando nosotros
el tamaño requerido al control.
Propiedades de los controles
Todos los controles que dibujamos en el formulario tienen un conjunto de propiedades que
identificaran a cada control y definirán su aspecto y su comportamiento. Vamos a acceder a la
ventana de las propiedades de los controles haciendo clic en el icono de la barra de
herramientas (fig.6):
Fig.6. Icono de la ventana de propiedades.
También podemos acceder a la ventana de propiedades seleccionando la opción Ver +

Ventana Propiedades del menú o pulsando F4.
7
¶
La ventana que nos aparecerá será la siguiente (fig.7):
Fig.7. Ventana de propiedades.
Nota: podemos fijar las ventanas, haciendo clic en la “chincheta” de la franja azul superior del
cuadro
En la parte superior de la ventana de propiedades vemos una lista desplegable (fig.8), en ella
están todos los controles que tenemos en el formulario, además del propio formulario que
también dispone de propiedades. Al seleccionar uno de ellos accedemos a sus propiedades.
8
Unidad
Es muy importante fijarse en el control que aparece en esa lista, antes de realizar alguna
modificación en las propiedades, para cerciorarnos de que estamos editando las propiedades
del control que realmente queremos modificar. Esto es motivo muchas veces de
equivocaciones.
Fig.8. Lista desplegable de la ventana propiedades.
Vamos a modificar la propiedad Text del control Button1. Editamos el valor de la propiedad
Text, eliminamos el texto “Button1” y escribimos “Haz clic”, cuando pulsemos la tecla Enter o
el tabulador se modificará el texto del botón en el formulario (fig.9).
Fig.9. Modificar la propiedad Text del control Button1.
9
¶
Añadir código a los controles
Vamos introducir código a nuestro ejemplo. Para acceder al código del formulario, podemos
hacerlo de alguna de las siguientes maneras:
• Seleccionar la opción Ver + Código en el menú.
• Pulsar F7.
• Hacer clic derecho sobre el formulario y elegir la opción Ver código del menú contextual que
aparece.
Nos mostrará la siguiente ventana:

Fig.10. Ventana de código.
Nos aparece una nueva pestaña en el entorno de desarrollo: “Form1.vb”, aquí escribiremos el
código del formulario “Form1”.
Para volver a la ventana que hemos utilizado hasta ahora para diseñar el formulario haremos
clic en la pestaña “Form1.vb[Diseño]”.
Pero volvamos a la pestaña de código “Form1.vb” y observemos el código que nos muestra:
Public Class Form1
End Class
Todo formulario es un objeto y el código de un objeto se escribe en una clase. Por esto, el
código lo escribiremos dentro de un bloque Class... End Class. “Form1” es el nombre de la
clase.
10
Unidad
Vamos a introducir código para que al hacer clic en el botón “Button1” (evento “Click” de
“Button1”) se muestre el texto “¡Hola Mundo!” en el cuadro de texto “TextBox1”. La línea de
código será:
Me.TextBox1.Text = "¡Hola Mundo!"
Con está sentencia conseguimos que al hacer clic en el botón “Button1”, la propiedad “Text”
del cuadro de texto “TextBox1” reciba el valor “¡Hola Mundo!”.
Para escribir el código del evento “Click” correspondiente a la pulsación del control “Button1”, la
forma más rápida es haciendo doble clic sobre el control en la ventana de diseño del formulario
(pestaña “Form1.vb [Diseño]”), lo que abrirá el editor de código y nos situará en el
procedimiento vacío “Button1_Click”. Escribimos dentro de él la línea de código anterior.
Public Class Form1
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles Button1.Click
Me.TextBox1.Text = "¡Hola Mundo!"
End Sub
End Class
Probemos la aplicación ejecutándola, pulsemos la tecla F5 (o también la opción Depurar +

Iniciar depuración). Nos aparecerá el formulario en la pantalla y al hacer clic en el botón,
aparecerá el texto que escribimos.
Lo que ha ocurrido es que se ha ejecutado el evento “Click” del botón “Button1” tal y como nos
lo indica la expresión que vemos al final del encabezamiento del procedimiento.
...Handles Button1.Click
Esto es lo verdaderamente importante. La palabra clave “Handles”, seguida del nombre del
control, un punto y el nombre del evento; esto le indica al Framework que debe ejecutar este
procedimiento cuando se produzca el evento para ese control. El nombre del procedimiento
“Button1_Click” no tiene importancia, se puede modificar y poner cualquier otro; pero
normalmente lo dejaremos como está ya que le otorga un nombre significativo.
Ahora vamos a dibujar otro botón en nuestro formulario. Para ello seleccionemos la pestaña
“Form1.vb [Diseño]”. Vayamos al “cuadro de herramientas” y hacemos doble clic en el control
Button. Lo colocamos debajo del botón que ya teníamos. Y modificamos la propiedad “Text”
asignándole el literal “Borrar” (fig.11).
11
¶
Fig.11. Formulario con el nuevo botón.
Para asignarle el código al nuevo botón, vamos a acceder al procedimiento “Button2.Click” de

otra manera. Seleccionamos la pestaña de código: “Form1.vb” y en la lista despegable de la
parte superior de la ventana, donde están todos los objetos que tenemos en el formulario,
seleccionamos el nuevo botón “Button2” (fig.12)
Fig.12. Lista desplegable con los objetos del formulario.
Ahora, de la lista desplegable que está a la derecha de la anterior, seleccionamos el evento

que deseamos programar, será el evento “Click” (fig.13).
12
Unidad
Fig.13. Seleccionar el evento “Click”
Ya tenemos el procedimiento “Button2.Click” para programar el segundo botón de nuestro

formulario. Podíamos haber llegado al procedimiento haciendo doble clic en el “Button2” en el
diseño del formulario, como hicimos con el “Button1”, pero así hemos visto otra forma de
acceder al código de los procedimientos de los objetos.
Añadimos a este procedimiento la siguiente línea de código:
Private Sub Button2_Click(ByVal sender As Object, ByVal e As System.EventArgs)

Handles Button2.Click
Me.TextBox1.Text = Nothing
End Sub
Con lo que conseguiremos “borrar” el contenido de la propiedad “Text” del objeto “TextBox1” al
hacer clic en el botón “Button2.”
Ejecutamos la aplicación, pulsar F5, y, cuando aparezca el formulario, pulsamos primero en el

botón “Haz clic” y después en el botón “Borrar”.
Para detener la ejecución podemos hacerlo de diferentes maneras, en la siguiente figura

vemos dos de ellas: mediante el botón de la barra de herramientas o cerrando el formulario.
13
¶
Fig.14.Deteniendo la ejecución.
Guardar el proyecto
Por defecto, el proyecto se guardará en la carpeta “Mis documentos”, dentro de ésta en la ruta:
“Visual Studio 2008\Projects\MiPrimerPrograma”. Dentro de esta última carpeta tenemos otra
carpeta con el mismo nombre y un fichero del tipo “Microsoft Visual Studio Solution”. Este es el
fichero que hay que hacer doble clic en él para que podamos editar el proyecto con el Visual
Basic Express.
Utilización del depurador de proyectos
VB (Visual Basic) tiene un buen depurador, que nos permitirá introducirnos dentro del código
de nuestro programa durante la ejecución del mismo, para observar qué es lo que está
ocurriendo: ejecutar línea a línea el programa, observar el valor de las variables, etc., aspectos
todos ellos fundamentales para el seguimiento de errores y fallos en la lógica de la
programación.
Vamos a ejecutar nuestro proyecto en modo depuración. Para ello pulsaremos F8, o
seleccionaremos en el menú “Depurar + Paso a paso por instrucciones”. Cualquiera de estas
acciones iniciará la ejecución del programa dentro del contexto del depurador. Nos aparecerá
el formulario, hacemos clic en el botón con el texto “Haz clic” y la ejecución se detendrá en la
primera línea de código del procedimiento “Button1.Click”, destacándola en color amarillo. La
línea marcada en amarillo indica que es la siguiente línea a ejecutarse, para ejecutarla y pasar
a la siguiente línea pulsaremos de nuevo F8, y así sucesivamente hasta llegar a la última línea
del procedimiento (End Sub), ejecutada ésta, se finalizará el procedimiento y nos mostrará de
nuevo el formulario. Si hacemos clic en el botón con el texto “Borrar”, se realizará el mismo
proceso pero con el procedimiento “Button2.Click”.
14
Unidad
En el proceso de depuración, podemos ver de forma inmediata el valor de una variable o de
una propiedad simplemente situando el cursor del ratón sobre ella. En la figura siguiente
(fig.15), observamos que la línea siguiente a ejecutarse es “End Sub”, por lo que la línea
anterior que asignaba el texto “¡Hola Mundo!” a la propiedad “Text” de cuadro de texto
“TextBox1” ya se ha ejecutado. Si colocamos el cursor sobre la expresión
“Me.TextBox1.Text” aparece un recuadro con el contenido de dicha propiedad (fig.15).
Fig.15.Depurando la aplicación.
Probar a hacer lo mismo pero antes de ejecutar la línea de código que asigna el texto a la
propiedad. Vemos que la propiedad Text no tiene ningún contenido.
Si en cualquier momento queremos continuar la ejecución normal del programa sin seguir
utilizando el depurador, pulsaremos F5.
Utilización de la ayuda
La ayuda o MSDN Library (Microsoft Development Network Library) es una importantísima

fuente de información de la plataforma NET. La aplicación utilizada para navegar por la
documentación de la ayuda es Microsoft Document Explorer, que permite al programador una
enorme flexibilidad a la hora de realizar consultas sobre la ayuda disponible de los diferentes
productos de desarrollo que componen la plataforma .NET.
Para acceder a ella pulsaremos la tecla F1, tanto si estamos en la pestaña de diseño como en
la de código. Aparecerá una nueva entrada en la barra de tareas (fig.16).
Fig.16. Accediendo a la ayuda.
15
¶
Vamos a realizar una búsqueda en la ayuda para que nos informe sobre el tipo de datos
“String”. Seleccionamos la pestaña “Buscar” y escribimos en el primer cuadro “tipo String”,
hacemos clic en el botón “Buscar” de la derecha y esperamos a que realice la búsqueda.
Fig.17. Búsqueda en la ayuda.
Como podemos observar, nos proporciona numerosas entradas que hacen referencia al tema
buscado. Tendremos que seleccionar aquellas que se ajusten más a nuestras necesidades de
información. Aunque en este caso la primera entrada nos puede resolver totalmente la
consulta, otras veces no es así, hay que realizar una exhaustiva búsqueda para encontrar
aquello que deseamos.
Nota: También podemos observar que realiza la búsqueda primero en el MSDN online, en
comunidades y foros, y por último en la ayuda local, si quisiéramos que busque primero en la
ayuda local, o sólo en esta, podemos realizar la siguiente modificación: en el menú
seleccionamos Herramientas + Opciones y dentro de esta en Ayuda + En Pantalla. Aquí
seleccionamos la opción que nos resulte más conveniente en el apartado “Cuando cargue
contenido de la ayuda…”
Hacemos clic en la entrada “String (Tipos de datos, Visual Basic)” y nos mostrará información
sobre este tipo de datos. Si la información va a ser consultada con frecuencia, conviene
agregarla a “Favoritos de la ayuda”, para ello hacemos clic en el icono de la barra de
herramientas (fig.18). Para acceder a los “favoritos de la ayuda” ya guardados, tenemos la
pestaña lateral “Favoritos de la ayuda” que está en la izquierda de la ventana (fig.18.).
16
Unidad
Fig.18. Agregar a favoritos de la Ayuda.
En la Ayuda encontraremos información de muy distintos niveles. Consultas como “Crear el

primer programa en Visual Basic” nos proporciona un conjunto de enlaces donde os explican
todo lo contenido en esta unidad. Es sin duda el mejor manual del lenguaje que podéis
encontrar para todas las necesidades de información. Os animo a que la consultéis con
frecuencia.
17
Técnico Superior en
Desarrollo de Aplicaciones Informáticas
2
Unidad
Características del lenguaje y

controles más comunes
MÓDULO

Unidad 2: CARACTERÍSTICAS DEL LENGUAJE Y CONTROLES MÁS

COMUNES

Permanente
ISBN: 978-84-692-3442-6
Unidad
2 controles más comunes
En esta unidad veremos las características del lenguaje de programación Visual Basic Net. Y
desarrollaremos un ejercicio que nos permitirá conocer tres controles más comunes en un
formulario de Windows: TextBox, Button y Label.
CARACTERÍSTICAS DEL LENGUAJE............................................................................. 4

Declaración de variables ............................................................................................ 4
Declaración de constantes ......................................................................................... 6
Declaración de arrays ................................................................................................ 6
Redimensión de arrays .............................................................................................. 8
Recorrer un array ....................................................................................................... 8
Operadores aritméticos .............................................................................................. 9
Operadores de comparación...................................................................................... 9
Procedimientos......................................................................................................... 10
Pasos de parámetros ............................................................................................... 11
Estructuras de control .............................................................................................. 12
• Sentencia If ................................................................................................... 12
• Sentencia Select Case.................................................................................. 12
• Sentencia Do…Loop..................................................................................... 13
• Sentencia For…Next..................................................................................... 16
• Sentencia For Each…Next ........................................................................... 16
CONTROLES MÁS COMUNES. TEXTBOX, BUTTON Y LABEL .................................. 17
3
¶
Características del lenguaje
Teniendo en cuenta la experiencia que ya tuvisteis en el primer curso en programación,

muchos de los conceptos que veamos en este apartado os resultarán familiares.
Declaración de variables
Utilizamos la palabra reservada “Dim” seguida del nombre de la variable y a continuación la

palabra reservada “As” y el tipo de variable que vamos a declarar.
Dim Valor As String ' cadena de caracteres

Dim Cuenta As Integer ' numérico entero de 32 bits con signo
Dim Cta As Single ' numérico de punto flotante de precisión simple de 32 bits
Dim FhActual As Date ' fecha y hora
Nota: la comilla simple (') indica el comienzo de un comentario en el código
Podemos también realizar declaraciones de variables en la misma sentencia Dim, aunque sean
de distinto tipo.
Dim Nombre, Apellidos, Ciudad As String

Dim Cta As Single, Num As Integer
Vamos a crear un nuevo proyecto para probar las declaraciones de variables que realicemos
en esta unidad de trabajo. Abrimos la aplicación Visual Basic, o si ya la tenemos abierta vamos
al menú a Archivo + Nuevo Proyecto. Creamos una nueva aplicación para Windows y le
asignamos el nombre “Unidad2”. Agregamos un botón al formulario y en el evento “click” de
botón escribimos las siguientes declaraciones y asignaciones de variables:

' Declaración de variables
Dim ImporteFac As Integer

Dim Precio As Single
Dim Valor As String
Dim Correcto As Boolean ' valores true o false
Dim fNueva As Date
Dim fCompleta As Date
Dim fHora, fHora1 As Date
' Asignación de valores a las variables
ImporteFac = 875
Precio = 50.75
Valor = "mesa"
Correcto = True
FNueva = "21/11/2007" ' dia/mes/año
FCompleta = "7/11/2007 14:22:00"
fHora = "5:40:00 PM"
fHora1 = "17:40:00"
End Sub
Vamos a ejecutar la aplicación en modo depuración, pulsamos F8, y cuando aparezca el

formulario, hacemos clic en el botón “Button1”. Se detendrá la ejecución al principio del
procedimiento que resuelve el evento clic del botón, “Button1.click”.
Antes de ejecutar ninguna línea, vamos a visualizar las variables locales de la aplicación en
una ventana, para ello vamos al menú Depurar + Ventanas + Variables locales. Nos aparece
una ventana con las variables locales de la aplicación, fijémonos en las que hemos declarado
nosotros dentro del procedimiento que vamos a ejecutar (fig.1).
4
Unidad
Fig.1. Ventana variables locales.
Observando la ventana de variables locales antes de asignar ningún valor a las variables,
podemos ver los valores iniciales para los distintos tipos de variables. Para “Integer” es cero;
también es cero para el tipo “Single”, pero con un decimal; para “String” es “Nothing”; para el
tipo “Boolean” es “false”. Y para el tipo “Date” le asigna el valor “#12:00:00 AM#”.
Vayamos ejecutando línea a línea el código, para ello pulsamos nuevamente F8. Vemos como
se modifican los valores de las variables a medida que ejecutamos las líneas de código.
Recordar que la línea resaltada en amarillo es la línea que se va a ejecutar al pulsar F8,
Cuando llegamos al final del procedimiento (“End Sub”).Tenemos las siguientes
asignaciones (fig.2).
Fig.2. Ventana variables locales.
Los valores que nos llaman la atención son los de las variables de tipo “Date”. Le asignamos
fechas en el formato “día/mes/año” (FNueva = "21/11/2007") y a efectos de almacenamiento
interno la convierte en el formato “mes/día/año” (#11/21/2007#). Y, también, cuando le
asignamos una hora en formato de 24 horas, la representa en el formato 12 horas; con la
sentencia (fHora1 = "17:40:00"), almacena el valor (#5:40:00 PM#).
No obstante, podemos asignar valores de tipo “Date” en formato “mes/día/año” utilizando el

carácter “#”. Por ejemplo, escribir la sentencia siguiente y ejecutar la aplicación.
5
¶
Dim fFecha As Date = #11/21/2007#
Observamos también que es posible declarar una variable y en la misma línea de código
asignarle un valor.
Declaración de constantes
Al igual que las variables, una constante es un elemento del lenguaje que guarda un valor, pero
que en este caso y como su propio nombre indica, dicho valor será permanente a lo largo de la
ejecución del programa, no pudiendo ser modificado.
Para declarar una constante, utilizamos la palabra reservada “Const” seguida de nombre de la
constante y le asignamos el valor que va a tener.
Const Pi = 3.1416
En la declaración de la constante se pude especificar el tipo de valor que va a guardar,

atendiendo a los tipos de datos que vimos en el apartado anterior.
Const Pi2 As Single = 3.1416
En el primer caso, la constante “Pi” se considera del tipo “Double”, que representa valores
“numéricos de punto flotante de doble precisión de 64 bits”, el doble que un valor de tipo
“Single”. (Observarlo en la ventana Variables locales al depurar la aplicación).
Declaración de arrays
Para declarar un array, o matriz, actuaremos prácticamente igual que para declarar una
variable, con la diferencia de que utilizaremos los paréntesis después del nombre, para indicar
que se trata de un array, y opcionalmente, dentro de los paréntesis, indicaremos el número de
elementos que inicialmente va a tener el array. También es posible, asignar valores a los
elementos en el mismo momento de su declaración.
Debemos tener en cuenta a la hora de establecer el número de elementos, que el primer índice
de un array es el cero, por lo que al ser creado, el número real de elementos en un array será
el especificado en la declaración más uno.
Para probar las siguientes sentencias de declaraciones de arrays, vamos a añadir otro botón al
formulario “Button2”, y escribimos las siguientes líneas de código que declaran de arrays.

' Declaración de un array sin elementos
Dim Paises() As String
' array con 4 elementos: del 0 a 3
Dim Nombres(3) As String
' asignamos un valor a las dos primeras posiciones del array
Nombres(0) = "Enrique"
Nombres(1) = "Marta"
' array con 3 elementos, cuyos valores asignamos en el momento de la
declaración del array
Dim Colores() As String = {"Rojo", "Verde", "Azul"}
End Sub
6
Unidad
Ejecutamos la aplicación en modo depuración, pulsando F8, y vamos ejecutando, línea a línea,
hasta llegar al “End Sub” del procedimiento que se ejecuta al hacer clic al botón último añadido,
“Button2.Click”.
En la ventana de las variables locales podemos observar los valores que tomarán los arrays
declarados. (fig.3). Hacemos clic en el símbolo “+” que tenemos a la izquierda del nombre de
los arrays “Colores” y “Nombres”.
Fig.3. Ventana Variables Locales. Declaración de arrays.
Vemos que los arrays declarados los define en la columna “Tipo” con la expresión “String()”,
esto es, que contendrán valores de tipo “String” y con los paréntesis puesto que son arrays.
El array “Paises” no tiene ningún número de elementos, su valor es “Nothing”. El array
“Nombres” tiene 4 elementos, del 0 al 3, las dos primeras posiciones con los valores asignados
y las dos últimas con valor “Nothing”, ya que nada hemos asignado a esas posiciones. Y el
array “Colores” tiene 3 elementos, con índice de 0 al 2, con los valores asignados al declararlo.
En las declaraciones que hemos hecho de arrays, todos sus valores son del mismo tipo de
datos. Si necesitamos que un array almacene datos de tipos diferentes, debemos declarar el
array como tipo “Object”, el tipo de dato genérico en el entorno de NET. Por ejemplo,
probemos las siguientes líneas de código:
Dim Valores(3) As Object

Valores(0) = 1 'integer
Valores(1) = "datos" 'string
Valores(2) = False ' boolean
Valores(3) = #11/21/2007# ' date
En la ventana de las variables locales podemos observar los valores de distinto tipo que
contendrá el array (fig.4).
7
¶
Fig.4. Ventana Variables Locales. Array de tipo Object.
Nota: Si observáis, la asignación de la fecha a la última posición del array se tuvo que hacer en
el formato “mes/día/año”, empleando el símbolo “#”. Si se asignase con las comillas,
(“21/11/2007”) consideraría que se trataba de un valor de tipo “String”, no de un valor de tipo
“Date”.
Una solución sería utilizar la función “CDate”, para convertir una expresión (“String”) en tipo
“Date”:
Valores(3) = CDate("21/11/2007") ' date
En esto ejemplo hemos utilizado arrays de una única dimensión pero, lógicamente, podemos
declarar arrays de más dimensiones.
Dim datos(2, 2) As Integer ' array de dos dimensiones
Redimensión de arrays
Para modificar el tamaño o número de elementos de un array, emplearemos la instrucción

“ReDim”, seguido del array a modificar y el nuevo tamaño. Pero esta acción provoca la pérdida
de la información que tuviese almacenado el array. Si queremos evitar esta pérdida, tendremos
que incluir la palabra “Preserve” después de la declaración “Redim”.
Dim Nombres(2) As String ' array con 3 elementos

Nombres(0) = "Enrique"
Nombres(1) = "Marta"
Nombres(2) = "Elena"
' redimensionamos el array Nombres para que tenga dos elementos más,
' para conservar los valores que ya tienen los tres primeros elementos
' especificamos la palabra Preserve al redimensionar
ReDim Preserve Nombres(4)
Nombres(3) = "Carlos"
Nombres(4) = "Andrés"
Utiliza el ejercicio “Unidad2” para probar estas líneas de código. Primero redimensiona el array
sin la palabra “Preserve” y observa en la ventana de variables locales como se han perdido los
tres primeros valores del array. Luego comprueba como con la palabra “Preserve” estos valores
se mantienen.
Recorrer un array
Para recorrer todos los elementos de un array emplearemos la estructura de control

“For...Next”. Vamos a borrar todos los objetos que tenemos en el ejercicio “Unidad2” y
dibujamos un botón y un cuadro de texto. Esto es, nos quedaría en el formulario dos controles,
“TextBox1” y “Button1”.
En la ventana de código incluiremos las siguientes líneas en el procedimiento “Button1.Click”.
8
Unidad

' declaramos un array y le asignamos valores
Dim Numeros() As Integer = {1, 2, 3, 4, 5, 6, 7}
' recorremos el array y añadimos cada elemento al cuadro de texto
TextBox1
For Each i As Integer In Numeros
Me.TextBox1.AppendText(i)
Next
End Sub
La variable “i” (que la declaramos de tipo “Integer”) recogerá cada elemento del array
“Numeros” y mediante el método “AppendText” del cuadro de texto, se añadirá al contenido de
la propiedad “Text” del “TextBox1”. Al final, en la propiedad “Text” tendremos la secuencia de
todos los elementos del array “Numeros”.
Operadores aritméticos
Veamos un breve cuadro con los operadores aritméticos.
Suma/Resta +/-
Multiplicación *
Potencia ^ Dim Rtdo As Integer = (-2) ^ 3 ' Rtdo = -8
División real / Dim Rtdo As Single = 9 / 5 ' Rtdo = 1.8
División entera \ Dim Rtdo1 As Single = 9 \ 5 ' Rtdo = 1.0
Resto Mod Divide, con división entera, dos números y devuelve el resto de la
división.
Dim Resto As Single = 9 Mod 5 ' Rtdo = 4.0
Concatenación & Une dos o más cadenas de caracteres para formar una única cadena.
Dim Nombre As String = "Marcos " & "García"
' Nombre = "Marcos García"
Operadores de comparación
< Menor que

<= Menor o igual que
> Mayor que
>= Mayor o igual que
= Igual a
<> Distinto de
El resultado obtenido es un valor de tipo “Boolean”, esto es un valor lógico, “True” (verdadero)
o “False” (falso).
Dim Rtdo As Boolean = 8 > 5 ' Rtdo = True
Para obtener más información sobre los operadores del lenguaje, podéis consultar la ayuda. Y
sobre los operadores lógicos no hago referencia a ellos ya que son similares a los de otros
lenguajes de programación.
9
¶
Procedimientos
Los procedimientos son un conjunto de sentencias de código, identificadas con un nombre, que
al invocar a éste se ejecutan en secuencia. Existen tres tipos:
• Los procedimientos “Sub” realizan acciones pero no devuelven un valor al punto de

llamada. Los controladores de eventos son procedimientos Sub que se ejecutan en
respuesta a un evento.
• Los procedimientos “Function” pueden devolver un valor al procedimiento que origina la

llamada. La instrucción “MessageBox.Show” es un ejemplo de función.
• Los procedimientos “Property” devuelven y asignan valores de propiedades de clases.
Sintaxis de un procedimiento tipo “Sub”:
[Accesibilidad] Sub NombreProcedimiento[(ListaParámetros)]

[líneas de código]
[Exit Sub | Return]
End Sub
La “Accesibilidad” indicará la posibilidad de invocar al procedimiento desde los distintos puntos

de la aplicación. Por ejemplo, un procedimiento con accesibilidad “Private” en un formulario,
será accesible únicamente en ese formulario, no se podrá invocar desde otro formulario de la
aplicación. Si no especificamos nada, será “Public”, reconocible en toda la aplicación.
La sentencia “Return” y “Exit Sub” permiten concluir la ejecución del procedimiento sin haber
llegado a su fin. Podemos utilizarla en tantos lugares dentro de un procedimiento como sea
necesario.
Sintaxis de un procedimiento “Function”:

[Accesibilidad] Function NombreFunción[(ListaParámetros)] As TipoDato

[Return Valor]
[NombreFunción = Valor]
[Exit Function]
End Function
Como podemos ver, los procedimientos “Function”, llamados “funciones”, pueden retornar un
valor, para ello tenemos las sentencias “Return Valor” o “NombreFunción = Valor”. Veamos un
ejemplo que podemos probar en el ejercicio “Unidad2”.
Declaramos una función con el nombre “CalcularSuma” y dos parámetros “Operando1” y

“Operando2” de tipo “Integer”, por lo tanto el valor que retorna la función también será de tipo
“Integer” y así se ha declarado al final de la cabecera de la función con la expresión “As
Integer”.
Function CalcularSuma(ByVal operando1 As Integer, ByVal operando2 As Integer)

As Integer
'Return operando1 + operando2
CalcularSuma = operando1 + operando2
End Function

Dim Rtdo As Integer = CalcularSuma(4, 5)
10
Unidad
End Sub
El valor de retorno, que será la suma de los dos operandos, se realizará mediante las
expresiones:
“CalcularSuma = operando1 + operando2” o también “Return operando1 + operando2”
Cualquiera de ellas será válida.
Ejecutar el código en modo depuración y observar los valores de las variables en la ventana de
variables locales (fig.5).
Fig.5. Función CalcularSuma.
Pasos de parámetros
Mecanismo de paso Explicación Implicaciones Ventaja
Por valor El procedimiento Si el procedimiento Protege la variable de

Palabra clave: ByVal invocado recibe una invocado modifica la ser cambiada por el
copia de los datos copia, el valor original de procedimiento invocado.
cuando es invocado. la variable permanece
intacto. Cuando la
ejecución retorna al
procedimiento de
llamada, la variable
contiene el mismo valor
que tenía antes de que
el valor se pasara.
Por referencia El procedimiento El procedimiento El procedimiento
Palabra clave: ByRef invocado recibe una invocado puede invocado puede utilizar
referencia a los datos modificar la variable el argumento para
originales (la dirección directamente. Cuando la devolver un nuevo valor
de los datos en ejecución retorna al al código de llamada.
memoria) cuando es procedimiento de
invocado. llamada, la variable
contiene el valor
modificado.
11
¶
Si no se especifica nada, el editor de código añade la palabra “ByVal”, es decir, por defecto el
paso de parámetros se realiza “por valor”.
Estructuras de control
• Sentencia If
Tenemos varias sintaxis:
If Expresión Then Instrucción_Verdadero [Else Instrucción_Falso]
If Expresión Then
líneas de código
cuando Expresión es Verdadero
......
[Else]
líneas de código
cuando Expresión es Falso
......
End If
If ExpresiónA Then
líneas de código cuando ExpresiónA es Verdadero
.......
ElseIf ExpresiónB Then
líneas de código cuando ExpresiónB es Verdadero
.......
[ElseIf ExpresiónN Then]
líneas de código cuando ExpresiónN es Verdadero
.......
[Else]
líneas de código cuando ninguna expresión devuelve Verdadero
.......
End If
• Sentencia Select Case
Select Case Expresión

Case ListaExpresionesA
líneas de código si se cumple ListaExpresionesA
.....
[Case ListaExpresionesB]
líneas de código si se cumple ListaExpresionesB
.....
[Case Else]
líneas de código si no se cumple ninguna ListaExpresiones
.....
End Select
La lista de expresiones asociada a cada Case en esta estructura estará separada por comas y
podrá tener alguno de los siguientes formatos:
• Expresión.
• ExpresiónMenor To ExpresiónMayor
• Is OperadorComparación Expresión.
12
Unidad
Veamos un ejemplo:
Dim numero As Integer = 8

Select Case numero
Case 1 To 5
Me.TextBox1.Text = "Entre 1 y 5, inclusive"
Case 6, 7, 8
Case 9 To 10
Case Else
Me.TextBox1.Text = "No está entre 1 y 10"
End Select
Se pueden utilizar varias expresiones o intervalos en cada cláusula Case. Por ejemplo, la línea
siguiente es válida:
Case 1 To 4, 7 To 9, 11, 13, Is > maxNumber
• Sentencia Do…Loop
Las instrucciones “Do…Loop” proporcionan un modo para ejecutar un bloque de código

mientras una condición sea verdadera o hasta que lo sea.
Do [While | Until Expresión]

líneas de código
......
[Exit Do]
líneas de código
......
Loop [While | Until Expresión]
La condición se puede comprobar al principio, después del “Do”, o al final, después del “Loop”,
y con “While” o con “Until”.
También podemos utilizar la sentencia “Exit Do” para finalizar la ejecución de un bloque
“Do…Loop” en cualquier lugar de las líneas de código. Se puede emplear la sentecia “Exit Do”
tantas veces como sea necesario.
Veamos el proceso de sumar los números del 1 al 5 empleando un bloque “Do…Loop” con la
condición en distintos lugares.
• Con la condición al principio y con “While”
' Sumar los números del 1 al 5

Dim total As Integer
Do While numero <= 5
' acumulamos en total el valor de la variable numero
total += numero
' incrementamos en 1 la variable numero
numero += 1
Loop
' total será igual a 15
13
¶
• Con la condición al final y con “Until”

Do
total += numero
numero += 1
Loop Until numero > 5
• Con la condición entre las líneas de código y con “Exit Do”

Do
total += numero
If numero = 5 Then Exit Do
numero += 1
Loop
Vamos a ejecutar este último bloque “Do…Loop”. Para ello escribimos todo el código dentro de
un procedimiento “Clic” de un botón“. Una vez hecho, vamos a aprender a establecer un
“punto de interrupción” en nuestro código. Al establecer puntos de interrupción en las líneas de
código, cuando iniciemos la ejecución del proyecto con F5, ésta se detendrá cuando encuentre
un punto de interrupción, a partir de esa línea se podrá ejecutar el programa en modo
depuración, con F8, o retomar la ejecución normal, con F5.
Vamos a establecer un punto de interrupción al comienzo del bloque “Do…Loop”. Situamos el
cursor en la línea donde se encuentra la sentencia “Do” y pulsamos la tecla F9 (o vamos a la

opción del menú Depurar + Alternar puntos de interrupción). Aparecerá esa línea resaltada en
rojo (fig.6).
14
Unidad
Fig.6.Depuración bloque Do…Loop.
Si iniciamos la ejecución con F5, nos aparecerá el formulario, y al hacer clic en el botón
“Button1”, la ejecución del código se detendrá en la línea donde tenemos el punto de
interrupción, esto es, donde comienza el bloque “Do…Loop”. Ahora vamos ejecutando, con F8,
el código línea a línea y observamos los valores que van tomando las variables locales
“numero” y “total”; así como el momento en que se cumple la condición y se ejecuta la
sentencia “Exit Do”.
Lógicamente se pueden establecer los puntos de interrupción que se quiera. También se

pueden establecer puntos de interrupción en las líneas de código haciendo clic en la columna
de la izquierda que contiene los círculos rojos que identifican la existencia de un punto de
interrupción (fig.7).
Fig.7.Establecer puntos de interrupción.
Para eliminar un punto de interrupción hacemos clic sobre el círculo rojo o pulsamos F9 con el
cursor sobre la línea de código.
15
¶
• Sentencia For…Next
Podemos utilizar un bucle “For…Next” cuando conocemos el número de veces que es

necesario que se ejecute un bloque de código. Una instrucción “For…Next” repite un conjunto
de instrucciones un número específico de veces.
For Contador = Inicio To Fin [Step Incremento]

líneas de código
......
[Exit For]
líneas de código
......
Next
“Contador” se inicializa con el valor de “Inicio” y el código existente entre For y Next es
ejecutado hasta que el valor de “Contador” sea igual a “Fin”.
Por defecto, los incrementos de Contador son en uno, pero podemos cambiar este aspecto
utilizando el modificador “Step”, mediante el que podemos establecer el número en el que se
van a realizar los incrementos. “Step” también nos permite realizar decremento utilizando un
número negativo.
El ejemplo anterior de obtener la suma de los números del 1 al 5 sería con un bloque
“For…Next”.

Dim i As Integer ' Contador
For i = 1 To 5
total += i
Next
También podemos declarar la variable que hace de contador (variable “i”) en la misma
declaración “For”.

For i As Integer = 1 To 5
total += i
Next
Si queremos realizar una salida de la ejecución de esta estructura antes de haber completado
el número de iteraciones establecidas, podemos utilizar la instrucción Exit For, que provocará
dicha salida de igual modo que el explicado anteriormente en la estructura Do...Loop.
• Sentencia For Each…Next
Una instrucción “For Each…Next” ejecuta un bloque de instrucciones para cada elemento de
un array o una colección (más adelante veremos este concepto).
For Each Elemento In Array/Colección

líneas de código
......
[Exit For]
líneas de código
......
Next
16
Unidad
Veamos el ejemplo anterior, pero almacenando los números en un array, y recorriéndolo con
un bloque “For Each…Next”.
'Sumar los números del 1 al 5

'almacenados en el array numeros()
Dim numeros() As Integer = {1, 2, 3, 4, 5}
For Each i As Integer In numeros
total += i
Next
Controles más comunes. TextBox, Button y Label
Vamos a desarrollar un ejercicio para comprender la utilización de estos controles básicos.

Creamos un nuevo proyecto y le asignamos el nombre “01.DatosAlumnos”.
Al formulario de inicio “Form1” vamos a cambiarle el nombre para identificarlo mejor, y también
la leyenda que aparece en el cuadro azul superior, que también contiene el literal “Form1”.
Para ello vamos al “Cuadro de Propiedades” y en la propiedad “Name” le asignamos el valor
“frmInicio”. Las tres primeras letras “frm” se emplean para identificarlo como un “objeto de la
clase Form (formulario)”. Y en la propiedad “Text” escribimos “Datos Alumnos” (fig.7).
Fig.8. Cuadro de propiedades. Modificar propiedad Name y Text del formulario.
17
¶
Como se puede ver, el nombre del formulario se actualizó en la lista desplegable de la parte
superior del “cuadro de herramientas”, su nuevo nombre es “frmInicio”. Y también se actualizó
la leyenda del formulario del cuadro azul superior, ahora aparece el literal “Datos Alumnos”
Nota: Siempre que se vaya a modificar una propiedad hay que fijarse en la lista desplegable
superior del cuadro de herramientas para cerciorarse de que se están editando las propiedades
del objeto que deseamos modificar. Esto es muchas veces causa de equivocaciones.
Vamos a añadir otro formulario a nuestro proyecto. Para ello tendremos que conocer otra
ventana del entorno de desarrollo del VB, el “Explorador de soluciones”, accedemos a él
situándonos en la pestaña lateral de la parte derecha o en el icono del menú señalado en la
siguiente figura:
Fig.9. Acceder al Explorador de soluciones.
El explorador de soluciones nos muestra los elementos que contiene nuestro proyecto:
formularios, módulos, clases, etc. (fig.10).
Fig.10. Explorador de soluciones.
Vamos a añadir los dos elementos señalados en la figura 10, el formulario “frmVerDatos.vb” y
el módulo “datos.vb”. Para añadir un nuevo formulario a nuestro proyecto vamos a la opción del
menú “Proyecto + Agregar Windows Forms” y nos aparece una ventana donde está
18
Unidad
seleccionada la plantilla “Windows Forms”, le cambiamos el nombre genérico “Form1.vb” por

“frmVerDatos.vb”.
Ahora vamos a añadir un “módulo”, que no es más que un fichero con la extensión “vb” que
puede contener cualquier tipo de código Visual Basic. Generalmente se utilizan para declarar
métodos o variables que no están directamente relacionadas con los formularios del proyecto,
es decir, son independientes al código de éstos.
Un formulario también tiene la extensión “vb”, puesto que contiene código en visual Basic, pero,
a diferencia del módulo, tiene una vista de componentes con representación gráfica (vista
diseño).
Para agregar un módulo, tenemos la opción del menú “Proyecto + Agregar módulo” y le damos
el nombre “datos.vb”.
Ya tenemos completo la vista del “Explorador de soluciones” de la figura 10. Sólo nos queda
comentar la entrada “My Project” que, al hacer doble clic en ella, nos muestra una ventana con
las “propiedades del proyecto”, que ya veremos algunas de ellas cuando necesitemos
modificarlas.
Vamos a comenzar el diseño del formulario “frmInicio”. Los controles que necesitamos para
este formulario son TextBox, Button y Label. (fig.11).
Fig.11. Controles para el formulario “frmInicio”.
El formulario “frmInicio” tendrá el siguiente aspecto en su diseño de controles (fig.12):
19
¶
Fig.12. formulario frmInicio.
En el siguiente cuadro representamos los valores que recibirán las propiedades de los distintos
controles dibujados en el formulario:
Tipo de Control Propiedad: Name Propiedad: Text

Label Label1 Datos Alumnos
Label Label2 Nombre:
Label Label3 Apellidos:
Label Label4 Curso:
Label Label5 Nº Alumnos:
Label lblNalum lblNalum

Button btnAceptar Aceptar
Button btnVerDatos Ver Datos
TextBox txtNombre
TextBox txtApellido
TextBox txtCurso
Las etiquetas que no se van a utilizar en el código del formulario no es necesario que
cambiemos el nombre que se le asigna por defecto (label1, label2, label3….). Sin embargo la
etiqueta “lblNalum” le asignamos otro nombre, ya que va a contener el número de alumnos que
hemos introducido en un momento dado, por lo que durante el proceso irá variando su
contenido.
Como se puede observar, a los objetos los nombramos con tres letras al principio de su
nombre para identificar el tipo de objeto que es. Vamos a adoptar el siguiente criterio:
Control Prefijo
Label lbl
Button btn
TextBox txt
La etiqueta “Label1” que contiene el literal “Datos Alumnos” tiene un tamaño de letra mayor que
el resto de las etiquetas. Para ello modificamos la propiedad “Font” de dicha etiqueta (fig.13). Al
20
Unidad
seleccionar esta propiedad, nos aparece un pequeño botón a la derecha; al hacer clic en él
surge un cuadro donde podremos modificar la fuente del texto de “Label1”.
Fig.13. Propiedad Font de Label1
Seleccionemos en dicho cuadro el “estilo de fuente” a “negrita”, y el “tamaño” a 14. Y hagamos

clic en el botón “Aceptar”.
Ya concluido el diseño del formulario, podemos observar en la lista desplegable de la parte

superior del cuadro de propiedades, todos los controles que contiene el formulario con su
nombre y la clase a la que pertenecen (fig14).
Fig.14. Lista desplegable del cuadro de propiedades del formulario “frmInicio”
Comencemos con la codificación del ejercicio. Vamos primero a introducir el código en el

módulo “datos.vb”. En el explorador de soluciones hacemos doble clic en el elemento
“datos.vb” y nos aparecerá una pestaña donde introduciremos el código que contendrá este
módulo. Escribimos las siguientes líneas de código dentro del bloque “Module datos . . .
End Module”:
Module datos
Structure Alumno
Dim nombre As String
Dim apellido As String
Dim curso As String
21
¶
End Structure
Friend aAlumno() As Alumno

Friend nAlumno As Short
End Module
Examinemos estas líneas de código. Primeramente declaramos una “estructura”, que consiste
en la agupación de un conjunto de datos para formar un dato compuesto. Esta es una
definición sencilla de una estructura, pero para este ejercicio nos basta. A la estructura le
hemos dado el nombre “Alumno”, ya que contendrá información de un alumno: su nombre,
apellido y el curso en el que está matriculado. Declaramos tres variables para recoger esa
información.
A continuación declaramos el array “aAlumno”, que será del tipo de la estructura que acabamos
de crear (“As Alumno”). Por lo que cada posición del array “alumno” almacenará un valor
“nombre”, un valor “apellido” y un valor “curso”. Para acceder a estos valores tendremos que
escribir:
aAlumno(i).nombre
aAlumno(i).apellido
aAlumno(i).curso
Este array tiene un “nivel de acceso” distinto del utilizado hasta ahora. La declaración del array
viene encabezada por la palabra “Friend” en vez de “Dim”. Si empleásemos esta última, el
array sólo sería accesible en el módulo donde lo hemos declarado, esto es en “datos.vb”. Pero
con un nivel de acceso “Friend”, conseguimos poder utilizar el array en el código de todos los
ficheros con extensión “vb” que tenemos en el proyecto, esto es, podemos utilizarlo en el
código de los formularios del proyecto. El nivel de acceso “Public” también nos valdría.
También observamos que no hemos especificado ningún valor entre los paréntesis al declarar
el array “aAlumno”, esto es, que no determinamos el número de elementos que contendrá el
array. Ya que no sabemos el número de alumnos que vamos a almacenar en él,
redimensionaremos el array a medida que se vayan introduciendo nuevos alumnos.
Y por último, declaramos la variable “nAlumno”, también con nivel de acceso “Friend”, y de tipo
“Short” (entero de formato corto).
Ahora vamos a escribir el código del formulario “frmInicio”. Seleccionamos el formulario en el

explorador de soluciones y pulsamos F7. Ya estamos en la pestaña del código del formulario.
Vamos a codificar el primer procedimiento, “frmInicio_Load”. Para que el entorno de desarrollo
de VB nos escriba el bloque de este procedimiento, seleccionamos de la lista desplegable de la
parte superior izquierda de la ventana en la que nos encontramos la opción “(frmInicio
eventos)”, y de la lista desplegable de la derecha, el método “Load”, (fig. 15).
Fig.15. Procedimiento frmInicio_Load
22
Unidad
Este método se ejecuta antes de que se muestre el formulario por primera vez, es decir,
cuando se “carga” el formulario en memoria. En él escribimos un comentario y una única
sentencia:
' inicializar la etiqueta lblNalum

Me.lblNalum.Text = 0
Que inicializa el valor de la propiedad Text de la etiqueta “lblNalum” a cero. Está etiqueta nos
indicará el número de alumnos que tendremos ya recogidos en el array, por lo que inicialmente
valdrá cero.
Si ejecutamos el proyecto en modo depuración (pulsando F8, y ejecutando línea a línea) vemos
que antes de que se muestre el formulario se ejecuta este método y la etiqueta contendrá su
nuevo valor, cero.
Nota: La palabra “MyBase” hace referencia a la clase de donde heredó la clase en la que nos
encontramos (“frmInicio”). Todos los formularios heredan de la clase base “Form”, por lo tanto
Mybase hace referencia esa clase. Y con la expresión “MyBase.Load” se está invocando al
método Load de la clase Form, clase base del formulario “frmInicio”.
Sigamos con el código del formulario. La lógica del proceso parece sencilla: se escribirán
valores para los cuadros de texto txtNombre, txtApellidos y txtCurso, y después se hará clic en
el botón “Aceptar”, esto conllevará el guardar los datos en el array. Su proceso será:
1. Incrementamos la variable “nAlumno”, ya que recogerá en todo momento el

número de alumnos que tiene el array. Como inicialmente la variable tenía el valor
cero, ahora será 1.
2. Redimensionamos el array con el valor de la variable anterior, para crear la

posición 1 del array. Recordar que lo habíamos declarado sin especificar ningún
número de elementos. Además, lo redimensionamos con la palabra “Preserve”
para que conserve los valores que ya tiene almacenado el array. En este primer
caso nada conservará ya que es la primera posición la que estamos guardando.
3. Guardamos los contenidos de los cuadros de texto en el array. Recordamos que el

array es del tipo compuesto “Alumno”.
4. Actualizamos la etiqueta “lblNalum”.
5. Y por último borramos el contenido de los cuadros de texto para dejarlas

preparadas para los datos del nuevo alumno.
Luego buscamos el método “Click” del botón “btnAceptar” (en las listas desplegables
superiores) y escribiremos el código siguiente:
Private Sub btnAceptar_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnAceptar.Click
'Guardar datos alumno en el array

' incrementar nAlumno
nAlumno += 1
'redimensionamos el array aAlumno
ReDim Preserve aAlumno(nAlumno)
' guardar datos en el array
aAlumno(nAlumno).nombre = Me.txtNombre.Text
aAlumno(nAlumno).apellido = Me.txtApellido.Text
aAlumno(nAlumno).curso = Me.txtCurso.Text
' mostrar el nº de alumnos
23
¶
Me.lblNalum.Text = nAlumno
' borrar cajas de texto

Me.txtNombre.Text = Nothing
Me.txtApellido.Text = Nothing
Me.txtCurso.Text = Nothing
End Sub
Para ejecutar este proceso línea a línea (modo depuración) vamos a añadir un punto de
interrupción en el comienzo del método “btnAceptar.Click”, y ejecutamos el proyecto. Damos
valores para un nuevo alumno y pulsamos el botón “Aceptar”. La ejecución se detiene al
comienzo del procedimiento. Para ver los valores que van tomando la variable “nAlumno” y el
array “aAlumno”, vamos a llevarlos a una “ventana de Inspección”. La ventana “Variables
locales” no contendrá estas variables porque, recordemos, están declaradas en el módulo
“datos” no en el formulario.
Empecemos por la variable “nAlumno”, para llevarla a la “ventana inspección”, situamos el
cursor en la variable y vamos al menú, a la opción Depurar + Inspección rápida; nos muestra la
ventana de inspección rápida, hacemos clic en el botón “Agregar inspección” y ya tenemos la
variable en la “ventana inspección”. Hacemos el mismo proceso para el array.
Ahora vamos ejecutando línea a línea el procedimiento (F8) y vamos viendo como va
cambiando el contenido de la variable y el array en la ventana de inspección. Cuando
lleguemos al final del procedimiento, antes de ejecutar la sentencia “End Sub”, tendremos la
variable “nAlumno” con valor 1, y en la posición 1 del array los datos del alumno que hemos
introducido (fig. 16).
Nota: La posición 0 del array se creó al redimensionar el array con el valor 1, pero no la vamos
a utilizar en este ejercicio.
Fig.16. Ventana Inspección
Introducimos más alumnos y comprobamos como el proceso se ejecuta de acuerdo a la lógica

del ejercicio.
Ya tenemos el proceso principal del botón “btnAceptar” desarrollado, no obstante vamos a

incorporar más instrucciones a este proceso, por ejemplo, si queremos que el usuario
introduzca todos los datos de un alumno para no guardar información en blanco en el array,
podemos escribir las siguientes instrucciones al comienzo del procedimiento:
24
Unidad
' comprobar que esten todos los datos

If Me.txtNombre.Text = Nothing Or Me.txtApellido.Text = Nothing Or
Me.txtCurso.Text = Nothing Then
MessageBox.Show("Faltan datos", "Datos alumnos",
MessageBoxButtons.OK, MessageBoxIcon.Information)
Exit Sub
End If
Cómo podéis ver, comprobamos si alguno de los cuadros de texto tiene un valor vacío
(“Nothing”), en el caso de que alguno estuviese vacío, mostramos un mensaje mediante el
objeto “MessageBox”, y su método “Show”, avisando de este hecho, y ejecutamos la sentencia
“Exit Sub”, esta sentencia, como su nombre indica, provoca la conclusión de la ejecución del
procedimiento en el que estamos.
Luego el código del procedimiento “Click” del Botón “btnAceptar” quedaría:

' comprobar que esten todos los datos
If Me.txtNombre.Text = Nothing Or Me.txtApellido.Text = Nothing Or
Me.txtCurso.Text = Nothing Then
MessageBox.Show("Faltan datos", "Datos alumnos",
Exit Sub
End If
'Guardar datos alumno

' incrementar nAlumno
nAlumno += 1
'redimensionamos el array aAlumno
ReDim Preserve aAlumno(nAlumno)
' guardar datos en el array
aAlumno(nAlumno).nombre = Me.txtNombre.Text
aAlumno(nAlumno).apellido = Me.txtApellido.Text
aAlumno(nAlumno).curso = Me.txtCurso.Text
' mostrar el nº de alumnos

Me.lblNalum.Text = nAlumno
' borrar cajas de texto

Me.txtNombre.Text = Nothing
Me.txtApellido.Text = Nothing
Me.txtCurso.Text = Nothing
End Sub
Ahora veamos el código que contendrá el evento “Click” del botón “btnVerDatos”. Simplemente
queremos que al hacer clic en este botón, nos muestre el otro formulario que tenemos en
nuestro proyecto, “frmVerDatos”. Con la siguiente instrucción lo conseguiremos:
Private Sub btnVerDatos_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnVerDatos.Click
' mostrar formulario frmVerDatos
frmVerDatos.ShowDialog()
End Sub
Pero este formulario está sin ningún objeto. Vamos a la pestaña de diseño del formulario y
dibujamos sólo dos objetos en él, un “TextBox” y un “Button”.
25
¶
TextBox txtDatos
Button btnCerrar Cerrar
Ahora modificaremos dos propiedades del control “txtDatos”. La propiedad “Multiline” la

pondremos a valor “True” (por defecto está a false), con lo que conseguiremos que el cuadro
pueda contener más de una línea de texto; ahora ya podemos modificar el tamaño del control
para ver las múltiples líneas de texto que contendrá.
Y la propiedad “Readonly”, también la cambiamos a valor “True”, con lo que el usuario no podrá
modificar el texto que mostremos en el cuadro; podría decirse que se comportaría como una
etiqueta.
El formulario quedaría:
Fig.17. Formulario frmVerDatos.

Nota: para cambiar el texto que aparece en el cuadro azul superior del formulario. Modificamos
el valor de la propiedad “Text” del formulario “frmVerDatos”.
Fig.18. Propiedad Text de frmVerDatos
El proceso consistirá en mostrar toda la información que tenemos almacenada en el array

“aAlumno” en el cuadro de texto “txtDatos” del formulario. Una línea por alumno.
26
Unidad
Utilizaremos también el evento “Load” del formulario, y en él introduciremos el siguiente código:
Public Class frmVerDatos

Private Sub frmVerDatos_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
' borrar el contenido de txtDatos
Me.txtDatos.Text = Nothing
' mostrar los datos del array aAlumno en txtDatos, uno alumno por
línea
For i As Short = 1 To aAlumno.GetUpperBound(0)
Me.txtDatos.AppendText(aAlumno(i).nombre & " - " &
aAlumno(i).apellido & " - " & aAlumno(i).curso & vbNewLine)
Next
End Sub
End Class
Veamos las novedades del código anterior:
• La expresión “aAlumno.GetUpperBound(0)” nos proporciona el número de elementos

que tiene el array “aAlumno” en su primera dimensión (dimensión 0), que en este caso
es la única. Esta información también nos la daría la variable “nAlumno”.
• Con la sentencia: Me.txtDatos.AppendText(aAlumno(i).nombre & " - " &

aAlumno(i).apellido & " - " & aAlumno(i).curso & vbNewLine).
Añadimos a “txtDatos” todos los datos de una posición del array (posición i) que
corresponde a un alumno, separados por un guión y al final provocamos un salto a la
siguiente línea con “vbNewLine”.
También podíamos haber escrito la siguiente secuencia:
Dim alum As Alumno

For Each alum In aAlumno
Me.txtDatos.AppendText(alum.nombre & " - " & alum.apellido & " - "
& alum.curso & vbNewLine)
Next
El inconveniente es que la posición 0 del array no la estamos utilizando y con esta secuencia si
se tendría en cuenta y aparecería una línea con dos guiones al principio.
Ya por último nos quedaría asignarle código al botón “btnCerrar”, simplemente vamos a “cerrar”
el formulario actual con la sentencia Me.Close().
Nota: Me hace referencia a la propia clase en la que estamos. En nuestro caso al formulario, el
método Close, provoca el cierre del formulario.
Lo usamos bastante al introducir el código ya que al escribir Me y a continuación añadir un
punto, nos muestra un desplegable con todas las propiedades del formulario y todos los
controles que hemos dibujado en el formulario, facilitándonos así la búsqueda de los
mismos.
También MyClass tiene esta misma utilidad.
El procedimiento quedaría:
Private Sub btnCerrar_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnCerrar.Click
' cerrar el formulario
Me.Close()
End Sub
27
¶
Ya hemos terminado el proyecto, vamos a ejecutarlo e introducir varios alumnos y vemos que
funciona tal y como habíamos pensado (fig.20).
Fig.20. Proyecto en ejecución.

28
3
Unidad
Creación y utilización de una

clase en Visual Basic.NET
MÓDULO

Unidad 3: CREACIÓN Y UTILIZACIÓN DE UNA CLASE EN VISUAL BASIC.NET

Permanente
ISBN: 978-84-692-3442-6
3 Creación y utilización de una
Unidad
En esta unidad se mostrarán las características del lenguaje Visual Basic .NET para crear una
clase, definiendo sus propiedades y métodos. Desarrollaremos un pequeño ejemplo en el que
crearemos y utilizaremos una clase.
CREAR UNA CLASE. PROPIEDADES Y MÉTODOS. ..................................................................... 4

PLANTEAMIENTO DEL EJERCICIO ................................................................................................ 7
Diseño ........................................................................................................................................ 7
Módulo de datos ......................................................................................................................... 8
Utilización de la clase. Aceptar y almacenar un objeto de la clase ........................................... 8
Método compartido y función InputBox...................................................................................... 9
Nuevo formulario. Formulario “frmVerEmpleados” .................................................................. 11
3
¶
Crear una clase. Propiedades y métodos.
Vamos a crear un nuevo proyecto donde realizaremos un ejemplo de creación de una clase y
utilización de la misma. Al nuevo proyecto le asignamos el nombre “02.ClaseEmpleado”.
Añadimos una clase a nuestro proyecto. Para ello vamos a las opciones del menú “Proyecto +
Agregar Clase…”, aparecerá un cuadro donde le asignaremos un nombre a la clase, el nombre
por defecto es “Class1.vb”, lo cambiaremos por “CEmpleado.vb”.
Al principio de la clase, y dentro del bloque “Public Class CEmpleado…End Class”, vamos a
declarar una serie de variables privadas o internas de la clase, que recogerán características
del empleado tales como: su nombre, categoría, sueldo, número de cuenta bancaria, y nombre
de la entidad bancaria:
Public Class CEmpleado

' variables privadas de la clase
Private csNombre As String ' nombre del empleado
Private csCategoria As String ' categoria
Private cdbSueldo As Double ' sueldo
Private csCuenta As String ' nº de cuenta bancaria
Private csEntidad As String ' nombre de la entidad bancaria
…..
…..
End Class
Nota: al asignarle el nombre a las variables, empleamos el criterio de anteponer al nombre la

letra “c” para identificarla como variable de clase y a continuación una o dos letras que nos
indican el tipo de variable que es; por ejemplo, una “s” para variables de tipo String, o las letras
“db” para variables de tipo Double.
Ahora vamos a desarrollar los métodos Property que se emplearan para asignar y obtener los
valores de las variables privadas que hemos declarado.
El primero será la propiedad Nombre que asignará y obtendrá el valor de la variable csNombre.
En su asignación, comprobaremos que el valor no sea un valor vacío.
Public Class CEmpleado

' variables privadas de la clase
…..
…..
' propiedad Nombre de la clase CEmpleado

Property Nombre() As String
Get
Return csNombre
End Get
Set(ByVal value As String)

If value.Equals("") Then
MessageBox.Show("Error, nombre vacío")
Else
csNombre = value
End If
End Set
End Property
End Class
El bloque Get simplemente devuelve el valor de la variable csNombre mediante la instrucción

“Return”. Y el bloque Set comprueba si el valor que se intenta asignar a la variable es un valor
4
Unidad
vacío con la expresión value.Equals(""), donde “value” es el valor que se desea asignar a
la variable csNombre.Si es así se muestra un mensaje y si no se le asigna dicho valor a la
variable. Observar que “value” es de tipo String y por lo tanto disponemos de las funciones de
la clase String, y una de ellas es la función Equals, que en este caso compara el contenido de
“value” con una cadena vacía (“”).
Para la variable csCategoria, sólo aceptaremos los valores “A, B o C”, como categorías válidas.
El método Property que escribiremos será el siguiente:
' propiedad Categoria de la clase CEmpleado

Public Property Categoria() As String
Get
Categoria = csCategoria
End Get
Set(ByVal value As String)

Select Case value.ToUpper
Case "A", "B", "C"
csCategoria = value.ToUpper
Case Else
MessageBox.Show("Categoria no válida, teclee A,B o C")
End Select
End Set
End Property
El valor de la variable cdbSueldo, tendrá relación con la categoría. Para un empleado con la
categoría A, sueldo tendrá que ser mayor o igual a 1000 y menor que 1500; para un empleado
de la categoría B, mayor o igual a 800 y menor que 1000; y para un empleado de la categoría
C, mayor o igual a 500 y menor que 800. Lógicamente primero tenemos que conocer la
categoría del empleado para poder asignarle un sueldo. El método Property que recogerá estas
condiciones será el siguiente:
' propiedad Sueldo de la clase CEmpleado

Public Property Sueldo() As Double
Get
Sueldo = cdbSueldo
End Get
Set(ByVal value As Double)
If Me.csCategoria Is Nothing Then
MessageBox.Show("Error, no tiene asignada la categoria")
ElseIf (Me.csCategoria = "C" And value >= 500 And value < 800) Or _
(Me.csCategoria = "B" And value >= 800 And value < 1000) Or _
(Me.csCategoria = "A" And value >= 1000 And value < 1500) Then
' sueldo correcto, según categoría
cdbSueldo = value
Else
' sueldo incorrecto, mostramos mensaje de error según la categoría
Select Case Me.csCategoria
Case "A"
MessageBox.Show("Error: categoria A, 1.000 € <= sueldo < 1.500 €")
Case "B"
MessageBox.Show("Error: categoria B, 800 € <= sueldo < 1.000 €")
Case "C"
MessageBox.Show("Error: categoria C, 500 € <= sueldo < 800 €")
End Select
End If
End Set
End Property
Nota: Si queremos escribir la extensa condición del ElseIf en varias líneas, debemos de separarlas con un
guión bajo, dejando un espacio en blanco antes de dicho guión. No obstante si queremos podemos
escribirla toda seguida, solamente es por una mejora visual.
5
¶
Vamos a crear una propiedad CtaBanco que utilizaremos para asignar valores a las variables
csCuenta y csEntidad. Será una propiedad de sólo escritura, por lo que no tendrá el bloque
Get. A la hora de escribir la cabecera del procedimiento Property, añadimos la palabra
WriteOnly, que la identifica como propiedad de sólo escritura.
En nuestro ejercicio adoptaremos el siguiente formato para las cuentas: 1111-123456. Los
cuatro primero números identificaran el banco al que pertenece la cuenta, y los seis siguientes
dígitos serán el número de la cuenta.
Desde el procedimiento Property CtaBanco, asignaremos un valor a la variable csEntidad, en

función de los cuatro primeros números introducidos. Escribimos algunos valores de ejemplo
para entidades ficticias.
' propiedad CuentaBancaria de la clase CEmpleado (sólo escritura)

Public WriteOnly Property CtaBanco() As String
Set(ByVal Value As String)
Select Case Value.Substring(0, 4)
Case 1111
csEntidad = "Caja Avilés"
Case 2222
csEntidad = "Banco Rico"
Case 3333
csEntidad = "Banco Pobre"
Case Else
csEntidad = "Banco Desconocido"
End Select
csCuenta = Value
End Set
End Property
Veamos que se obtiene con la expresión “Value.Substring(0, 4)”. Substring es una

función que los tipos de datos String tienen definida, y que nos permite obtener una subcadena
del contenido del dato String. Con los parámetros asignados, obtenemos los cuatro primeros
caracteres de su contenido: el 0 indica que comenzará a extraer los caracteres desde el
principio de la cadena, y el 4 el número de caracteres a extraer. Luego, con la expresión

anterior, se obtendrán los caracteres que identifican a la entidad bancaria.
Después de asignarle un valor a la propiedad csEntidad, almacenamos el valor introducido en

la variable csCuenta.
Y ya sólo añadiremos una propiedad más. La propiedad EntidadBanco será de sólo lectura,
esto es únicamente tendrá el bloque Get, y su misión será obtener el valor de la variable
csEntidad. En la cabecera del procedimiento escribiremos ReadOnly.
' propiedad EntidadBancaria de la clase CEmpleado (sólo lectura)

Public ReadOnly Property EntidadBanco() As String
Get
Return csEntidad
End Get
End Property
Cómo métodos de la clase, sólo vamos a declarar uno, y de carácter compartido (Shared).
Recordar que un método compartido de una clase se puede ejecutar sin necesidad de crear
instancias de esa clase. El método será el siguiente:
' método FinVacaciones de la clase CEmpleado

Public Shared Function FinVacaciones(ByVal fechaInicio As Date, ByVal Dias
As Integer) As Date
Return fechaInicio.AddDays(Dias).ToShortDateString
6
Unidad
End Function
El método FinVacaciones tiene dos parámetros, uno de tipo Date que recogerá la fecha de
inicio de las vacaciones y otro de tipo Integer, que recogerá el número de días de vacaciones, y
devolverá la fecha de finalización de las vacaciones; para ello sumará a la fecha de inicio,
primer parámetro, el número de días de vacaciones, segundo parámetro, empleando la función
AddDays de los tipos de datos Date, para realizar este cálculo. Con ToShortDateString,
conseguimos que nos devuelva la fecha resultante en un formato de fecha corto (dd/mm/aa).
Planteamiento del ejercicio
Diseño
Una vez definida la clase CEmpleado. Realizaremos el diseño del formulario de inicio de
nuestro proyecto (Form1.vb) y añadiremos los siguientes controles:

Label Label1 Nombre:
Label Label2 Categoria:
Label Label3 Sueldo:
Label Label4 Cta. Banco:
Label Label5 Banco:
Label Label6 Formato:1111-123456
Button btnVerDatos Ver Datos
TextBox txtNombre
TextBox txtCategoria
TextBox txtSueldo
MaskedTextBox mtxtCtaBanco Propiedad Mask : 0000-000000
Label lblBanco
Label Label7 Nº Empleado:
Label lblNEmp 0
Button btnAceptar Aceptar
El control MaskedTextBox, es un control similar a un TextBox, pero permite establecer una

máscara para facilitar la entrada correcta de los datos. En la propiedad Mask establecemos la
máscara “0000-000000”. En cada elemento 0 de la máscara se aceptará un dígito entre 0 y 9.
La disposición de los controles en el formulario podría ser la siguiente:
7
¶
Módulo de datos
Vamos a añadir a nuestro proyecto un módulo para datos, lo llamaremos “datos.vb”. En él

realizaremos las siguientes declaraciones:
Module datos
' declaramos un array que almacenará objetos de la clase CEmpleado
Public aEmpleado(0) As CEmpleado
' declaramos una variable que contendrá el número de empleados que se
vayan introduciendo en el array
Public nEmp As Short
End Module
Utilización de la clase. Aceptar y almacenar un objeto de la clase
Al hacer clic en el botón “Aceptar” del formulario crearemos un objeto o instancia de la clase
CEmpleado, que llamaremos oEmpleado. A continuación asignaremos los contenidos de los
distintos TextBox a las propiedades del objeto. Si alguna asignación no fuese correcta, la
propiedad contendrá un valor Nothing o cero, tal y como las definimos en la clase. En ese caso
llevaremos el cursor al TextBox correspondiente para que el usuario corrija el valor introducido.
Para realizar esta acción tenemos el método Focus, mediante la expresión
“NombreTextBox.Focus()”).
Y a continuación finalizamos la ejecución del procedimiento con “Exit Sub”.
Después de aceptados todos los valores para el objeto oEmpleado, tenemos que almacenarlo
en el array aEmpleado. Para ello y previamente, incrementamos la variable nEmp y
redimensionamos el array para añadir una posición más y almacenar en ella el objeto
oEmpleado. El código que realiza este proceso será el siguiente:

'declaramos un objeto o instancia de la clase CEmpleado
Dim oEmpleado As New CEmpleado
'asignar el contenido de txtNombre a la propiedad Nombre del objeto
oEmpleado.Nombre = Me.txtNombre.Text
If oEmpleado.Nombre = Nothing Then
8
Unidad
Me.txtNombre.Focus()
Exit Sub
End If
'asignar el contenido de txtCategoria a la propiedad Categoria

oEmpleado.Categoria = Me.txtCategoria.Text
If oEmpleado.Categoria = Nothing Then
Me.txtCategoria.Focus()
Exit Sub
End If
' asignar el contenido de txtSueldo a la propiedad Sueldo

oEmpleado.Sueldo = Me.txtSueldo.Text
If oEmpleado.Sueldo = 0 Then
Me.txtSueldo.Focus()
Exit Sub
End If
'asignar el contenido de mtxtCtaBanco a la propiedad CtaBanco

oEmpleado.CtaBanco = Me.mtxtCtaBanco.Text
'mostrar el nombre del banco en la etiqueta lblBanco
Me.lblBanco.Text = oEmpleado.EntidadBanco
' Almacenar el objeto Empleado en el array

' incrementar nEmp para determinar la posición del objeto
nEmp += 1
'redimensionamos el array aEmpleado
ReDim Preserve aEmpleado(nEmp)
' guardar el objeto oEmpleado en el array, en la nueva posición
aEmpleado(nEmp) = oEmpleado
' mostrar el número de empleados almacenados en la etiqueta lblNEmp

Me.lblNEmp.Text = nEmp
End Sub
Recomiendo que se ejecute el proyecto en modo depuración (F8), línea a línea; observando en
cada momento la secuencia de ejecución del programa y el valor que van tomando las
variables y demás estructuras de datos. Esto facilita mucho la compresión del código escrito,
así como su depuración si se produce algún error.
Método compartido y función InputBox
Teníamos definido un método compartido de la clase (FinVacaciones). Vamos a utilizarlo en

nuestro ejemplo. Para ello incorporaremos al formulario inicio (Form1.vb) dos controles, Button
y Label.
Tipo de Control Propiedad: Name Propiedad

Button btnFinVacaciones Text : Calcular Fin Vacaciones
Label lblFinVacaciones Autosize : false
La colocación de los controles en el formulario podría ser:
9
¶
Recordaremos que el método FinVacaciones tenía dos parámetros, la fecha de inicio de las
vacaciones y el número de días que durarían éstas. Dicho método sumaba los días a la fecha
de inicio y nos proporcionaba la fecha de final de vacaciones. Para obtener los dos parámetros
utilizaremos la función InputBox. Mediante esta función podremos solicitar un dato al usuario a
través de un cuadro de diálogo que se mostrará en pantalla. Su sintaxis es:
InputBox(Mensaje,Título,RespuestaDefecto,XPosicion,YPosicion)
•
Mensaje. Obligatorio. Un literal que nos indica lo que se desea obtener

• Título. Opcional. Literal que aparecerá en la barra de título del cuadro de diálogo.
• RespuestaDefecto. Opcional. Respuesta que se mostrará en el cuadro de diálogo,
pudiendo el usuario aceptarla o modificarla.
• XPosicion, YPosicion. Opcionales. las coordenadas en donde aparecerá el cuadro en
la pantalla. Si se omiten, se mostrará en el centro de la pantalla.
El evento clic del botón btnFinVacaciones quedaría:
Private Sub btnFechaVacaciones_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnFinVacaciones.Click
Dim finicio As Date = InputBox("Introduce una fecha de inicio", "Fecha
vacaciones", Now.Date)
Dim dias As Integer = InputBox("Introduce número de días", "Fecha
vacaciones" , 15)
Me.lblFinVacaciones.Text = CEmpleado.FinVacaciones(finicio, dias)
End Sub
El primer InputBox solicita la fecha de inicio de vacaciones. Como “respuesta por defecto” se
anotó la expresión Now.Date, que proporciona la fecha de hoy y que se mostrará en el cuadro
de diálogo pudiendo el usuario aceptarla o modificarla, si no es ésta la fecha deseada.
En el segundo InputBox se pide el número de días de las vacaciones, en el tercer parámetro

indicamos el valor 15, que el usuario puede modificar o aceptar.
10
Unidad
La última sentencia del código anterior, calcula el final de las vacaciones empleando el método
compartido de la clase CEmpleado, mostrando el resultado en la etiqueta lblFinVacaciones.
Nuevo formulario. Formulario “frmVerEmpleados”
Añadamos un nuevo formulario a el proyecto, en él vamos a mostrar los empleados que están
almacenados en el array hasta ese momento. Para añadir un nuevo formulario, vamos a las
opciones del menú Proyecto + Agregar Windows Forms, le llamaremos “frmVerEmpleados.vb”.
Contendrá sólo dos controles:

TextBox txtEmpleados Propiedad Multiline : true
Propiedad ScrollBars : vertical
Propiedad ReadOnly : true
Button btnCerrar Text : Cerrar
El TextBox txtEmpleados será de sólo lectura (ReadOnly = true), ya que sólo vamos a mostrar
unos datos, no se van a editar.
El formulario tendrá el siguiente aspecto:
El proceso será el siguiente: al cargar el formulario se recorre todo el array y se muestra en

txtEmpleados una línea con los datos de cada empleado almacenado en dicho array. El código
a incluir en el formulario será:
Public Class frmVerEmpleados

Inherits System.Windows.Forms.Form
Private Sub frmVerEmpleados_Load(ByVal sender As System.Object, ByVal e As

Me.txtEmpleados.Text = Nothing
For i As Short = 1 To aEmpleado.GetUpperBound(0)
Me.txtEmpleados.AppendText(aEmpleado(i).Nombre & " - " &
aEmpleado(i).Categoria & " - " & aEmpleado(i).Sueldo & " - " &
aEmpleado(i).EntidadBanco & vbNewLine)
Next
11
¶
End Sub
Private Sub btnCerrar_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnCerrar.Click
Me.Close()
End Sub
End Class
Tendremos que incorporar un botón al formulario inicial (Form1.vb) para que desde él
podamos invocar al nuevo formulario frmVerEmpleados:

Button btnVerEmpleados Text : Ver Empleados
Y el código sería:
Private Sub btnVerEmpleados_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnVerEmpleados.Click
frmVerEmpleados.ShowDialog()
End Sub
Con esto ya concluimos el ejercicio.

12
4
Unidad
Controles ListBox, MenuStrip,

ComboBox, RadioButton y
CheckBox
MÓDULO

Unidad 4: CONTROLES LISTBOX, MENUSTRIP, COMBOBOX, RADIOBUTTON Y

CHECKBOX

Permanente
ISBN: 978-84-692-3442-6
Unidad
4 ComboBox, RadioButton y
CheckBox
En esta unidad veremos una serie de ejercicios que nos mostraran el funcionamiento de cinco
controles típicos de los formularios Windows: ListBox, MenuStrip, ComboBox, RadioButton,
CheckBox.
CONTROL LISTBOX.......................................................................................................................... 4
CONTROL MENUSTRIP. ................................................................................................................. 10
CONTROL COMBOBOX.................................................................................................................. 20
CONTROL RADIOBUTTON............................................................................................................. 22
CONTROL CHECKBOX................................................................................................................... 24
3
¶
Control ListBox.
Un ListBox es un control que contiene una lista de elementos, de los cuales el usuario puede
hacer una selección de uno o varios elementos.
La propiedad Items recoge la lista de elementos que tiene un ListBox. Podemos acceder a ella
en el cuadro de propiedades y asignarle elementos a la lista en tiempo de diseño. También
proporciona métodos para añadir elementos a la lista en tiempo de ejecución.
Vamos a crear un nuevo proyecto con el nombre “05.ControlListBox”. Busquemos en el

cuadro de herramientas el control ListBox y lo dibujamos en el formulario (fig.1).
Fig.1. Listbox en el cuadro de herramientas.
Cambiemos en nombre al ListBox. Para ello accedemos al cuadro de propiedades y buscamos

la propiedad Name que contendrá el valor ListBox1, lo modificamos por “lstFuente”.
Vamos a añadir algunos elementos a la propiedad Items del ListBox. De nuevo, en el cuadro
de propiedades buscamos esta propiedad, y hacemos clic en el pequeño cuadro de la derecha.
Nos aparecerá una ventana donde podremos escribir los elementos que deseamos incorporar
al ListBox. Escribiremos una serie de nombres, uno en cada línea. Y hacemos clic en el botón
Aceptar (fig.2).
4
Unidad
CheckBox
Fig.2. Colección Items del ListBox.
Para ver más características de este control desarrollaremos más el proyecto. Además del
ListBox lstFuente, añadiremos los siguientes controles al formulario

Label label1 “Lista sin ordenar”
Label Label2 “Lista ordenada”
ListBox lstDestino
Button btnAñadirF “Añadir elemento”
Button btnAñadirD “Añadir elemento”
Button btnEliminarF “Eliminar elementos seleccionados”
Button btnEliminarD “Eliminar elementos seleccionados”
Button btnEliminarTodosF “Eliminar todos los elementos”
Button btnEliminarTodosD “Eliminar todos los elementos”
Button btnMoverTodoADestino “>>”
Button btnMoverADestino “>”
Button btnMoverAFuente “<”
Button btnMoverTodoAFuente “<<”
En la siguiente figura (fig.3) se puede ver la disposición de los controles en el formulario. En

color rojo están los nombres de los controles:
5
¶
Fig.3. Disposición de los controles en el formulario.
En el segundo ListBox que tenemos en el formulario, lstDestino, vamos a representar los

elementos ordenados. Para ello accederemos a la propiedad Sorted de lstDestino y
modificaremos su valor a True, por defecto es False.
Empezaremos a codificar el evento click de botón “btnAñadirF”. Este botón tendrá como
finalidad el añadir un nuevo elemento al ListBox lstFuente. El código podría ser el siguiente:
Private Sub btnAñadirF_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnAñadirF.Click
Dim dato As String
dato = InputBox("Introduce nuevo dato : ", "Lista Fuente")
If dato.Trim <> Nothing Then Me.lstFuente.Items.Add(dato.Trim)
End Sub
En él, primeramente declaramos una variable de tipo String, “dato”. Mediante la función
InputBox solicitamos el dato a añadir a lstFuente. Comprobamos que el valor introducido no es
una secuencia vacía y si no lo es, lo añadimos a la colección Items de lstFuente mediante la
función Add.
dato.Trim. La función Trim elimina los espacios en blanco al inicio y al final de “dato”, si los
hubiera.
Si ejecutamos el proyecto y hacemos clic en el botón que acabamos de codificar, observamos

que añade el elemento introducido al final de lista de elementos de lstFuente.
El código para el botón “btnAñadirD” será igual que el anterior pero añadiendo el elemento
introducido a lstDestino.
6
Unidad
CheckBox
Private Sub btnAñadirD_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnAñadirD.Click
Dim dato As String
dato = InputBox("Introduce nuevo dato : ", "Lista Fuente")
If dato.Trim <> Nothing Then Me.lstDestino.Items.Add(dato.Trim)
End Sub
El botón “btnEliminarF”, eliminará los elementos de la lista que estén seleccionados.
Por defecto, en un ListBox podemos seleccionar un elemento de cada vez, pero también es
posible seleccionar varios elementos de la lista. La propiedad SelectionMode con valor “One”
sólo nos permitirá seleccionar un elemento. Vamos a modificar su valor, a “MultiSimple”, con lo
que podremos seleccionar varios elementos, haciendo clic en cada uno de ellos (fig.4).
Fig.4. Disposición de los controles en el formulario.
El código para el botón “btnEliminarF” podría ser:
Private Sub btnEliminarF_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnEliminarF.Click
For i As Integer = 1 To Me.lstFuente.SelectedItems.Count
Me.lstFuente.Items.Remove(Me.lstFuente.SelectedItem)
Next
End Sub
Comentemos las nuevas referencias del código anterior. La colección “SelectedItems”

contiene los elementos de un ListBox que están seleccionados en un momento dado. La
expresión “SelectedItems.Count” nos proporciona el número de elementos de la colección
SelectedItems, o lo que es lo mismo, el número de elementos seleccionados. Utilizamos un
bucle For que va desde 1 hasta el número de elementos seleccionados
(“lstFuente.SelectedItems.Count”).
Dentro del bucle For sólo hay una sentencia. Dicha sentencia invoca al método “Remove” de la
colección “Items” del ListBox lstFuente, y como parámetro le pasamos el primer elemento
seleccionado, que lo proporciona la propiedad “SelectedItem” de lstFuente.
7
¶
Veámoslo con un ejemplo. Establezcamos un punto de interrupción en la instrucción de
comienzo del blucle For (fig.5).
Fig.5. Punto de interrupción en el bucle For.
Ejecutemos el proyecto y seleccionemos los elementos de lstFuente, “Luis”,”Tomás” y

“Ramón”. Como establecimos la propiedad SelectionMode a MultiSimple, para realizar la
selección de estos tres elementos haremos clic en cada uno de ellos. Después hagamos clic en
el botón “Eliminar elementos seleccionados” (fig.6).
Fig.6. Selección de elementos en lstFuente.
La ejecución del proyecto se detendrá en el punto de interrupción. Si situamos el cursor sobre

la expresión “Me.lstFuente.SelectedItems.Count”, aparecerá un cuadro con el valor que
devuelve, y este valor es 3, el número de elementos seleccionados actualmente en lstFuente
(fig.7).
Fig.7. Número de elementos seleccionados.
8
Unidad
CheckBox
Y si situamos el cursor sobre la expresión “Me.lstFuente.SelectedItem”, que es el argumento

que se le pasa al método Remove; en un cuadro se nos mostrará el primero elemento de los
seleccionados en lstFuente; en este caso será “Luis” (fig.8).
Fig.8. Primer elemento seleccionado.
Si ejecutamos “paso a paso” las instrucciones del bucle For, vemos que en la siguiente
ejecución del bucle, el número de elementos que devuelve Count es 2, y que ahora, el primer
elemento seleccionado es “Tomás”, ya que Luis fue eliminado de la lista de lstFuente y
lógicamente, también de la lista de elementos seleccionados. En la siguiente ejecución, Count
devuelve 1 y SelectedItem la cadena “Ramón”.
El código del botón “btnEliminarD” sería el mismo pero sobre el ListBox lstDestino.
Private Sub btnEliminarD_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnEliminarD.Click
For i As Short = 1 To CShort(Me.lstDestino.SelectedItems.Count)
Me.lstDestino.Items.Remove(Me.lstDestino.SelectedItem)
Next
End Sub
Los botones para “Eliminar todos los elementos” de la lista, tendrían el siguiente código:
Private Sub btnEliminarTodosF_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnEliminarTodosF.Click
Me.lstFuente.Items.Clear()
End Sub
Private Sub btnEliminarTodosD_Click(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles btnEliminarTodosD.Click
Me.lstDestino.Items.Clear()
End Sub
Simplemento “borrar” con el método Clear la colección Items de los ListBox lstFuente y
lstDestino.
Veamos ahora los métodos para mover elementos entre los dos ListBox. El botón
“btnMoverTodoADestino”, identificado con “>>”, llevará toda el contenido de lstFuente a
lstDestino, y eliminará el contenido de lstFuente. El código podría ser:
Private Sub btnMoverTodoADestino_Click(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles btnMoverTodoADestino.Click
Me.lstDestino.Items.AddRange(Me.lstFuente.Items)
Me.lstFuente.Items.Clear()
End Sub
Con la primera sentencia, añadimos con AddRange, un conjunto de elementos a lstDestino, el

conjunto de elementos es la colección Items de lstFuente. Y con la segunda sentencia,
eliminamos todos los elementos de lstFuente.
Para el botón “btnMoverTodoAFuente”, el procedimiento sería:
9
¶
Private Sub btnMoverTodoAFuente_Click(ByVal sender As System.Object, ByVal e
As System.EventArgs) Handles btnMoverTodoAFuente.Click
Me.lstFuente.Items.AddRange(Me.lstDestino.Items)
Me.lstDestino.Items.Clear()
End Sub
Añadimos a lstFuente todos los elementos de lstDestino, y eliminamos los elementos de

lstDestino.
Ejecutaremos la aplicación y probaremos los procedimientos escritos. Observemos que al

mover todos los elementos a lstDestino, estos se muestran ordenados, ya que establecimos la
propiedad Sorted a True.
El botón “btnMoverADestino”, llevará los elementos que han sido previamente seleccionados
de lstFuente a lstDestino. Eliminándolos de lstFuente. El código podría ser:
Private Sub btnMoverADestino_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnMoverADestino.Click
For i As Integer = 1 To Me.lstFuente.SelectedItems.Count
Me.lstDestino.Items.Add(Me.lstFuente.SelectedItem)
Me.lstFuente.Items.Remove(Me.lstFuente.SelectedItem)
Next
End Sub
Se compone de un bucle For que va desde 1 hasta el número de elementos seleccionados

(SelectedItems.Count). Dentro del bucle For se irán añadiendo, con la función Add, a la
colección Items de lstDestino los elementos que han sido seleccionados en lstFuente,
obteniéndolos con SelectedItem. Y eliminándolos de lstFuente con Remove.
Para el botón “btnMoverAFuente”, el procedimiento sería:
Private Sub btnMoverAFuente_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnMoverAFuente.Click
For i As Integer = 1 To Me.lstDestino.SelectedItems.Count
Me.lstFuente.Items.Add(Me.lstDestino.SelectedItem)
Me.lstDestino.Items.Remove(Me.lstDestino.SelectedItem)
Next
End Sub
Con estos procedimientos ya concluimos el ejercicio, donde pudimos comprobar la utilización y

algunas funcionalidades del control ListBox.
Control MenuStrip.
El control MenuStrip proporciona una estructura de opciones de menús para un formulario.

Desarrollaremos un ejercicio para explicar su uso. Creamos un nuevo proyecto
“06.ControlMenuStrip”. En el diseñador de formularios añadimos un control MenuStrip al
formulario principal seleccionándolo en el cuadro de herramientas. Está localizado dentro del
grupo “Menús y barra de herramientas” (fig.9).
10
Unidad
CheckBox
Fig.9. Control MenuStrip en el cuadro de herramientas.
Observamos que en la parte inferior del diseñador aparece una referencia del nuevo control del
formulario con el nombre “MenuStrip1” (fig.10).
Fig.10. Control MenuStrip.
En la parte superior del formulario ya podemos añadir las opciones del menú que necesitemos.
En el mismo literal “Escriba aquí”, vamos a escribir “Opciones-Lista”, que será el nombre de la
primera opción principal del menú. Debajo de éste escribiremos las opciones de menú “Añadir”,
11
¶
“Eliminar”, a continuación un separador, que conseguiremos con escribir un simple guión (“-“), y
por último la opción “Rellenar” (fig.11).
Fig.11. Menú Opciones.
Cada una de estas opciones de menú crea un control del tipo “ToolStripMenuItem” que se van
generando a medida que las vamos añadiendo en el editor de menú. Podemos ver estos
controles en la lista desplegable de la parte superior del cuadro de propiedades (fig.12).
Fig.12. Controles ToolStripMenuItem.
Vemos que, por ejemplo, con la opción “Añadir”, se crea un control cuya propiedad Name será
“AñadirToolStripMenuItem”. La propiedad Text será “Añadir”.
Vamos a incorporar al formulario un control ListBox. Le asignaremos el nombre “lstLista”.
Con las opciones del menú definidas, tendremos que introducir el código que se ejecutará al
seleccionar una de estas opciones. El evento que se produce cuando seleccionamos una
opción de menú es el evento “Click”. Empecemos por la opción “Rellenar”. Esta opción va a
rellenar el ListBox con letras mayúsculas generadas de forma aleatoria.
Private Sub RellenarToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles RellenarToolStripMenuItem.Click
' Rellenar el ListBox
Dim rnd As New Random
Me.lstLista.Items.Clear()
For i As Short = 1 To 100
' Generar letras entre A(65) y Z(90)
Me.lstLista.Items.Add(Chr(rnd.Next(65, 91)))
Next
End Sub
12
Unidad
CheckBox
Comentemos el código anterior. Definimos una variable de tipo Random, que llamamos “rnd”, y
la utilizaremos para generar números aleatorios. Borramos la lista, con el método Clear. A
continuación, mediante un bucle For, generaremos cien números aleatorios entre 65 y 90, ya
que entre estos dos valores están representadas las letras mayúsculas en el Código ASCII. La
función “Next”, que nos proporciona los objetos de la clase Random, tal como la hemos escrito,
generará números aleatorios mayores o iguales a 65 y menores a 91.
Mediante la función “Chr” obtenemos el carácter correspondiente al código ASCII obtenido de
forma aleatoria. Y ese carácter lo añadimos a la colección Items de lstLista con el método Add.
Ejecutamos el proyecto y seleccionamos la opción “Rellenar”. Comprobaremos que el ListBox

se rellenó con cien letras mayúsculas. Podemos asignar a las opciones del menú una “tecla de
acceso rápido”, que cuando se pulse se ejecutará el código igual que si se hubiese
seleccionado la opción en el menú. Vamos a añadir la tecla “F11” a la opción “Rellenar”. Para
ello tendremos que ir al cuadro de propiedades y localizar la propiedad “ShortcutKeys” del
control “RellenarToolStripMenuItem” y en el cuadro de diálogo que se nos muestra, seleccionar
la tecla elegida (fig.13).
Fig.13. Propiedad ShorcutKeys.
Ejecutamos el proyecto y pulsamos la tecla F11. El ListBox se rellenará también de letras

mayúsculas.
El código para la opción “Añadir” podría ser el siguiente.
Private Sub AñadirToolStripMenuItem_Click(ByVal sender As System.Object, ByVal

e As System.EventArgs) Handles AñadirToolStripMenuItem.Click
Dim letra As Char = InputBox("Introduce letra maýscula : ",
"Lista").ToUpper
If letra <> Nothing Then Me.lstLista.Items.Add(letra)
End Sub
Declaramos una varible de tipo Char, ya que solamente necesitamos almacenar un carácter.
Mediante la función InputBox solicitamos dicho carácter. La función “ToUpper”, al final del
13
¶
InputBox, convierte a mayúsculas el carácter introducido. Si el valor introducido es distinto de
“Nothing”, lo añadimos a lstLista.
La opción “Eliminar” tendría el código siguiente.
Private Sub EliminarToolStripMenuItem_Click_1(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles EliminarToolStripMenuItem.Click
Me.lstLista.Items.Remove(Me.lstLista.SelectedItem)
End Sub
Simplemente escribimos una sentencia que mediante el método Remove de la colección Items
del ListBox, elimina el elemento seleccionado de la lista. Si no se hubiera seleccionado ningún
elemento nada ocurriría.
Ya tenemos todas las opciones del menú principal “Opciones-lista” desarrolladas. Añadiremos
más opciones, como muestra la siguiente figura (fig.14).
Fig.14. Menú Buscar.
La opción del menú principal “Buscar”, tendrá dos opciones, “Buscar elemento” con tecla de
acceso rápido F8, y “Buscar siguiente”, con tecla de acceso rápido F9.
Las opciones de búsqueda de este nuevo menú se realizarán sobre el ListBox lstLista. Por lo
tanto tenemos que tener en cuenta que si la lista está vacía, las opciones de este menú
principal deberían aparecer desactivadas, ya que no hay elementos para realizar una
búsqueda. Para conseguir esto emplearemos el evento “DropDowOpening” de la opción
principal “Buscar”. Este evento se produce justamente antes de desplegarse el menú, esto es,
antes de mostrar las opciones que contiene. El código para el procedimiento que atiende este
evento podría ser:
Private Sub BuscarToolStripMenuItem_DropDownOpening(ByVal sender As Object,

ByVal e As System.EventArgs) Handles BuscarToolStripMenuItem.DropDownOpening
If Me.lstLista.Items.Count = 0 Then
Me.BuscarElementoToolStripMenuItem.Enabled = False
Me.BuscarSiguienteToolStripMenuItem.Enabled = False
Else
Me.BuscarElementoToolStripMenuItem.Enabled = True
End If
End Sub
Mediante una sentencia If, preguntamos si el número de elementos (Count) de la colección

Items de lstLista es cero, si esto es así desactivamos las opciones “BuscarElemento” y
“BuscarSiguiente” asignándole el valor False a la propiedad Enabled en ambas opciones. Si la
lista tuviese elementos activamos la opción “BuscarElemento”. La otra opción
“BuscarSiguiente” se activará más adelante, en otra parte del código, después de realizar una
primera búsqueda.
14
Unidad
CheckBox
También desactivaremos estas dos opciones en el procedimiento que se ejecuta cuando se

carga el formulario “Load”, ya que al ListBox no le añadimos ningún elemento en tiempo de
diseño y por lo tanto, la lista está vacía al iniciarse la ejecución del proyecto.
Private Sub Form1_Load (ByVal sender As System.Object, ByVal e As

Me.BuscarElementoToolStripMenuItem.Enabled = False
End Sub
Para codificar las opciones nuevas del menú, necesitaremos añadir al formulario los siguientes
controles:

Label label1 “Letra a buscar:”
Label lblLetra
ListBox lstPosiciones
Modificamos, del control lblLetra, las propiedades BorderStyle a FixedSingle, y AutoSize a

False.
La disposición de los controles en el formulario podría ser la siguiente (fig.15).
Fig.15. Controles en el formulario.
Codificaremos ahora la opción “Buscar elemento”. El código podría ser el siguiente.
Dim LetraBuscar As Char, Posicion, PrimeraPosicion As Short
15
¶
Private Sub BuscarElementoToolStripMenuItem_Click(ByVal sender As
System.Object, ByVal e As System.EventArgs) Handles
BuscarElementoToolStripMenuItem.Click
LetraBuscar = InputBox("Letra a buscar : ", "Buscar en lista")
If LetraBuscar = Nothing Then Exit Sub
Me.lblLetra.Text = Char.ToUpper(LetraBuscar)
Me.lstPosiciones.Items.Clear()
Posicion = Me.lstLista.FindStringExact(LetraBuscar)
If Posicion <> -1 Then
Me.lstPosiciones.Items.Add(Posicion)
Me.lstLista.TopIndex = Posicion
Me.lstLista.SelectedIndex = Posicion
Me.BuscarSiguienteToolStripMenuItem.Enabled = True
PrimeraPosicion = Posicion
Else
MessageBox.Show("La letra no está en la lista", " Buscar en lista
", MessageBoxButtons.OK, MessageBoxIcon.Error)
End If
End Sub
Primeramente declaramos tres variables fuera del procedimiento, ya que las utilizaremos en
otros procedimientos del proyecto. “LetraBuscar” es una variable de tipo Char que recogerá la
letra que estamos buscando en un momento dado, y por lo tanto necesitaremos conocerla
también en el procedimiento asociado al evento de la opción “Buscar siguiente”. Y lo mismo
ocurrirá con las variables de tipo Short “Posicion” y “PrimeraPosicion”. Las definimos como
variables a nivel de formulario, esto es, serán reconocidas en todos los procedimientos del
formulario.
Mediante la función InputBox se solicita el carácter a buscar. Si no se tecleo ningún carácter,

concluimos la ejecución del procedimiento (“Exit Sub”). Con la siguiente instrucción convertimos
a mayúscula la letra a buscar mediante la función ToUpper y la mostramos en la etiqueta
lblLetra. Después borramos la colección Items del ListBox lstPosiciones. Este ListBox recogerá
las posiciones en que aparece el carácter a buscar en el otro ListBox del formulario, lstLista.
Para buscar un elemento en un ListBox disponemos de la función “FindStringExact”, la cual

busca el primer elemento que coincide exactamente con la cadena especificada como
argumento y devuelve la posición de ese elemento en el ListBox. En el supuesto de que no
encontrase ninguna coincidencia, devuelve el valor -1.
Siguiendo con el código, realizamos la búsqueda de la letra con la función descrita

anteriormente y recogemos el valor devuelto en la variable “Posicion”, variable del formulario.
Si se encontró coincidencia, esto es, si el valor devuelto es distinto de -1, añadimos a la
colección Items del ListBox lstPosiciones la posición de la primera aparición del carácter.
A continuación le asignamos a la propiedad “TopIndex” del ListBox el valor de “Posicion”, con

lo que se conseguirá que el primer elemento visible del ListBox sea el carácter hallado. Es decir
que la secuencia de letras representadas en lstLista se desplazará hasta esa posición, y el
elemento de esa posición se mostrará el primero en el ListBox.
Además, vamos “marcar” como seleccionado al elemento de esa posición, esto se consigue
asignando a la propiedad “SelectedIndex” del ListBox, el valor de “Posicion”
Después, ya que realizamos una primera búsqueda, activamos la opción “Buscar siguiente”, la
cual realizará una nueva búsqueda del carácter, pero a partir de la siguiente posición a la
primera aparición del carácter. Y por último, recogemos en la variable “PrimeraPosicion” el
valor de la variable “Posicion”, ya que necesitaremos conocer ese valor en otros
procedimientos que desarrollaremos a continuación.
16
Unidad
CheckBox
Si no se encuentra ninguna coincidencia del carácter buscado, mostramos un mensaje en

pantalla mediante un MessageBox.
Antes de probar el código escrito hasta ahora, añadiremos tres sentencias al final del
procedimiento “RellenarToolStripMenuItem_Click”. La finalidad de esas sentencias es “borrar”
el contenido de la etiqueta lblLetra y del ListBox lstPosiciones, y activar la opción “Buscar
elemento”. El código completo sería:
Private Sub RellenarToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles RellenarToolStripMenuItem.Click
' Rellenar el ListBox
Dim rnd As New Random
Me.lstLista.Items.Clear()
For i As Short = 1 To 100
' Generar letras entre A(65) y Z(90)
Me.lstLista.Items.Add(Chr(rnd.Next(65, 91)))
Next
Me.lblLetra.Text = Nothing
Me.lstPosiciones.Items.Clear()
Me.BuscarElementoToolStripMenuItem.Enabled = True
End Sub
Vamos a ejecutar el proyecto para probar el código escrito hasta ahora. Llenamos el ListBox
seleccionando la opción “Rellenar” o pulsando F11. Busquemos una letra seleccionando la
opción “Buscar elemento” o pulsando F8. Una vez introducida una letra y, si existe alguna
coincidencia en la lista, se situará esa letra como primer elemento visible del ListBox y además
aparecerá seleccionada. En lstPosiciones tendremos la posición del elemento en lstLista
(fig.16).
Fig.16. Primera búsqueda.
En la ejecución representada en la imagen, buscamos la letra “v”, y la primera aparición ha sido

en la posición 16.
17
¶
Hay que tener en cuenta que la posición primera en un ListBox es la posición 0, no la 1.
Vamos a desarrollar la opción de menú “Buscar siguiente”. Comencemos por escribir el

siguiente código:
Private Sub BuscarSiguienteToolStripMenuItem_Click(ByVal sender As

BuscarSiguienteToolStripMenuItem.Click
Posicion = Me.lstLista.FindStringExact(LetraBuscar, Posicion)
' si se encontró una nueva coincidencia
If Posicion <> -1 Then
End If
End Sub
En la primera sentencia volvemos a utilizar la función FindStringExact sobre el ListBox lstLista,

pero en este caso le pasamos dos parámatros, la letra a buscar y la posición de la anterior
coincidencia. La nueva búsqueda comienza en la siguiente posición. Por ejemplo, si en la
búsqueda de la letra “v” que anteriormente se realizó y cuya primera aparición fue en la
posición 16, al seleccionar la opción “Buscar siguiente”, esta primera sentencia realizará la
búsqueda desde la posición siguiente, es decir, desde la posición 17, ya que se le indica que la
primera aparición fue en la posición 16.
Las siguientes instrucciones son las mismas que escribimos en el código de la opción “Buscar
elemento”.
Si se encuentra una nueva coincidencia, esto es, si devuelve un valor distinto de -1, añadimos
a la colección Items del ListBox lstPosiciones la posición de la nueva aparición del carácter y
asignamos a las propiedades TopIndex y SelectedIndex del ListBox el valor de la nueva
posición.
Ahora debemos de preguntarnos cuál es el comportamiento de la función FindStringExact

cuando en su búsqueda se alcanza el final de la lista. Vamos a ejecutar el proyecto y buscar
una letra, y después, seguir buscando para intentar resolver nuestra duda (fig.17).
18
Unidad
CheckBox
Fig.17. Búsqueda cíclica.
Observamos que al alcanzar el final de la lista continúa la búsqueda comenzando en la primera

posición, es decir, realiza búsquedas cíclicas en las listas.
Resuelta nuestra duda, tendremos que modificar el procedimiento ya que cuando se vuelva a
repetir la primera aparición detectemos el fin de lista. El nuevo código para el procedimiento de
la opción “Buscar siguiente” podría ser:
Private Sub BuscarSiguienteToolStripMenuItem_Click(ByVal sender As

BuscarSiguienteToolStripMenuItem.Click
Posicion = Me.lstLista.FindStringExact(LetraBuscar, Posicion)
' comprobar si ya recorrió toda la lista
If Posicion = PrimeraPosicion Then
Me.lstPosiciones.Items.Add("Total : " & Me.lstPosiciones.Items.Count)
MessageBox.Show("Fin de lista", "ListBox", MessageBoxButtons.OK,
MessageBoxIcon.Information)
' si se encontró una nueva coincidencia
ElseIf Posicion <> -1 Then
End If
End Sub
Añadimos un bloque If donde comprobamos si la nueva coincidencia, recogida en la variable

“Posicion” es igual a la primera aparición, recogida en la variable “PrimeraPosicion” en un
procedimiento anterior. Si se cumple esta condición es que ya se dio una vuelta a la lista y por
lo tanto concluimos la búsqueda. Añadimos un mensaje con el número de veces que se repitió
la letra en el ListBox lstPosiciones, mostramos un mensaje avisando del “Fin de lista” y
desactivamos la opción “Buscar siguiente”.
19
¶
Para concluir el proyecto podemos incorporar la opción de menú “Cerrar” que con la sentencia
“Me.Close” con lo que se cierra el formulario.
Private Sub CerrarToolStripMenuItem_Click_1(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles CerrarToolStripMenuItem.Click
Me.Close()
End Sub
Control ComboBox.
Es un control de características similares a un ListBox. Presenta una lista desplegable de

elementos para que el usuario seleccione uno de ellos. Veamos un pequeño ejemplo de
utilización de un control ComboBox. Creamos un nuevo proyecto con el nombre
“07.ControlComboBox”.
Al formulario le añadimos los siguientes controles:
Tipo de Control Propiedad: Name Propiedades

Label label1 Text: “Seleccione ciudad :”
Label lblCiudad AutoSize:False; FixedSingle: BorderStyle
ComboBox cmbCiudades
Añadiremos también un control MenuStrip, con una sola opción de menú, “Añadir Ciudad”.
Fig.18. Formulario proyecto ControlComboBox.
Al ComboBox cmbCiudades vamos a añadir una serie de elementos en tiempo de diseño. Para
ello, al igual que un ListBox, tendremos que acceder a la propiedad Items del control en el
cuadro de propiedades y en el editor de la colección escribiremos los siguientes nombres de
ciudades: Oviedo, Gijón, Avilés y Mieres (fig.19).
20
Unidad
CheckBox
Fig.19. Colección Items del ComboBox
El proceso de este ejemplo es sencillo. Cuando el usuario seleccione una de la ciudades del
ComboBox cmbCiudades, la ciudad seleccionada se mostrará en lblCiudad. Al igual que en el
ListBox, el evento que se produce cuando se selecciona un elemento en un ComboBox es
“SelectedIndexChanged”. El código para este evento sería el siguiente.
Private Sub cmbCiudades_SelectedIndexChanged(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles cmbCiudades.SelectedIndexChanged
Me.lblCiudad.Text = Me.cmbCiudades.SelectedItem
End Sub
Como en el ListBox, la propiedad SelectedItem devuelve el elemento seleccionado, luego

asignamos ese valor a la propiedad Text de lblCiudad.
La opción de menú “Añadir ciudad” tendrá el siguiente código.
Private Sub AñadirCiudadToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles AñadirCiudadToolStripMenuItem.Click
Dim NuevaCiudad As String = InputBox("Introduzca nueva ciudad:", "Nueva
ciudad")
If NuevaCiudad.Trim <> Nothing Then
Me.cmbCiudades.Items.Add(NuevaCiudad.Trim)
End Sub
Declaramos una variable de tipo String “NuevaCiudad”. Mediante la función InputBox,

solicitamos un valor para esta variable. Y si el valor introducido es distinto de Nothing, la
añadimos a la lista de elementos de cmbCiudades. La función Trim, recordar que elimina los
espacios en blanco, tanto al principio como al final de una cadena.
Con este código ya concluimos el ejemplo. Una propiedad a destacar del ComboBox es
“DropDownStyle”. Las opciones que tiene esta propiedad modifican la apariencia y el
comportamiento del ComboBox. Ejecutar el ejemplo que hemos visto con los distintos valores
que puede tomar esta propiedad y fijaros en la funcionalidad y apariencia del control.
21
¶
Control RadioButton.
Este control permite ofrecer al usuario un conjunto de opciones para que escoja una de ellas.
Por lo tanto si tenemos varios botones en un formulario, sólo podemos tener una de ellas
seleccionada en un momento dado. Si queremos ofrecer varios conjuntos de opciones,
tendremos que agrupar cada conjunto de opciones en un control GroupBox, que es un control
contenedor de otros controles.
Fig.20. RadioButton y Groupbox.

Vamos a crear el proyecto de ejemplo que llamaremos “08.ControlRadioButton”. Y en su

formulario dibujaremos los siguientes controles:

Label lblSaludo Text: “Buenos Días”
GroupBox grbFuentes Text: “Fuentes”
RadioButton rbtSansSerif Text: “Microsoft Sans Serif”
RadioButton rbtCourierNew Text: “Courier New”
RadioButton rbtArial Text: “Arial”
GroupBox grbEstilos Text: “Estilos”
RadioButton rbtNormal Text: “Normal”
RadioButton rbtNegrita Text: “Negrita”
RadioButton rbtCursiva Text: “Cursiva”
La disposición de los controles en el formulario será la siguiente (fig.21).
22
Unidad
CheckBox
Fig.21. Formulario del proyecto.
El GroupBox grbFuentes contendrá a los RadioButton rbtSansSerif, rbtCourierNew y rbtArial. Y

el GroupBox grbEstilos contendrá a rbtNormal, rbtNegrita y rbtCursiva.
Vamos también a modificar la propiedad Checked de los RadioButton rbtSansSerif y

rbtNormal, cambiamos su valor a True. Esta propiedad tendrá valor True cuando el control
RadioButton está activado. Y al establecer su valor a True en tiempo de diseño se conseguirá
que al ejecutar el proyecto estas dos opciones ya estén activadas, como se ve en la figura
anterior.
La lógica del ejercicio consistirá en modificar la fuente y el estilo del texto “Buenos Días” que
muestra la etiqueta, seleccionando las alternativas que nos ofrecen los RadioButton del
formulario.
El evento que se produce cuando un RadioButton es seleccionado es “CheckedChanged”.

Como su nombre indica, este evento se produce cuando se modifica el valor de la
propiedad Checked; y los valores posibles de esta propiedad son True o False.
Veamos cual sería el código para el control rbtSansSerif:
Private Sub rbtSansSerif_CheckedChanged(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles rbtSansSerif.CheckedChanged
Me.lblSaludo.Font = New Font("Microsoft Sans Serif", 10)
End Sub
Modificamos la propiedad Font de la etiqueta lblSaludo. Le asignamos una nueva fuente,

“Microsoft Sans Serif”, y un nuevo tamaño de letra, 10.
Para los otros dos RadioButton escribiremos la misma sentencia, modificando el tipo de fuente.
El tamaño será el mismo para los tres.
Private Sub rbtCourierNew_CheckedChanged(ByVal sender As System.Object, ByVal

e As System.EventArgs) Handles rbtCourierNew.CheckedChanged
Me.lblSaludo.Font = New Font("Courier New", 10)
End Sub
23
¶
Private Sub rbtArial_CheckedChanged(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles rbtArial.CheckedChanged
Me.lblSaludo.Font = New Font("Arial", 10)
End Sub
Con los RadioButton de el GroupBox Estilos conseguiremos poner el texto de la etiqueta en

negrita o cursiva. El procedimiento del evento CheckedChanged para rbtNormal sería el
siguiente.
Private Sub rbtNormal_CheckedChanged(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles rbtNormal.CheckedChanged
Me.lblSaludo.Font = New Font(Me.lblSaludo.Font, FontStyle.Regular)
End Sub
En este caso la fuente no la modificamos, dejamos la que tendría la etiqueta lblSaludo,

recogida en su propiedad Font. Y le asignamos el estilo seleccionado mediante la enumeración
que nos proporciona el Visual Studio, FontStyle. También valdría si especificamos un 0 (cero),
en vez de la expresión “FontStyle.Regular”.
Para el estilo negrita escribiremos “FontStyle.Bold” o un 1 (uno). Y para cursiva,

“FontStyle.Italic” o un 2 (dos).
Private Sub rbtNegrita_CheckedChanged(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles rbtNegrita.CheckedChanged
Me.lblSaludo.Font = New Font(Me.lblSaludo.Font, FontStyle.Bold)
End Sub
Private Sub rbtCursiva_CheckedChanged(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles rbtCursiva.CheckedChanged
Me.lblSaludo.Font = New Font(Me.lblSaludo.Font, FontStyle.Italic)
End Sub
Control CheckBox.
Los controles CheckBox tienen una función similar a los RadioButton; permiten al usuario
elegir de un conjunto de opciones, pero, al contrario que los RadioButton, se pueden
seleccionar varias de estas opciones. Desarrollemos un ejercicio de ejemplo. Creamos un
nuevo proyecto, que llamaremos “09.ControlCheckBox”. Incorporaremos al proyecto los
siguientes controles:

Label Label1 Text: “Noticias de interés:”
CheckBox chkLiteratura Text: “Literatura”
CheckBox chkCiencias Text: “Ciencias”
CheckBox rbtDeportes Text: “Deporte”
CheckBox rbtViajes Text: “Viajes”
Button btnAceptar Text: “Aceptar”
24
Unidad
CheckBox
Fig.22. Formulario controles CheckBox.
Al igual que los controles RadioButton, los CheckBox tienen la propiedad Checked que toma el
valor True si está seleccionado y False si no lo está. También tienen el evento
“CheckedChanged”, que se produce cuando se modifica el valor de la propiedad Checked de
un control CheckBox.
La lógica del ejercicio es sencilla. El usuario seleccionará algunas de las noticias que le
interesan y hará clic en el botón. Mostraremos la selección que hizo mediante un MessageBox.
El código del botón podría ser el siguiente.

Dim Seleccion As String
If Me.chkViajes.Checked Then Seleccion = Me.chkViajes.Text & vbTab

If Me.chkLiteratura.Checked Then Seleccion &= Me.chkLiteratura.Text & vbTab
If Me.chkCiencias.Checked Then Seleccion &= Me.chkCiencias.Text & vbTab
If Me.chkDeporte.Checked Then Seleccion &= Me.chkDeporte.Text
If Seleccion = Nothing Then

MessageBox.Show("No hay selección", "Selección:", MessageBoxButtons.OK)
Else
MessageBox.Show(Seleccion, "Selección:", MessageBoxButtons.OK)
End If
End Sub
Creamos una variable de tipo String y la llamamos “Seleccion”. En ella vamos a guardar el tipo
de noticias que el usuario ha seleccionado. Vamos concatenando (“&=”) el valor de la
propiedad Text de los CheckBox si la propiedad Checked es True. La expresión “& vbTab” la
utilizamos para separar los tipos de noticias en la variable (carácter de tabulador).
Si el usuario realizó alguna selección, es decir si la variable es distinta de Nothing, mostramos

el contenido de dicha variable mediante un MessageBox (fig.23).
25
¶
Fig.23. Ejecución del proyecto.
Vamos a incorporar otra funcionalidad al ejemplo. Si el usuario selecciona la opción de

deportes, le advertimos que todas las noticias serán de futbol. El procedimiento a desarrollar
sería el siguiente.
Private Sub chkDeporte_CheckedChanged(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles chkDeporte.CheckedChanged
If Me.chkDeporte.Checked Then MessageBox.Show("¡SOLO HABLAMOS DE
FUTBOL!", "¡ADVERTENCIA!", MessageBoxButtons.OK, MessageBoxIcon.Stop)
End Sub
Cuando cambie el valor de la propiedad Checked, se produce el evento CheckedChanged. En

el procedimiento que atiende este evento mostramos el mensaje de advertencia si el valor que
va a tomar Checked es True, si el valor va a ser False no se muestra dicho mensaje.
26
5
Unidad
Métodos y funciones de los

arrays. La clase Random
MÓDULO

Unidad 5: MÉTODOS Y FUNCIONES DE LOS ARRAYS. LA CLASE RANDOM.

Permanente
ISBN: 978-84-692-3442-6
5 Métodos y funciones de los
Unidad
En esta unidad desarrollaremos un ejercicio que nos permitirá profundizar en los arrays,
utilizando algunos de sus métodos y funciones. También emplearemos la clase random que
nos proporciona el .Net.
PLANTEAMIENTO DE EJERCICIO................................................................................................... 4
Diseño ........................................................................................................................................ 4
Proceso del ejercicio. ................................................................................................................. 5
3
¶
Planteamiento de ejercicio
Vamos a crear un nuevo proyecto, asignándole el nombre “03.ClaseRandom”.
Diseño
En el formulario de inicio del proyecto (Form1.vb), añadiremos los siguientes controles:

Label Label1 “(máx. 40 elementos)”
Label lblVerArray (en blanco)
Label lblRepeticiones (en blanco)
Button btnGenerar “Generar array de…”
Button btnOrdenar Ordenar
Button btnRepeticiones “Repeticiones de…”
TextBox txtNelementos (en blanco)
TextBox txtNumero (en blanco)

4
Unidad
A las etiquetas le añadimos un borde (con la propiedad BorderStyle a valor FixedSingle) y

modificamos su tamaño (propiedad Autosize a false).
Vamos también a “desactivar” los botones btnOrdenar y btnRepeticiones, para ello asignamos
el valor False a propiedad Enabled de ambos botones. A lo largo del proceso iremos
activándolos.
Proceso del ejercicio.
El proceso del ejercicio consiste en introducir en txtNelementos el número de elementos que

vamos a generar con la clase Random (máximo 40). Los almacenamos en el array aNumeros,
y los mostramos en la etiqueta lblVerArray. Todo esto se lleva a cabo cuando hagamos clic en
el botón btnGenerar. El código que contendría el evento Click de este botón podría ser:
Private Sub btnGenerar_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnGenerar.Click
' validar número de elementos introducido
If Val(Me.txtNelementos.Text) < 1 Or Val(Me.txtNelementos.Text) > 40
Then
MessageBox.Show("Nº elementos incorrecto")
Me.txtNelementos.Focus()
Exit Sub
End If
' redimensionar el array con el número de elementos introducido

ReDim aNumeros(Val(Me.txtNelementos.Text))
' creamos un objeto de la clase Random
Dim rnd As New System.Random
' generamos los números aleatorios y los almacenamos en el array
For i As Short = 1 To aNumeros.GetUpperBound(0)
aNumeros(i) = rnd.Next(100)
Next
' visualizar el array en la etiqueta
VerArray()
' activar botón Ordenar
Me.btnOrdenar.Enabled = True
End Sub
Primeramente validamos el número de elementos introducido. Si este número no está

comprendido entre 1 y 40 mostramos un mensaje de error con MessageBox. A continuación
colocamos el cursor en la caja de texto txtNelementos con el método Focus y concluimos la
ejecución del procedimiento con Exit Sub.
La función Val convierte el valor de tipo string de la propiedad Text en un valor numérico
Si el valor introducido es correcto. Redimensionamos el array con ese valor para crear el
espacio justo para almacenar los números aleatorios. Declaramos un objeto de la clase
Random y mediante un bucle “for” generamos los números aleatorios. El bucle for se recorrerá
desde 1 hasta el número de elementos que tiene el array, y que nos lo proporciona el método
GetUpperBound.
Dentro de este bucle, utilizamos el objeto de la clase Random “rnd”. Esta clase contiene el
método Next, que pasándole el argumento 100 a dicho método, nos proporciona un valor
menor que 100 de forma aleatoria.
Buscar en la ayuda información sobre este método. Hacer la búsqueda con la expresión
Random.Next
5
¶
Para mostrar todos los números aleatorios almacenados en el array en la etiqueta vamos a
declarar un procedimiento “VerArray” que invocaremos en varias ocasiones a lo largo del
ejercicio, una de ellas será en este procedimiento; y por último activamos el botón btnOrdenar,
asignándole el valor true a la propiedad Enabled.
El procedimiento “VerArray” podría tener el siguiente código:
Sub VerArray()
Me.lblVerMatriz.Text = Nothing
Me.lblVerMatriz.Text &= i & " - " & aNumeros(i) & vbNewLine
Next
End Sub
Observamos en el código anterior que, primero borramos la etiqueta “lblVerMatriz” asignando el

valor Nothing a la propiedad Text. Después recorremos con un bucle for el array aNumeros.
Por cada número aleatorio, concatenamos o añadimos a la propiedad Text de la etiqueta (con
la expresión &=) la posición del número en el array (i), un guión y el número aleatorio; luego
realizamos un salto de línea (vbNewLine), para que el siguiente número aparezca en otra línea.
Ahora, en la etiqueta lblVerMatriz tendremos un listado de los números aleatorios generados

similar al siguiente para 25 elementos:
Veamos ahora el código que contendrá el botón btnOrdenar:
Private Sub btnOrdenar_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnOrdenar.Click
Array.Sort(aNumeros)
VerArray()
End Sub
6
Unidad
Es muy sencillo. Si investigamos en la ayuda, vemos que la clase Array tiene un método para
ordenar los elementos de un array, el método Sort. Para utilizar este método especificamos el
nombre de la clase, seguido del método Sort y como parámetro el array a ordenar. Y volvemos
a invocar el método VerArray para que nos muestre nuevamente los números aleatorios del
array en la etiqueta, pero esta vez ordenados.
Sólo nos queda asignarle código al botón btnRepeticiones. Este botón está desactivado, lo
activaremos cuando se teclee un número en txtNumero y lo volvemos a desactivar cuando
txtNumero este vacío. Para realizar este proceso vamos a utilizar el evento TextChanged. Este
evento se produce cuando cambia el contenido de la propiedad Text de un TextBox. El código
a introducir en dicho evento podría ser el siguiente:
Private Sub txtNumero_TextChanged(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles txtNumero.TextChanged
If Me.txtNumero.Text = Nothing Then
Me.btnRepeticiones.Enabled = False
Else
Me.btnRepeticiones.Enabled = True
End If
End Sub
El código es sencillo, mediante una sentencia if, comprobamos si el valor de la propiedad text
de txtNumero es Nothing, desactivando el botón si es así, y en caso contrario lo activamos.
En el TextBox txtNumero se tecleará el número aleatorio que queremos buscar en el array

aNumeros. Al hacer clic en el botón btnRepeticiones, en la etiqueta lblRepeticiones nos
aparecerá el número de veces que se repite dicho número aleatorio en el array.
7
¶
Para realizar este proceso vamos a crear una función, que llamaremos nRepeticiones, en ella
contaremos el número de veces que se repite el número a buscar en el array. Será de tipo
Short, ya que nos devuelve un valor entero. El código podría ser el siguiente:
Function nRepeticiones() As Short

If aNumeros(i) = Val(Me.txtNumero.Text) Then nRepeticiones += 1

Next
End Function
Y, por último, en el evento Click del botón btnRepeticiones formamos el literal que aparecerá
en la etiqueta lblRepeticiones e invocamos el método nRepeticiones anterior.
Private Sub btnRepeticiones_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnRepeticiones.Click
Me.lblRepeticiones.Text = "el número " & Me.txtNumero.Text & " se
repite " & nRepeticiones()
End Sub
8
6
Unidad
El parámetro “sender” y la
colección “Controls” de un
formulario
MÓDULO

Unidad 6: EL PARÁMETRO “SENDER” Y LA COLECCIÓN “CONTROLS” DE UN

FORMULARIO

Permanente
ISBN: 978-84-692-3442-6
Unidad
6 colección “Controls” de un
formulario
En esta unidad desarrollaremos un ejercicio en el que utilizaremos el parámetro “sender” de la

cabecera de los procedimientos que atienden a los eventos; y la colección “controls” de un
formulario.
Diseño ........................................................................................................................................ 4
Añadir un control en tiempo de ejecución .................................................................................. 7
3
¶
En este ejercicio veremos cómo podemos hacer para que:
• un procedimiento “atienda” o “maneje” eventos de varios controles. Para ello

utilizaremos el parámetro sender de la cabecera de los procedimientos que atienden a
los eventos.
• y como añadir un control al formulario en tiempo de ejecución, no en tiempo de diseño

como hasta ahora hemos hecho (colección Controls).
Crearemos un nuevo proyecto, asignándole el nombre “04.Porcentajes”.
Diseño
En el formulario de inicio del proyecto (Form1.vb) añadiremos los siguientes controles:

Label label1 “Cantidad:”
Label lblPorcentaje “%”
Label label3 “Total:”
Button btn7 “7%”
TextBox txtCantidad (en blanco)
TextBox txtPorcentaje (en blanco)
TextBox txtTotal (en blanco)

Como txtPorcentaje y txtTotal solamente las utilizaremos para mostrar datos, no para
introducirlos, vamos a modificar el valor de la propiedad ReadOnly de dichos controles,
estableciéndola a True, en tiempo de diseño.
4
Unidad
formulario
El proceso del ejercicio consiste en introducir una cantidad en txtCantidad, y el usuario hará clic
en algunos de los botones del formulario que representa porcentajes que se aplicarán a la
cantidad introducida. Calculado el porcentaje lo mostramos en txtPorcentaje y el total, que será
la suma de la cantidad más el porcentaje, en txtTotal. Por ejemplo, si introducimos la cantidad
1000 y el botón seleccionado es el del 16%, el porcentaje será 160 y el total 1160, como
vemos en la imagen siguiente.
Observemos también que al hacer clic en uno de los botones, la etiqueta del centro tendrá que
mostrarnos el porcentaje seleccionado, por lo que tendremos que modificar la propiedad Text
de dicha etiqueta en tiempo de ejecución, cada vez que seleccionemos un porcentaje.
Atendiendo a la lógica del ejercicio, nos damos cuenta que el proceso para los tres botones es
el mismo, lo único que varía es el valor del porcentaje a aplicar. Por lo tanto vamos a hacer que
un mismo procedimiento atienda o maneje el evento clic de los tres botones. Para conseguir
esto, la cabecera del procedimiento tendrá que ser la siguiente:
Private Sub btnPorcentaje_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btn7.Click, btn16.Click, btn33.Click
Para escribir esta cabecera, nos situamos en el primero de los botones y hacemos doble clic,
esto nos llevará a la ventana de código del evento click de ese botón; modificamos el nombre
del procedimiento dándole un nombre que no se identifique con un botón en concreto, por
ejemplo “btnPorcentaje_Click”; y añadimos, después de la cláusula Handles, la expresión
“botón.evento” de los botones restantes. Así conseguiremos que el procedimiento
btnPorcentaje se ejecute al hacer clic en alguno de los tres botones de porcentaje.
Ahora veamos el código que podemos incorporar a este procedimiento. Lo primero que vamos
hacer es validar los datos de entrada, es decir, si no tenemos ninguna cantidad introducida en
txtCantidad, vamos a mostrar un mensaje advirtiendo de esta circunstancia, llevamos el cursor
a txtCantidad con el método Focus, y finalizamos la ejecución del procedimiento (Exit Sub).
' validar datos de entrada

If Val(Me.txtCantidad.Text) = 0 Then
MessageBox.Show("Introduzca una cantidad")
Me.txtCantidad.Focus()
Exit Sub
End If
5
¶
A continuación tendremos que determinar el porcentaje a calcular. Dado que este
procedimiento atiende al evento clic de los tres botones, para saber cual botón ha provocado la
ejecución del procedimiento tendremos que consultar al primer parámetro del procedimiento,
sender (“ByVal sender As System.Object”). Como podemos observar es del tipo
Object y hace referencia al objeto o control que provocó la ejecución del procedimiento, en
nuestro caso, referenciará al botón seleccionado de los tres posibles botones que atiende el
procedimiento.
Con la siguiente expresión:
Dim btn As String = sender.Text
la variable btn recogerá el valor de la propiedad Text del botón seleccionado, esto es, si el
botón fue el del “16%”, este será el contenido de dicha variable.
Pero, realmente lo que nos interesa será el valor numérico de esa expresión, es decir,
necesitamos obtener solamente los dos primeros caracteres (“16”) y desechar el último (“%”).
Esto lo conseguimos con la función Val, que al convertir a valor numérico la expresión “16%”
solamente selecciona los dígitos numéricos, desechando el símbolo de porcentaje.
Dim tipo As Short = Val(btn)
Y ya, por último, sólo quedará realizar los cálculos para obtener el porcentaje y el total, y
también mostrar, en la etiqueta lblPorcentaje, el porcentaje seleccionado.
Me.txtPorcentaje.Text = Me.txtCantidad.Text * tipo / 100

Me.txtTotal.Text = Val(Me.txtCantidad.Text) + Val(Me.txtPorcentaje.Text)
Me.lblPorcentaje.Text = btn
Recopilando todo el código, el procedimiento quedaría:
Private Sub btnPorcentaje_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btn7.Click, btn16.Click, btn33.Click
' validar datos de entrada

If Val(Me.txtCantidad.Text) = 0 Then
MessageBox.Show("Introduzca una cantidad")
Me.txtCantidad.Focus()
Exit Sub
End If
Dim btn As String = sender.Text
' obtener el tipo de porcentaje a aplicar

Dim tipo As Short = Val(btn)
' calcular porcentaje y total
Me.txtPorcentaje.Text = Me.txtCantidad.Text * tipo / 100
Me.txtTotal.Text = Val(Me.txtCantidad.Text) + Val(Me.txtPorcentaje.Text)
' mostar porcentaje seleccionado en la etiqueta
Me.lblPorcentaje.Text = btn
End Sub
Sería muy conveniente ejecutar el procedimiento paso a paso, para ir viendo con más facilidad
la lógica del proceso y los valores que van tomando las variables en la ejecución de cada
sentencia.
6
Unidad
formulario
Añadir un control en tiempo de ejecución
Vamos a incorporarle otra funcionalidad a este ejercicio. Necesitamos que aparezca un botón
nuevo en el formulario, si la cantidad que se introduce es igual o superior a 10000. Este botón
calculará el porcentaje del 54%. Y si volvemos a modificar la cantidad a un valor inferior a
10000, ese nuevo botón tendrá que eliminarse del formulario.
Para realizar este proceso, codificaremos el evento TextChanged de txtCantidad que, como su
nombre indica, ocurre cuando la propiedad Text de un TextBox se modifica.
Dim boton54 As Boolean
Private Sub txtCantidad_TextChanged(ByVal sender As Object, ByVal e As

System.EventArgs) Handles txtCantidad.TextChanged
If Val(Me.txtCantidad.Text) >= 10000 And Not boton54 Then
' añadir el botón al formulario
…
En el código anterior, vemos que estamos codificando el evento TextChanged de txtCantidad.

Y que empleamos una variable de tipo Boolean “boton54”. Esta variable la utilizaremos para
saber si el nuevo botón ya está creado en el formulario, en ese caso tendrá un valor True. Si no
existe el nuevo botón en el formulario tendrá un valor False. Vamos a declararla fuera del
procedimiento, ya que si la declaramos dentro, cada vez que se ejecuta el procedimiento la
variable se inicializaría, y necesitamos conocer el valor que tomó en la anterior ejecución del
procedimiento. Es una variable a nivel de formulario.
Con esta variable ya podemos realizar la pregunta que en cada modificación de txtCantidad
debemos plantear. Esta pregunta es: “si la cantidad es igual o superior a 10000 y si no está el
botón54 en el formulario”. Ya que puede ocurrir que el valor anterior de txtCantidad ya fuese
igual o superior a 10000 y el botón54 ya estuviese creado en el formulario; en ese caso no
sería necesario crearlo.
Si ambas condiciones se cumplen, debemos añadir el botón54 al formulario.
Para añadir un nuevo control al formulario, primero debemos de declararlo.
Dim btn54 As New Button
Declaramos el nuevo objeto “btn54” del tipo Button. También lo declararemos fuera del
procedimiento, como la variable de tipo Boolean “boton54”.
¿Cómo podemos añadir un nuevo control al formulario?. Todos los controles que dibujamos en
un formulario se encuentran recogidos en una colección, la colección Controls. Si queremos
incorporar un nuevo control al formulario tendremos que añadir a esta colección el nuevo
control. Este se consigue mediante el método Add.

Me.Controls.Add(btn54)
Hemos creado un objeto de tipo Button y lo hemos añadido al formulario, ahora tendremos que
dar valores a las propiedades de ese nuevo control.
btn54.Text = "54%"
btn54.Size = New Size(62, 20)
btn54.Location = New Point(24, 156)
7
¶
Se asignó un valor a la propiedad Text (“54%”); un tamaño a la propiedad Size, que será el
mismo que tengan los otros botones; y una localización en el formulario. Para determinar la
localización del nuevo control en el formulario nos fijaremos en uno de los botones que ya
están en él, por ejemplo el del “33%”.
Observemos la siguiente imagen.
Vemos que la coordenada X del botón “33%” es 24, y es la distancia del botón al borde
izquierdo del formulario; al nuevo botón le asignaremos esa misma distancia. La coordenada Y
del botón “33%” es 112, y es la distancia del botón al borde superior del formulario; el nuevo
botón queremos que aparezca más debajo de éste, luego le asignaremos un valor mayor, por
ejemplo 156. Con estos valores, cuando aparezca el botón nuevo estará situado debajo del
botón “33%”.
Ya sólo resta escribir la sentencia que asocie el evento clic de este nuevo botón al
procedimiento “btnPorcentaje_Click”; tal y como ocurre con todos los botones de porcentaje de
este formulario.
AddHandler btn54.Click, AddressOf btnPorcentaje_Click
Con esta sentencia ya conseguimos que al hacer clic en el nuevo botón “btn54” se ejecute el
procedimiento “btnPorcentaje_Click”.
Recopilando el código escrito hasta ahora, tendremos:


8
Unidad
formulario

' definir propiedades del nuevo botón
btn54.Text = "54%"
'resolver el evento click del botón54 con el procedimiento

btnPorcentaje_Click
boton54 = True
…………….
La última línea del código anterior es para asignarle el valor True a la variable Boolean
boton54, ya que ahora el botón nuevo está en el formulario. Al estar declarada fuera del
procedimiento, en la siguiente ejecución del procedimiento tendrá valor True y sabremos que el
botón nuevo está presente en el formulario.
Ahora tendríamos que completar el código con las sentencias necesarias para eliminar el botón
btn54 cuando la cantidad sea inferior a 10000 y el nuevo botón esté en el formulario.
…………….
…………….
ElseIf Val(Me.txtCantidad.Text) < 10000 And boton54 Then
Me.Controls.Remove(btn54)
boton54 = False
…………….
Es sencillo, mediante ElseIf formamos la condición compuesta que pregunta si la cantidad es

inferior a 10000 y el botón54 está en el formulario (si es así, boton54 será True). Si se
cumplen ambas condiciones eliminamos (Remove) el botón54 de la colección Controls del
formulario, y asignamos a la variable boton54 el valor False, puesto que el botón btn54 ya no
está en el formulario.
Tenemos acabado este procedimiento:



' definir propiedades del nuevo botón
btn54.Text = "54%"
'resolver el evento click del botón54 con el procedimiento
btnPorcentaje_Click
boton54 = True
ElseIf Val(Me.txtCantidad.Text) < 10000 And boton54 Then
Me.Controls.Remove(btn54)
boton54 = False
End If
End Sub
9
¶
Si ejecutamos el ejercicio, podemos comprobar su funcionamiento. Para cantidades iguales o
superiores a 10000, aparece el nuevo botón. Y al hacer clic sobre él, calcula el porcentaje
asignado al botón, el 54%.
10
7
Unidad
El evento KeyPress. El parámetro

"e". La instrucción ”Try...Catch”.
La función “Format”
MÓDULO

Unidad 7: EL EVENTO KEYPRESS. EL PARÁMETRO "E". LA INSTRUCCIÓN

”TRY...CATCH”. LA FUNCIÓN “FORMAT”

Permanente
ISBN: 978-84-692-3442-6
Unidad
7 "e". La instrucción ”Try...Catch”.
En esta unidad desarrollaremos un sencillo ejercicio que nos permitirá conocer una serie de
conceptos importantes en el entorno del lenguaje que estamos utilizando:
• El evento KeyPress
• El parámetro “e”
• La instrucción “Try…Catch”
• Y la función “Format”
Diseño ........................................................................................................................................ 4
3
¶
En este ejercicio vamos a desarrollar un sencillo conversor de monedas.
Crearemos un nuevo proyecto, asignándole el nombre “04a.Conversor”.
Diseño
En el formulario de inicio del proyecto (Form1.vb) añadiremos los siguientes controles:

Label Label1 “Euros:”
Label Label2 “Dólares:”
TextBox txtEuros (en blanco)
TextBox txtDolares (en blanco)

El proceso del ejercicio consiste en introducir una cantidad de euros en txtEuros y al pulsar la
tecla “Enter” nos muestre en txtDolares el cambio en dólares. Y viceversa, si introducimos una
cantidad de dólares en txtDolares, al pulsar “Enter”, en txtEuros nos muestre el cambio en
euros.
Por lo tanto, lo primero que necesitaremos saber es cómo podemos detectar si el usuario pulsó
la tecla Enter. Para ello tendremos que utilizar el evento KeyPress de un TextBox. Este evento
tiene lugar al pulsar una tecla cuando estamos editando el contenido de un TextBox. Hagamos
doble clic en el TextBox txtEuros para ir a la ventana de código del formulario. Nos sitúa dentro
del evento TextChanged de txtEuros. Vamos a buscar en la lista desplegable de la parte
superior de la ventana, el evento KeyPress.
4
Unidad
La cabecera del evento es:
Private Sub txtEuros_KeyPress(ByVal sender As Object, ByVal e As

System.Windows.Forms.KeyPressEventArgs) Handles txtEuros.KeyPress
Fijémonos en el segundo parámetro del procedimiento. Es “e”, de la clase

“KeyPressEventArgs”, y nos va a indicar cuál ha sido la tecla pulsada en un momento dado.
Concretamente, la propiedad KeyChar de este parámetro nos facilitará dicha información.
e.KeyChar
El evento “txtEuros.KeyPress” se producirá siempre que pulsemos una tecla cualquiera cuando
estamos editando txtEuros. Por lo tanto tendremos que preguntar en cada pulsación, si la tecla
pulsada es la tecla Enter, ya que, en ese caso, se acabó la introducción de la cantidad en euros
y se realiza el cálculo del cambio a dólares.
If e.KeyChar = vbCr Then …
La constante “vbCr” hace referencia a la tecla Enter, o carácter “de retorno de carro” o
carácter “13”.
El parámetro “e” también tiene otra propiedad, “Handled”. Esta propiedad es de tipo Boolean, y
si, en un evento KeyPress de un Texbox, le asignamos un valor True, conseguimos que se
rechace el carácter pulsado y no se represente en el TextBox. Si el valor asignado es False,
el carácter sí aparecerá en el TextBox.
Con esta información vamos a emplear el evento KeyPress para realizar un proceso de
validación de los datos a introducir en txtEuros.
Solamente queremos que en txtEuros se acepten los números y la coma decimal. Vamos a
definir una función de tipo Boolean que reciba como parámetro un carácter y devuelva un valor
False si es un número o una coma, y valor True en caso contrario. Será así por la
funcionalidad de la propiedad Handled descrita. Ya que si el carácter pulsado no es un número
ni una coma, para rechazarlo, habrá que asignarle el valor True a la propiedad Handled.
Function ValidaCaracter(ByVal c As Char) As Boolean

' comprobar carácter pulsado
If Char.IsNumber(c) Or c = "," Then
5
¶
Return False
Else
Return True ' se rechaza el carácter pulsado
End If
End Function
El tipo de datos “Char”, tiene la función “IsNumber” de tipo Boolean que devuelve un valor
True si el carácter que le pasamos como parámetro es un carácter numérico, y False si no lo
es.
Por lo tanto el evento KeyPress tendrá, por ahora, las siguientes instrucciones.

If e.KeyChar = vbCr Then
' si pulsó Enter, realizamos la conversión
………
………
Else
' validar carácter tecleado
e.Handled = ValidaCaracter(e.KeyChar)
End If
End Sub
Si se pulsó la tecla Enter, hay que realizar la conversión, proceso que aún no hemos
desarrollado. Con cualquier otro carácter pulsado realizamos la validación a través de la
función “ValidaCaracter”. Se le pasa el carácter pulsado, “e.Keychar”, y en dicha función
comprobamos si el carácter es un número o una coma. Si no es un número o una coma
devuelve el valor True, que asignando este valor a la propiedad Handled del parámetro “e”, se
rechaza el carácter pulsado y no aparece en txtEuros.
Ejecutamos el proyecto y comprobamos que en txtEuros solamente podemos introducir

números o el carácter “,” para representar la coma decimal.
Podemos mejorar la función de validación que hemos creado, permitiendo también que se
acepte la pulsación de la tecla de retroceso para poder corregir los caracteres tecleados en
txtEuros si nos hemos equivocado en su introducción. Para ello añadimos una nueva condición
a la sentencia “if” de la función “ValidaCaracter”. Dicha función quedaría

If Char.IsNumber(c) Or c = "," Or c = vbBack Then
Return False
Else
End If
End Function
La constante vbBack referencia a la tecla que representa el “carácter de retroceso”.
Ejecutamos el proyecto y probamos si podemos modificar los caracteres introducidos

borrándolos con la tecla de retroceso.
Ahora tendremos que desarrollar la parte correspondiente al cálculo de la conversión de

moneda. Si se pulsó la tecla Enter, convertimos la cantidad en euros que tenemos en txtEuros
a dólares. El tipo de cambio que vamos a adoptar lo almacenaremos en una constante al
principio del formulario.
6
Unidad
Public Class Form1

' Establecemos un cambio de 1 euro = 1,4 dólares
Const Cambio = 1.4
……
Luego para realizar el cambio de euros a dólares multiplicaremos el contenido de txtEuros por
la constante “Cambio”.
El contenido de la propiedad Text de txtEuros es de tipo String, vamos a convertirlo a numérico
para realizar la operación anterior. En ejemplos anteriores utilizamos la función Val para esta
acción. Pero en este caso vamos a utilizar otra función de conversión que nos proporciona este
entorno de desarrollo. La función “CSng” convierte el argumento que se le pasa a un número
decimal de precisión simple.
¿Por qué no utilizamos la función Val? Veámoslo con un ejemplo. Si ejecutamos las siguientes
instrucciones:
Dim valor1 As Single = Val("1.4") ' devuelve 1.4

Dim valor2 As Single = Val("1,4") ' devuelve 1.0
Observaremos que en la primera sentencia el valor devuelto por la función Val es 1.4 y en la
segunda es 1.0. El motivo es que se está trabajando con la notación inglesa donde se utiliza el
punto decimal y no la coma. La función Val al encontrar una coma no sigue la conversión y no
tiene en cuenta el decimal para formar el número de tipo Single.
Sin embargo, en nuestro sistema operativo casi seguro que tenemos seleccionado en la
“Configuración Regional y de idiomas” el formato español, donde utilizamos la coma decimal.
La función CSng nos resuelve este problema. La sentencia siguiente:
Dim valor3 As Single = CSng("1,4") ' devuelve 1.4
En este caso sí convierte el número con su parte entera y decimal, devuelve el valor 1.4.
No obstante observaremos que convierte la coma decimal en un punto decimal. Y esto es
necesario porque internamente, el entorno de desarrollo que utilizamos, trabaja con la notación
inglesa.
Luego cuando llevemos el resultado a txtDolares veremos que el punto decimal se convierte en
coma decimal por la configuración que tenemos en nuestro sistema operativo.
Ya hemos visto los motivos que nos obligan a utilizar la función “CSng”. Sin embargo se nos
plantea otro problema. Cuando introducimos un valor que la función CSng no puede convertir a
tipo Single, la ejecución del programa se detiene y nos muestra un mensaje de error. Por
ejemplo, si ejecutamos la siguiente instrucción.
Dim valor4 As Single = CSng("1,,4") ' error
Como no puede convertir el String “1,,4” a un valor numérico porque se encuentra con dos
comas, se producirá un error de ejecución con el mensaje “La conversión de la cadena "1,,4"
en el tipo 'Single' no es válida”.
Para solucionar esto veamos, a modo de introducción, la instrucción ”Try...Catch”. Esta

importante instrucción nos ayudará a detectar los posibles errores que se produzcan en un
bloque de código mientras se ejecuta y realizar las acciones que sean oportunas. En nuestro
caso, si se produce el error en la función CSng, mostraremos un mensaje advirtiendo de la
incorrección del valor introducido y detenemos la ejecución del procedimiento. El código sería:
Dim valor As Single
7
¶
Try
Valor = CSng(Me.txtEuros.Text)
Catch ex As Exception
MessageBox.Show(ex.Message)
Exit Sub
End Try
Si se produce un error o “excepción” en la ejecución de la sentencia de conversión a tipo

Single del valor de la propiedad Text de txtEuros mediante la función CSng, se ejecutan las
instrucciones que están dentro en el bloque Catch…EndTry. La variable “ex” de la clase
“Exception” recogerá el error generado.
Mediante un MessageBox mostramos el contenido de la propiedad Message de la variable ex,
que nos mostrará el mensaje de error que se ha producido. Después detenemos la ejecución
del procedimiento (Exit Sub).
El nombre de variable “ex” es el que se le asigna por defecto, si queremos podemos cambiarlo.
La clase “Exception” contiene todos los errores que se pueden producir en la ejecución de una
aplicación.
Ya sólo nos queda calcular el cambio y mostrarlo en txtDolares. La siguiente sentencia nos
valdría.
Me.txtDolares.Text = valor * Cambio
Pero para evitar mostrar cambios con muchos decimales. Como el representado en la siguiente
imagen.
Vamos a utilizar la función “Format” para que solamente nos muestre dos decimales. La
sentencia sería.
Me.txtDolares.Text = Format(valor * Cambio, "#,##0.00")
Observar que en el formato que definimos ("#,##0.00") utilizamos la notación inglesa, el

punto decimal y la coma para separar las unidades de mil. Sin embargo, se convierte a la
notación nuestra al mostrarlo en txtDolares (coma decimal y unidades de mil separadas con
punto). Por ejemplo, si convertimos 980 euros, nos mostrará 1.372,00 dólares.
8
Unidad
Tanto el carácter “0” como el carácter “#” identifican una posición de un dígito. La diferencia es
que con el carácter “#”, si el valor de esa posición es cero, no representa nada en esa posición,
y con el carácter “0” si se muestra el cero.
Recopilando el código que hemos escrito hasta ahora sería el siguiente.
Public Class Form1
' Establecemos un cambio de 1 euro=1,4 dólares

Const Cambio = 1.4

Dim valor As Single
If e.KeyChar = vbCr Then
Try
valor = CSng(Me.txtEuros.Text)
Exit Sub
End Try
Me.txtDolares.Text = Format(valor * Cambio, "#,##0.00")
Else
End If
End Sub

If Char.IsNumber(c) Or c = "," Or c = vbBack Then
Return False
Else
End If
End Function
End Class
Para concluir el ejercicio, tendremos que programar el evento KeyPress de txtDolares para
que, al pulsar Enter, convierta la cantidad introducida en txtDolares a euros y los muestre en
txtEuros.
En este caso para realizar el cambio de dólares a euros dividiremos el contenido de txtDolares
por la constante “Cambio”. El código sería:
9
¶
Private Sub txtDolares_KeyPress(ByVal sender As Object, ByVal e As
System.Windows.Forms.KeyPressEventArgs) Handles txtDolares.KeyPress
Dim valor As Single
If e.KeyChar = vbCr Then 'c = ControlChars.Cr
Try
valor = CSng(Me.txtDolares.Text)
Exit Sub
End Try
Me.txtEuros.Text = Format(valor / Cambio, "#,##0.00")
Else
End If
End Sub
Por supuesto que también validamos la entrada de caracteres para que solamente se acepten
los números y la coma decimal, empleando la función “ValidaCaracter”.
10
8
Unidad
Editor. Control RichTextBox.

Cuadros de diálogos: controles SaveFileDialog,
OpenFileDialog, FontDialog y ColorDialog
MÓDULO

Unidad 8: EDITOR. CONTROL RICHTEXTBOX. CUADROS DE DIÁLOGOS:

CONTROLES SAVEFILEDIALOG, OPENFILEDIALOG, FONTDIALOG Y
COLORDIALOG

Permanente
ISBN: 978-84-692-3442-6
Unidad
8 Cuadros de diálogos
En esta unidad desarrollaremos un sencillo “editor de texto”. Para ello utilizaremos el control
RichTextBox, de similares características a un TextBox pero con mayores posibilidades. Y
también empleamos los controles de diálogos SaveFileDialog, OpenFileDialog, FontDialog y
ColorDialog.
Diseño ........................................................................................................................................ 4
3
¶
Vamos a desarrollar un pequeño editor. Para ello, crearemos un nuevo proyecto, con el nombre
“11.Editor”.
Diseño
Al formulario principal, vamos a añadir un control MenuStrip, para incorporarle una serie de
opciones de menú al formulario. Y un control de similares características a un cuadro de texto
TextBox, pero con más funcionalidades, “RichTextBox”.
Queremos que el control RichTextBox, ocupe todo el formulario, para ello vamos a su
propiedad “Dock”, y seleccionamos el rectángulo central que nos muestra al desplegar sus
posibles opciones. El valor que toma esta propiedad al hacer esa selección es “Fill”.
4
Unidad
Le cambiaremos el nombre al control RichTextBox, vamos a llamarle, “rtxtEditor”.
Ahora vayamos asignándole opciones de menú al formulario. Empezaremos por el menú

“Archivo”, añadiéndole las siguientes opciones:
Como se puede ver, modificamos para algunas de las opciones la propiedad ShorcutKeys,
para tener un acceso directo a ellas mediante la combinación de teclas Ctrl y una letra.
Al menú “Editar” le asignaremos las opciones siguientes:
5
¶
Y por último, al menú “Formato”:
Vamos a incorporarle más controles al formulario. Buscamos en el “cuadro de herramientas” el

grupo “Cuadros de diálogo”, y de los controles de este grupo añadiremos los siguientes:
“SaveFileDialog, OpenFileDialog, FontDialog y ColorDialog”.
6
Unidad
Estos controles se incorporan en el parte inferior del diseñador, al lado del control “MenuStrip”.
Su finalidad es mostrar los cuadros de diálogo típicos del entorno del sistema operativo
Windows tanto para guardar archivo, abrir archivo, mostrar las fuentes o los colores
disponibles.
La finalidad del ejercicio es realizar las funciones de un pequeño editor, reflejadas en los
menús que hemos creado, y utilizando el control RichTexBox para mostrar el texto editado.
Para comenzar la programación del proyecto. Vamos a definir una variable a nivel de formulario
que recoja el nombre que le hemos dado al archivo que estamos editando.
Public Class frmEditor

Dim NombreArchivo As String
…
…
Comenzamos con la opción “Archivo + Guardar”. Esta opción será la primera que
seleccionemos cuando ejecutamos la aplicación. Pero no estará disponible hasta que hayamos
escrito algo en rtxtEditor. Y esto lo podremos controlar mediante la propiedad “Modified” que ya
vimos con TextBox. Para ello, en el evento “DropDownOpening” activaremos la opción
“Guardar” si rtxtEditor se modificó o la desactivamos si no hubo modificación.
Private Sub ArchivoToolStripMenuItem_DropDownOpening(ByVal sender As Object,

ByVal e As System.EventArgs) Handles ArchivoToolStripMenuItem.DropDownOpening
If Me.rtxtEditor.Modified Then
Me.GuardarToolStripMenuItem.Enabled = True
Else
Me.GuardarToolStripMenuItem.Enabled = False
End If
End Sub
Otra cuestión que se nos plantea a la hora de seleccionar la opción “Archivo + Guardar” es que
no tengamos asignado ningún nombre al archivo, es decir que la variable a nivel de formulario
“NombreArchivo” este a “Nothing”. Por lo que la opción que realmente tendríamos que ejecutar
sería “Guardar como” para asignarle un nombre de archivo al texto que queremos guardar.
Veamos el código que podríamos asignarle a la opción “Guardar”.
Private Sub GuardarToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles GuardarToolStripMenuItem.Click
If NombreArchivo = Nothing Then
' si no hay nombre para el archivo, ejecutar GuardarComo
Me.GuardarComoToolStripMenuItem.PerformClick()
Else
' guardar archivo
Me.rtxtEditor.SaveFile(NombreArchivo)
Me.rtxtEditor.Modified = False
End If
End Sub
Como habíamos comentado, si no tenemos un nombre de archivo, ejecutamos la opción

“Guardar como”, invocando el procedimiento que atiende a este evento mediante la sentencia:
Me.GuardarComoToolStripMenuItem.PerformClick()
7
¶
Esta sentencia simula la acción del usuario de hacer clic en el botón “Guardar como”.
Si ya hay nombre, guardamos el texto editado en rtxtEditor en un archivo mediante el método

SaveFile del RichtTextBox, pasándole como parámetro el nombre que le asignará al archivo. Y
modificamos el valor de la propiedad “Modified” de rtxtEditor, puesto que al modificar el
contenido del RichTextBox esta propiedad cambio a True y como ya guardamos los cambios
que se han realizado, le asignamos el valor False.
Para la opción “Guardar como”.
Private Sub GuardarComoToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles GuardarComoToolStripMenuItem.Click
' solicitar un nombre de archivo
With Me.SaveFileDialog1
.Filter = "Ficheros RTF|*.rtf|Todos los ficheros|*.*"
.ShowDialog()
NombreArchivo = .FileName
End With
' comprobar si seleccionó el botón Cancelar
If NombreArchivo <> Nothing Then
Me.rtxtEditor.SaveFile(NombreArchivo)
Me.Text = NombreArchivo
' colocar el cursor al final del texto
Me.rtxtEditor.SelectionStart = Me.rtxtEditor.TextLength
End If
End Sub
Primeramente solicitamos al usuario que introduzca un nombre de archivo empleando el control

SaveFileDialog1. Utilizamos un bloque With…End With que es útil cuando queremos hacer
referencia a varias propiedades de un control, no siendo necesario escribir delante de cada
propiedad el nombre del control, solamente un punto. Utilizaremos las propiedades del control
SaveFileDialog1 siguientes:
• Filter: con ella vamos a establecer la cadena actual de filtro de nombres de archivo,
que determina las opciones que aparecen en la lista desplegable “Tipo” del cuadro de
diálogo.
8
Unidad
En nuestro caso establecemos el tipo de archivo con formato de texto enriquecido, que
tienen la extensión “RTF” y todos los ficheros, extensión “*.*”. La asignación a la
propiedad Filter será:
"Ficheros RTF|*.rtf|Todos los ficheros|*.*"
El separador utilizado es la barra vertical que se obtiene pulsado la combinación de teclas “alt
gr” + “1”
• ShowDialog: muestra el cuadro de diálogo.
• FileName: nos devuelve el nombre del archivo introducido o seleccionado en el cuadro

de diálogo.
El valor de la propiedad FileName se lo asignamos a la variable a nivel de formulario

“NombreArchivo” para que esté disponible en otros procedimientos.
A continuación comprobamos, con una sentencia “if”, si el usuario no hizo clic en el botón
“Cancelar” del cuadro de diálogo. Si fuese así, la variable “NombreArchivo” estará a Nothing.
Si el usuario seleccionó o tecleo un nombre de archivo. Guardamos el archivo con el método
“SaveFile”. Mostramos el nombre del archivo en la barra del título del formulario (Me.Text =
NombreArchivo). Colocamos el cursor al final del texto del rtxtEditor con la sentencia
siguiente:
Y modificamos el valor de la propiedad “Modified”, estableciéndolo a False.
9
¶
La ruta de archivos que aparece por defecto en la lista desplegable “Guardar en:” del cuadro de
diálogo suele ser la carpeta “Debug” del proyecto, es la carpeta donde se encuentra el fichero
ejecutable.
La opción “Archivo + Abrir” del menú mostrará un cuadro de diálogo que permita al usuario
seleccionar un archivo de los ya almacenados en el disco. Pero deberemos tener en cuenta si
el texto que se está editando en el RichTextBox ha sufrido cambios, e interrogar al usuario si
esos cambios desea descartarlos, ya que si abrimos un nuevo archivo en el RichTextBox,
dichos cambios se perderían.
El código para la opción “Abrir” podría ser:
Private Sub AbrirToolStripMenuItem_Click(ByVal sender As System.Object, ByVal

e As System.EventArgs) Handles AbrirToolStripMenuItem.Click
If Me.rtxtEditor.Modified Then ' hubo cambios en txtEditor
If MessageBox.Show("El texto ha cambiado. ¿Descarta los cambios?",
"Editor", MessageBoxButtons.YesNo) = Windows.Forms.DialogResult.No Then Exit
Sub
End If
With Me.OpenFileDialog1
.Filter = "Ficheros RTF|*.rtf|Todos los ficheros|*.*"
.FileName = Nothing
.ShowDialog()
NombreArchivo = .FileName
End With
If NombreArchivo <> Nothing Then
Me.rtxtEditor.LoadFile(NombreArchivo)
Me.Text = NombreArchivo
' colocar el cursor al final del texto
End If
End Sub
Si el contenido de rtxtEditor se ha modificado la propiedad “Modified” tendrá el valor True.

Mostramos un mensaje preguntando al usuario si descarta los cambios. Si el usuario responde
“No”, detenemos la ejecución del procedimiento con “Exit Sub”.
Si el texto no se ha modificado o el usuario descarta los cambios que se han producido en

rtxtEditor, Mostramos el cuadro de diálogo OpenFileDialog1 que, como se puede ver, tiene las
mismas propiedades que el cuadro de diálogo SaveFileDialog.
Si el usuario no hizo clic en el botón Cancelar y seleccionó un nombre de archivo, este archivo
lo “cargamos” en rtxtEditor con el método “LoadFile”. A continuación realizamos las mismas
acciones que en el procedimiento anterior (colocar el cursor al final del texto y modificar el valor
de la propiedad Modified)
La opción “Archivo + Nuevo” consistirá en crear un archivo nuevo, para ello eliminaremos el
contenido de rtxtEditor, y también el nombre de archivo recogido en la variable
“NombreArchivo”. Pero si el texto editado en ese momento en rtxtEditor se modificó, le
preguntaremos al usuario si desea descartar los cambios. El código para esta opción podría ser
el siguiente.
Private Sub NuevoToolStripMenuItem_Click_1(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles NuevoToolStripMenuItem.Click
If Me.rtxtEditor.Modified Then ' hubo cambios en rtxtEditor
10
Unidad

"Editor", MessageBoxButtons.YesNo) = Windows.Forms.DialogResult.No Then
Me.GuardarToolStripMenuItem.PerformClick()
End If
End If
Me.rtxtEditor.Clear()
Me.Text = "Editor"
NombreArchivo = Nothing
End Sub
Si el usuario NO descarta los cambios, ejecutamos el procedimiento de la opción “Guardar” que

guardará el archivo antes de editar uno nuevo. A continuación borramos el contenido de
rtxtEditor con el método “Clear”, modificamos el valor de la propiedad Text del formulario,
borramos el contenido de la variable NombreArchivo, y establecemos a False la propiedad
Modified del rtxtEditor.
La última opción del menú “Archivo” que nos queda por programar es la opción “Salir”, cuyo
objetivo es cerrar la aplicación, que conseguimos con la sentencia Application.Exit().
No obstante, al igual que en el anterior, comprobaremos primero si se modificó el contenido de
texto y preguntaremos si se desea o no descartar los cambios.
Private Sub SalirToolStripMenuItem_Click(ByVal sender As System.Object, ByVal

e As System.EventArgs) Handles SalirToolStripMenuItem.Click
Me.GuardarToolStripMenuItem.PerformClick()
End If
End If
' finalizar la aplicación
Application.Exit()
End Sub
Las opciones del menú “Editar” van a utilizar el “portapapeles” del sistema operativo. En el
Visual Studio hay una clase para manejar los datos en él almacenados, la clase “Clipboard”.
Podemos incluir en el procedimiento “Load” del formulario la sentencia que borra el
portapapeles para que al ejecutar la aplicación tengamos el portapapeles del sistema operativo
vacío.
Private Sub frmEditor_Load(ByVal sender As System.Object, ByVal e As

' borrar el portapapeles
Clipboard.Clear()
End Sub
La clase Clipboard tiene métodos para realizar las acciones de Cortar, Copiar y Pegar. Pero el
control RichTextBox tiene sus propios métodos para realizar estas acciones. Utilizando los
métodos del control RichTexBox, “Cut”, “Copy” y “Paste”, el código para las opciones del
menú “Cortar”,”Copiar” y “Pegar” será sencillo.
Private Sub CortarToolStripMenuItem_Click(ByVal sender As System.Object, ByVal

e As System.EventArgs) Handles CortarToolStripMenuItem.Click
Me.rtxtEditor.Cut()
End Sub
11
¶
Private Sub CopiarToolStripMenuItem_Click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles CopiarToolStripMenuItem.Click
Me.rtxtEditor.Copy()
End Sub
Private Sub PegarToolStripMenuItem_Click(ByVal sender As System.Object, ByVal

e As System.EventArgs) Handles PegarToolStripMenuItem.Click
Me.rtxtEditor.Paste()
End Sub
Con estos procedimientos ya tenemos disponibles en nuestro editor las acciones Cortar, Copiar
y Pegar. Pero pensemos en la posibilidad de llevar a cabo estas acciones. Si no tenemos
ningún texto seleccionado no podremos realizar las acciones de Cortar y Pegar. Por lo tanto,
en el evento “DropDowOpening” de la opción “Editar”, comprobamos si la propiedad
“SelectionLength” de rtxtEditor es mayor que 0 (cero), si es así tenemos texto seleccionado y
por lo tanto activamos las opciones Cortar y Copiar. Si no se cumple la condición es que no hay
texto seleccionado y desactivamos esas opciones.
Con la propiedad “SelectionLength” de un RichtTextBox, podemos obtener el número de

caracteres seleccionados del control.
Respecto a la opción Pegar, la activaremos si en el portapapeles hay texto almacenado. Para

determinar si en el portapapeles tenemos texto en formato RTF utilizaremos la propiedad
ContainsText de la clase Clipboard, que devuelve el valor True si hay texto y False si no lo
hay. Como parámetro le indicamos el tipo de formato de texto que nos interesa,
TextDataFormat.Rtf.
El procedimiento sería:
Private Sub EditarToolStripMenuItem_DropDownOpening(ByVal sender As Object,

ByVal e As System.EventArgs) Handles EditarToolStripMenuItem.DropDownOpening
' activar o desactivar opciones Copiar y Cortar en función de que haya
texto seleccionado
If Me.rtxtEditor.SelectionLength > 0 Then
Me.CortarToolStripMenuItem.Enabled = True
Me.CopiarToolStripMenuItem.Enabled = True
Else
Me.CortarToolStripMenuItem.Enabled = False
Me.CopiarToolStripMenuItem.Enabled = False
End If
' activar o desactivar si hay texto en el portapapeles

If Clipboard.ContainsText(TextDataFormat.Rtf) Then
Me.PegarToolStripMenuItem.Enabled = True
Else
Me.PegarToolStripMenuItem.Enabled = False
End If
End Sub
Las opciones “Deshacer” y “Rehacer”, tampoco tienen dificultad ya que el control RichTextBox
proporciona los métodos “Undo” y “Redo” que deshacen y rehacen la última operación en un
RichTextBox.
Private Sub DeshacerToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles DeshacerToolStripMenuItem.Click
Me.txtEditor.Undo()
End Sub
12
Unidad
Private Sub RehacerToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles RehacerToolStripMenuItem.Click
Me.txtEditor.Redo()
End Sub
Además, el control RichTextBox dispone de los métodos “CanUndo” y “CanRedo”, que nos
indicará si se puede deshacer o rehacer la última acción realizada en un RichTextBox.
Devuelve un valor True si es posible y False si no lo es.
Vamos a utilizar estos dos métodos para activar o desactivar las opciones del menú “Deshacer”
y “Rehacer”. Por lo tanto, añadimos al evento “DropDowOpening” de la opción “Editar” las
siguientes sentencias.
Private Sub EditarToolStripMenuItem_DropDownOpening(ByVal sender As Object,

ByVal e As System.EventArgs) Handles EditarToolStripMenuItem.DropDownOpening
….
….
….
If Me.rtxtEditor.CanUndo Then
Me.DeshacerToolStripMenuItem.Enabled = True
Else
Me.DeshacerToolStripMenuItem.Enabled = False
End If
If Me.rtxtEditor.CanRedo Then
Me.RehacerToolStripMenuItem.Enabled = True
Else
Me.RehacerToolStripMenuItem.Enabled = False
End If
End Sub
Y, para concluir el menú “Editar”, nos queda programar la opción “Seleccionar todo”, que con el
método “SelectAll” del control RichTextBox, simplemente sería una sentencia invocando a
dicho método.
Private Sub SeleccionarTodoToolStripMenuItem_Click(ByVal sender As

SeleccionarTodoToolStripMenuItem.Click
Me.rtxtEditor.SelectAll()
End Sub
El último menú de nuestro editor es el menú “Formato”. Para las opciones “Fuente” y “Color”
utilizaremos los cuadros de diálogo que nos muestran los controles FontDialog y ColorDialog
que ya tenemos en nuestro formulario.
Para la opción “Fuente” tendríamos las siguientes sentencias.
Private Sub FuenteToolStripMenuItem_Click(ByVal sender As System.Object, ByVal

e As System.EventArgs) Handles FuenteToolStripMenuItem.Click
With Me.FontDialog1
' determinar la fuente que tiene el texto
.Font = Me.rtxtEditor.SelectionFont
.ShowDialog()
' asignar la nueva fuente al texto
Me.rtxtEditor.SelectionFont = .Font
End With
End Sub
13
¶
Empleamos el control FontDialog1 dentro de un bloque With…End With. Y la propiedad
“SelectionFont” del control RichTextBox, con la que podemos obtener o establecer la fuente
del texto seleccionado o la fuente del texto del punto de inserción actual, es decir, donde esté
el cursor en ese momento.
Con la primera sentencia conseguimos que el cuadro de diálogo muestre el tipo de fuente que
tiene el texto donde se encuentra el cursor o el texto que está seleccionado. A continuación se
muestra el cuadro de diálogo (con el método “ShowDialog”). Y por último, se le asigna la fuente
seleccionada (que nos devuelve la propiedad “Font” del control “FontDialog”) al texto
seleccionado o, si no hay texto seleccionado, esta será la fuente que se utilizará si
comenzamos a escribir en ese punto donde se encuentra el cursor.
Para la opción “Color”, utilizaremos el control ColorDialog1 y la propiedad del RichTextBox,

“SelectionColor”. Los procesos serían los mismos que en la opción anterior.
Private Sub ColorToolStripMenuItem_Click(ByVal sender As System.Object, ByVal

e As System.EventArgs) Handles ColorToolStripMenuItem.Click
With Me.ColorDialog1
.Color = Me.rtxtEditor.SelectionColor
.ShowDialog()
Me.rtxtEditor.SelectionColor = .Color
End With
End Sub
Asignamos el color que tiene el texto seleccionado, o donde se encuentre el cursor, a la

propiedad “Color” del ColorDiagog1 para que lo muestre el cuadro de diálogo. Con
“ShowDialog” mostramos dicho cuadro. Y asignamos el nuevo color a la propiedad
SelectionColor de rtxtEditor.
Con la opción “Negrita” queremos que se incluya esta característica a la fuente del texto, o si
ya estuviese en negrita, que se quite esta característica. Para saber si un texto está en negrita
en un RichTextBox, tenemos la expresión SelectionFont.Bold que nos devuelve el valor True
si el texto está en negrita y False en caso contrario.
En el procedimiento que atiende al evento “Click” de la opción “Negrita”, primeramente

crearemos un objeto de la clase Font que almacenará la fuente que devuelve la propiedad
“SelectionFont” del RichTextBox del texto seleccionado o del punto de inserción donde se
encuentre el cursor.
Dim FuenteActual As Font = Me.rtxtEditor.SelectionFont
A continuación preguntaremos si esa fuente ya tiene el texto en negrita.
If Me.rtxtEditor.SelectionFont.Bold Then….
Si es así, le “quitamos” esa característica con la expresión siguiente:
New Font(FuenteActual.FontFamily, FuenteActual.Size, FuenteActual.Style And

Not FontStyle.Bold)
Observamos que hemos creado una nueva fuente tomando como base la “FuenteActual”, pero
con la expresión:
FuenteActual.Style And Not FontStyle.Bold
Con la que eliminamos la característica “Bold” (negrita) de dicha fuente.
14
Unidad
Si el texto no estuviese en negrita, lo modificamos con la expresión siguiente:
New Font(FuenteActual.FontFamily, FuenteActual.Size, FuenteActual.Style Or

FontStyle.Bold)
Private Sub NegritaToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles NegritaToolStripMenuItem.Click
If Me.rtxtEditor.SelectionFont.Bold Then
' a la fuente actual le quitamos la negrita
Me.rtxtEditor.SelectionFont = New Font(FuenteActual.FontFamily,
FuenteActual.Size, FuenteActual.Style And Not FontStyle.Bold)
Else
' a la fuente actual le añadimos la negrita
FuenteActual.Size, FuenteActual.Style Or FontStyle.Bold)
End If
End Sub
De similar manera serán los procedimientos para las opciones “Cursiva” y “Subrayado”.
Private Sub CursivaToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles CursivaToolStripMenuItem.Click
If Me.rtxtEditor.SelectionFont.Italic Then
' a la fuente actual le quitamos la cursiva
FuenteActual.Size, FuenteActual.Style And Not FontStyle.Italic)
Else
' a la fuente actual le añadimos la cursiva
FuenteActual.Size, FuenteActual.Style Or FontStyle.Italic)
End If
End Sub
Private Sub SubrayadoToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles SubrayadoToolStripMenuItem.Click
If Me.rtxtEditor.SelectionFont.Underline Then
' a la fuente actual le quitamos el subrayado
FuenteActual.Size, FuenteActual.Style And Not FontStyle.Underline)
Else
' a la fuente actual le añadimos el subrayado
FuenteActual.Size, FuenteActual.Style Or FontStyle.Underline)
End If
End Sub
Por último, vamos a programar el evento “DropDownOpening” de la opción “Formato” para que
las opciones “Negrita”, “Cursiva” y “Subrayado” del menú aparezcan activadas al desplegar el
menú Formato si la fuente del texto donde se encuentra el cursor tiene alguna de esas
características.
15
¶
Para activar una opción de menú, asignaremos a su propiedad Checked el valor True, y para
desactivarlas le asignamos el valor False.
Private Sub FormatoToolStripMenuItem_DropDownOpening(ByVal sender As Object,

ByVal e As System.EventArgs) Handles FormatoToolStripMenuItem.DropDownOpening
If Me.rtxtEditor.SelectionFont.Bold Then
Me.NegritaToolStripMenuItem.Checked = True
Else
Me.NegritaToolStripMenuItem.Checked = False
End If
If Me.rtxtEditor.SelectionFont.Italic Then
Me.CursivaToolStripMenuItem.Checked = True
Else
Me.CursivaToolStripMenuItem.Checked = False
End If
If Me.rtxtEditor.SelectionFont.Underline = True Then

Me.SubrayadoToolStripMenuItem.Checked = True
Else
Me.SubrayadoToolStripMenuItem.Checked = False
End If
End Sub
Y, para concluir este ejercicio, vamos a controlar mediante el evento “FormClosing” el cierre
del formulario cuando el usuario hace clic en la “X” (equis) de la esquina superior derecha del
formulario. Dicho evento tiene lugar antes de que se cierre el formulario, y en él vamos a
comprobar si el texto de rtxtEditor se ha modificado; si es así le preguntaremos al usuario si
descarta esos cambios. Si responde que no, cancelamos el cierre del formulario con la
expresión:
e.Cancel=True
Donde e es un parámetro del procedimiento.
Private Sub frmEditor_FormClosing(ByVal sender As Object, ByVal e As

System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing
' cancelar el cierre del formulario
e.Cancel = True
End If
End If
End Sub
16
9
Unidad
Validación de datos
MÓDULO

Unidad 9: VALIDACIÓN DE DATOS

Permanente
ISBN: 978-84-692-3442-6
Unidad
9 Validación de datos
El objetivo de la unidad es mostrar, mediante un ejercicio, la posibilidad de validación de

diferentes tipos de datos introducidos en un TextBox. Veremos los distintos eventos que nos
facilitaran esta labor de validación y emplearemos la clase ErrorProvider.
Diseño........................................................................................................................................................4
Proceso del ejercicio. ................................................................................................................................5
3
¶
En este ejercicio vamos a realizar la validación de diferentes tipos de datos introducidos en un

TextBox.
Utilizaremos como novedad, la clase ErrorProvider, que nos proporciona una manera sencilla
para indicar al usuario los errores de un control en un formulario. También emplearemos los
eventos Validating y Validated de un TextBox, en los que realizaremos las comprobaciones
para validar los datos introducidos.
Crearemos un nuevo proyecto con el nombre “12.ValidarDatos”.
Diseño
Al formulario principal le añadiremos los siguientes controles:

Label Label1 “E-mail:”
Label Label2 “Fecha:”
Label Label3 “Edad:”
TextBox txtEmail (en blanco)
TextBox txtFecha (en blanco)
TextBox txtEdad (en blanco)
Button btnAceptar “Aceptar”
También incorporaremos al formulario un objeto de la clase ErrorProvider.

Es del tipo de objetos que aparece en la parte inferior del diseñador del formulario.
El formulario tendrá un aspecto similar al de la imagen siguiente.
4
Unidad
El ejercicio consistirá en validar los datos introducidos en los TextBox del formulario. Para
txtEmail, comprobaremos que el usuario tecleó los caracteres “@” y “.” (punto). Para txtFecha
que el valor introducido es una fecha válida. Y para txtEdad que tecleó valores númericos.
Hagamos primero la siguiente observación. Cuando el cursor se encuentra en un TextBox se

dice que ese control tiene el “foco de entrada” o también podemos decir que se está editando
el TextBox. Perderá el foco de entrada cuando nos desplacemos a otro control mediante la
pulsación de la tecla de tabulación o haciendo clic con el ratón en ese control.
El evento Validating tiene lugar antes de que un control vaya a perder el foco de entrada.
Será pues, el evento apropiado para comprobar si los datos introducidos son correctos.
Vamos a utilizar la instrucción Try…Catch para la detección de errores. Y cuando una

validación no sea correcta, provocaremos un error mediante la instrucción Throw.
Comencemos por el control txtEmail. Primero comprobaremos que el contenido de la propiedad

Text de txtEmail no sea de longitud cero, esto es que el usuario no haya tecleado nada, para
ello utilizaremos la expresión siguiente.
If Me.txtEmail.Text.Length = 0 Then…
Si se cumple esta condición provocamos un error o excepción con el mensaje “Introduzca su E-

mail”.
Throw New Exception("Introduzca su E-mail")
5
¶
Después comprobaremos que la propiedad Text contenga los caracteres “@” y “.” (punto) que
tienen las direcciones de correo electrónico. Utilizaremos la función IndexOf de la propiedad
Text, que recibe como parámetro un carácter y ésta devuelve el valor -1 si el carácter
especificado no se encuentra en la secuencia de caracteres de la propiedad Text. Si el
carácter se encuentra en dicha secuencia, devuelve su posición dentro de ella.
El procedimiento que atiende al evento Validating de txtEmail podría ser el siguiente:
Private Sub txtEmail_Validating(ByVal sender As Object, ByVal e As

System.ComponentModel.CancelEventArgs) Handles txtEmail.Validating
Try
If Me.txtEmail.Text.Length = 0 Then
' generar un error o excepción
Throw New Exception("Introduzca su E-mail")
ElseIf Me.txtEmail.Text.IndexOf("@") = -1 Or
Me.txtEmail.Text.IndexOf(".") = -1 Then
Throw New Exception("E-mail incorrecto" & vbNewLine &
"Ejemplo: micorreo@hotmail.com")
End If
If MessageBox.Show(ex.Message, "Validar Controles",
MessageBoxButtons.OKCancel, MessageBoxIcon.Error) =
Windows.Forms.DialogResult.OK Then
' cancelar todos los eventos
e.Cancel = True
End If
End Try
End Sub
Vemos que, dentro de un bloque Try…Catch, comprobamos si la longitud de la propiedad Text

es 0 (cero), generando un error o excepción solicitándole que introduzca su correo electrónico,
ya que el TextBox está vacío.
Después comprobamos si la propiedad Text contiene los caracteres “@” y “.” (punto),
generando otro error si faltase cualquiera de estos caracteres.
Si se produce alguno de los dos errores, se ejecuta el código entre el bloque Cath …End Try. Y
en él vamos a ofrecer al usuario, mediante un MessageBox, la posibilidad de corregir el error,
para ello hará clic en el botón “Aceptar”, con lo cual se cancelarán todos los eventos que se
producirían a continuación del evento Validating, luego txtEmail no perdería el foco de
entrada. Esto se conseguiría con la expresión:
e.Cancel = True
Para validar el control txtFecha, utilizaremos el objeto ErrorProvider. El procedimiento podría

ser el siguiente.
Private Sub txtFecha_Validating(ByVal sender As Object, ByVal e As

System.ComponentModel.CancelEventArgs) Handles txtFecha.Validating
Try
If Me.txtFecha.Text.Length = 0 Then
Throw New Exception("Introduzca una fecha")
ElseIf Not IsDate(Me.txtFecha.Text) Then
Throw New Exception("Fecha incorrecta")
End If
Me.ErrorProvider1.SetError(Me.txtFecha, ex.Message)
Me.txtFecha.Focus()
e.Cancel = True
End Try
End Sub
6
Unidad
Igual que antes, primero comprobamos si txtFecha.Text.Length es 0 (cero), generando un error
si se cumple la condición. Después comprobamos si Text contiene un valor de fecha válido.
Para ello utilizamos la función IsDate, que devuelve un valor True si se trata de una fecha
válida; devuelve False si no lo es. Para señalar el error utilizamos el control ErrorProvider1.
Mediante el procedimiento SetError, le indicamos en que control se produjo el error y el
mensaje de error asociado.
Si se produce un error en la fecha, aparece a la derecha de txtFecha un icono parpadeando. Si

acercamos el ratón a dicho icono nos muestra el mensaje del error que establecimos. Como se
muestra en la imagen anterior.
Una vez corregida la fecha, para eliminar el icono del control ErrorProvider, tendremos que
ejecutar la siguiente sentencia
Me.ErrorProvider1.SetError(Me.txtFecha, Nothing)
Y el lugar de ejecución de esta sentencia será un nuevo evento, el evento Validated, este
evento se produce cuando finaliza la validación del control, es decir, después del evento
Validating.
Private Sub txtFecha_Validated(ByVal sender As Object, ByVal e As

System.EventArgs) Handles txtFecha.Validated
' cuando la fecha sea correcta, quitamos el ErrorProvider
Me.ErrorProvider1.SetError(Me.txtFecha, Nothing)
End Sub
Para validar el TextBox txtEdad, escribiremos el siguiente procedimiento.
Private Sub txtEdad_Validating(ByVal sender As Object, ByVal e As

System.ComponentModel.CancelEventArgs) Handles txtEdad.Validating
Try
If Me.txtEdad.Text.Length = 0 Then
Throw New Exception("Introduzca la edad")
ElseIf Not IsNumeric(Me.txtEdad.Text) Then
Throw New Exception("Edad incorrecta")
Else
'valor edad correcto, quitamos el ErrorProvider
Me.ErrorProvider1.SetError(Me.txtEdad, Nothing)
End If
7
¶
Me.ErrorProvider1.SetError(Me.txtEdad, ex.Message)
e.Cancel = True
Me.txtEdad.SelectAll()
End Try
End Sub
En este caso, utilizamos la función IsNumeric, que devuelve True si el argumento es un valor
numérico. Y, para hacerlo de otro manera, no empleamos el evento Validated para eliminar el
icono del ErrorProvider, sino que, dentro de la instrucción If…EndIf, añadimos un Else donde
eliminaremos dicho icono si no se ha detectado ningún error.
Con esto ya concluimos el ejercicio. Al botón “Aceptar” no le asignamos ningún proceso.

8
10
Unidad
Los eventos del ratón. Arrastrar

y soltar (Drag & Drop)
MÓDULO

Unidad 10: LOS EVENTOS DEL RATÓN. ARRASTRAR Y SOLTAR (DRAG & DROP)

Permanente
ISBN: 978-84-692-3442-6
Unidad
10 y soltar (Drag & Drop)
En esta unidad veremos algunos de los eventos que se producen en el manejo del ratón y el
proceso de arrastrar y soltar (drag & drop) entre dos controles, primeramente desarrollaremos
un ejercicio de arrastre entre dos controles TextBox y luego otro entre dos controles
PictureBox.
ARRASTRE ENTRE DOS CONTROLES TEXTBOX ........................................................................ 4

Diseño........................................................................................................................................................4
ARRASTRE ENTRE DOS CONTROLES PICTUREBOX.................................................................. 5
Diseño........................................................................................................................................................6
3
¶
Arrastre entre dos controles TextBox
Vamos a realizar primeramente un ejercicio donde arrastraremos el contenido de un TextBox y

lo soltaremos en otro TextBox.
Crearemos un nuevo proyecto con el nombre “13.Arrastrar_Soltar”.
Diseño
Al formulario principal le añadiremos solamente dos TextBox, por ahora:

TextBox txtOrigen Buenos días
TextBox txtDestino (en blanco)
Proceso del ejercicio
El proceso consistirá en arrastrar el contenido de txtOrigen a txtDestino.

Lo primero que deberemos de hacer es modificar la propiedad Allowdrop de txtDestino.

Inicialmente esta propiedad está a valor False, la cambiaremos a True para conseguir que
txtDestino acepte los datos que se intenten soltar sobre él en una operación de arrastre.
Esto lo podemos hacer en tiempo de diseño, en el cuadro de propiedades de los controles de
un formulario, o bien en el procedimiento Load del formulario. Escogeremos esta última opción.
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As

' permitir que txtDestino reciba datos en una operación de arrastre
Me.txtDestino.AllowDrop = True
End Sub
Normalmente las operaciones de arrastre comienzan con un clic del botón izquierdo del ratón
sobre el control de origen, en nuestro caso txtOrigen. Por lo tanto utilizaremos el evento
MouseDown de txtOrigen para iniciar este proceso. Este evento se produce cuando el
puntero del ratón se encuentra sobre el control y se presiona un botón.
Private Sub txtOrigen_MouseDown(ByVal sender As Object, ByVal e As

System.Windows.Forms.MouseEventArgs) Handles txtOrigen.MouseDown
' Iniciar el arrastre
Me.txtOrigen.DoDragDrop(Me.txtOrigen.Text, DragDropEffects.Copy)
End Sub
Para iniciar la operación de arrastre invocamos el método DoDragDrop de txtOrigen. Los

parámetros que necesita son:
4
Unidad
• Los datos que se van a arrastrar. En nuestro caso el contenido de la propiedad Text de
txtOrigen.
• Y un valor de la enumeración DragDropEffects. En nuestro caso “Copy”, con lo que

queremos indicar que los datos se copian al destino.
El siguiente evento que tendremos que programar es el evento DragEnter del control de
destino, es decir de txtDestino. Este evento se produce cuando arrastramos el cursor del
ratón sobre el control durante una operación de arrastrar y soltar.
Private Sub txtDestino_DragEnter(ByVal sender As Object, ByVal e As

System.Windows.Forms.DragEventArgs) Handles txtDestino.DragEnter
'comprobar el formato de los datos arrastrados
If (e.Data.GetDataPresent(DataFormats.Text)) Then
' aceptamos los datos arrastrados
e.Effect = DragDropEffects.Copy
Else
' rechaza los datos arrastrados
e.Effect = DragDropEffects.None
End If
End Sub
En este procedimiento comprobamos que los datos arrastrados son apropiados para el control
de destino. En nuestro caso no habrá ningún problema ya que los datos son tipo texto y
además los dos controles, origen y destino, son TextBox.
Para realizar estas comprobaciones debemos de atender al parámetro “e” del procedimiento.
Mediante la expresión
e.Data.GetDataPresent(DataFormats.Text)
Se comprueba si el tipo de dato que se arrastra sobre el control txtDestino es de tipo texto. La
expresión devuelve un valor True si esto es asi y por lo tanto aceptaremos los datos
arrastrados mediante la expresión
Si los datos arrastrados no se pudieran representar en el control de destino, los rechazaremos

con la expresión
Por último nos queda programar el evento que se produce cuando soltamos el botón del
ratón sobre el control de destino, evento DragDrop.
Private Sub txtDestino_DragDrop(ByVal sender As Object, ByVal e As

System.Windows.Forms.DragEventArgs) Handles txtDestino.DragDrop
' finalizar la operación de arrastre, llevando los datos arrastrados
al destino
Me.txtDestino.Text = e.Data.GetData(DataFormats.Text)
End Sub
La expresión e.Data.GetData(DataFormats.Text) proporciona los datos que se

están arrastrando, que los llevamos a la propiedad Text del control txtDestino.
Arrastre entre dos controles PictureBox
Veamos un nuevo control, “PictureBox”. Su finalidad es mostrar una imagen en el formulario.
5
¶
Diseño
Añadimos al formulario principal dos controles PictureBox, que llamaremos pbOrigen y

pbDestino. En el control pbOrigen mostraremos una imagen. Para ello iremos al cuadro de
propiedades del formulario y en la propiedad Image de pbOrigen, hacemos clic en el cuadro de
la derecha.
Nos mostrará un cuadro de diálogo desde el que podremos importar una imagen para
asignársela a esta propiedad.
También modificaremos la propiedad BorderStyle de ambos PictureBox a FixedSingle.
La disposición de los controles en el formulario podría ser la siguiente.
6
Unidad
Como el proceso es prácticamente igual que el anterior, con la única diferencia de que los
datos arrastrados no son de tipo texto sino que son de tipo Bitmap (mapa de bits de
Windows), vamos a tener en cuenta las siguientes consideraciones:
Si mantenemos la tecla CTRL pulsada mientras realizamos el arrastre, la imagen se “copia” en

pbDestino, es decir, los dos PictureBox mostrarán la imagen. Y si no pulsamos la tecla CTRL,
la imagen se “mueve” a pbDestino, es decir, no se mostrará en pbOrigen, sólo en pbDestino,
después de realizar el arrastre.
Primeramente tendremos que modificar la propiedad AllowDrop de pbDestino para que este
control acepte la operación de arrastrar y soltar que deseamos realizar. Y lo hacemos en el
procedimiento Load del formulario, como en el ejemplo anterior.

' permitir que txtDestino reciba datos en una operación de arrastre
Me.txtDestino.AllowDrop = True
Me.pbDestino.AllowDrop = True
End Sub
Después iniciamos el arrastre en el evento MouseDown de pbOrigen, invocando al método

DoDragDrop.
Private Sub pbOrigen_MouseDown(ByVal sender As Object, ByVal e As

System.Windows.Forms.MouseEventArgs) Handles pbOrigen.MouseDown
' iniciar el arrastre, para copiar o mover
Me.pbOrigen.DoDragDrop(Me.pbOrigen.Image, DragDropEffects.Copy Or
DragDropEffects.Move)
End Sub
En este caso los “efectos” del arrastre podrán ser “Copy” o “Move” dependiendo de si se pulsa
la tecla CTRL al realizar la operación de arrastre o no se pulsa.
Será en el evento DragEnter donde tendremos que averiguar si la tecla CTRL está pulsada.
Otra vez tendremos que atender al parámetro “e” del procedimiento. La propiedad KeyState
de este parámetro nos proporciona información sobre el estado actual de las teclas MAYÚS,
CTRL y ALT y de los botones del ratón. Si la tecla CTRL está pulsada, devuelve el valor 8. Y
7
¶
si el botón primario o izquierdo del ratón está pulsado, devuelve 1. Luego la combinación de
ambas pulsaciones hará que KeyState devuelva el valor 9 (8+1).
Private Sub pbDestino_DragEnter(ByVal sender As Object, ByVal e As

System.Windows.Forms.DragEventArgs) Handles pbDestino.DragEnter
' comprobar el formato de los datos arrastrados
If (e.Data.GetDataPresent(DataFormats.Bitmap)) Then
' e.KeyState: nos da información de pulsaciones en ratón y teclado
' si pulsamos CTRL, devuelve 8 (mirar ayuda)
' si pulsamos botón primario del ratón (botón izqdo.) devuelve 1
' ' luego CTRL + botón izqdo -> 8 + 1 = 9
If e.KeyState = 9 Then
' aceptar datos para copiar
Else
' aceptar datos para mover
e.Effect = DragDropEffects.Move
End If
Else
' rechazar los datos
End If
End Sub
En el procedimiento anterior, primero comprobamos que el formato de los datos arrastrados es

el apropiado para el control de destino. Como éste es un PictureBox, los datos apropiados
serán del tipo “Bitmap”. Después comprobamos si, además del botón izquierdo del mouse,
también se pulsó la tecla CTRL. Si es así el efecto deseado es “Copy”, si no será “Move”.
En el caso de que los datos arrastrados no sean del tipo “Bitmap” se rechazan.
En el evento DragDrop del control de destino, llevamos la imagen arrastrada a la propiedad

Image de pbDestino. Y si la acción realizada es “Move”, quitamos la imagen del origen,
pbOrigen.
Private Sub pbDestino_DragDrop(ByVal sender As Object, ByVal e As

System.Windows.Forms.DragEventArgs) Handles pbDestino.DragDrop
' llevar la imagen al destino
Me.pbDestino.Image = e.Data.GetData(DataFormats.Bitmap)
' si es mover, la quitamos del origen
If e.Effect = DragDropEffects.Move Then
Me.pbOrigen.Image = Nothing
End If
End Sub
8
11
Unidad
Acceso a bases de datos con

ADO.NET (I)
MÓDULO

Unidad 11: ACCESO A BASES DE DATOS CON ADO.NET (I)

Permanente
ISBN: 978-84-692-3442-6
Unidad
11 ADO.NET (I)
El objetivo de esta unidad es mostrar el proceso para agregar un origen de datos a un

proyecto. Además se mostrarán en un formulario los datos de las tablas de la base de datos
empleando diferentes controles.
AGREGAR UN ORIGEN DE DATOS AL PROYECTO................................................... 5

QUÉ ES ADO.NET......................................................................................................... 13
Qué es un DataSet........................................................................................................ 13
MOSTRAR LOS DATOS DE UNA TABLA EN EL FORMULARIO MEDIANTE UN

DATAGRIDVIEW ........................................................................................................... 13
Relación entre controles.............................................................................................. 22
MOSTRAR LOS DATOS DE UNA TABLA EN EL FORMULARIO MEDIANTE

CONTROLES TEXTBOX ............................................................................................... 25
MOSTRAR EN UN FORMULARIO UNA RELACIÓN “MAESTRO-DETALLE” ENTRE

DOS TABLAS ................................................................................................................ 29
3
¶
Primeramente tendremos que crear con Access, la base de datos BDClientes, con la siguiente
estructura:
Vamos también a crear la carpeta “BD” con la siguiente ruta:

Mis Documentos\VisualStudio2005\Projects\BD
Y guardamos en dicha carpeta la base de datos creada, con algunos datos de prueba.
4
Unidad
11 ADO.NET (I)
Agregar un origen de datos al proyecto
Crearemos un nuevo proyecto, que podemos llamar “20.BD1”.
En primer lugar deberemos incorporar al proyecto la base de datos creada, es decir, vamos a
“agregar un origen de datos al proyecto”.
Para ello seleccionamos la opción del menú “Datos + Agregar nuevo origen de datos…”
Y nos aparecerá la siguiente ventana:
Hacemos clic en el botón “Siguiente”:
5
¶
Hacemos clic en el botón “Nueva conexión…”:

6
Unidad
11 ADO.NET (I)
Modificamos el “Origen de datos” haciendo clic en el botón “Cambiar…” y seleccionando

“Archivo de base de datos Microsoft Access” en el supuesto de que se especificase otro origen
de datos. Después hacemos clic en el botón “Examinar…” Buscamos la carpeta BD creada
anteriormente y seleccionamos la base de datos BDClientes.
7
¶
Probamos la conexión a la bd (base de datos) haciendo clic en el botón “Probar conexión”.

8
Unidad
11 ADO.NET (I)
Cerramos la ventana del mensaje. Y seguimos adelante haciendo clic en el botón “Aceptar”.
En esta ventana, podemos ver la cadena de conexión que utilizará el proyecto para conectar a
la base de datos.
Hacemos clic en el botón “Siguiente” y nos muestra una ventana con un mensaje en el que nos
pregunta si deseamos copiar la base de datos a la carpeta del proyecto y modificar la cadena
de conexión. Vamos a contestar que “Sí”.
9
¶
En la siguiente ventana nos pregunta si se desea guardar la cadena de conexión en el archivo
de configuración de la aplicación con el nombre “BDClientesConnectionString”. Hacemos clic
en el botón “Siguiente”.
Ya tenemos la cadena de conexión creada, pulsamos el botón Siguiente y en la ventana que

aparece se va a crear el Dataset (conjunto de datos) con el nombre de “BDClientesDataSet”.
10
Unidad
11 ADO.NET (I)
Expandimos “Tablas” para ver que están identificadas las tres tablas de la base de datos
(clientes, productos y ventas).
11
¶
Marcamos “Tablas”, para que seleccione las tres tablas. Y hacemos clic en el botón “Finalizar”.
Ya tenemos el Dataset del proyecto creado.
En la ventana “Orígenes de datos” (Opción menú “Datos\Mostrar origen de datos…”)

podemos ver su estructura.
Antes de seguir con el ejercicio, vamos a comentar algunos conceptos.
12
Unidad
11 ADO.NET (I)
Qué es ADO.Net
ADO.NET es un conjunto de objetos que nos proporciona la plataforma .NET para el acceso a
datos.
Qué es un DataSet
Es una representación de datos, residentes en memoria, obtenidos de un origen de datos (en
nuestro caso, de una base de datos). Representa un componente fundamental de la
arquitectura de ADO.NET.
En nuestro ejemplo, se ha creado el DataSet “BDClientesDataSet” obtenido de los datos de la
base de datos de Access “BDClientes”. Que lo tenemos en la parte inferior del diseñador del
formulario.
El DataSet está compuesto por una colección de objetos DataTable, que cada uno de ellos
referencia a una tabla de la base de datos. En nuestro caso habrá tres DataTable, “Clientes”,
“Productos” y “Ventas”.
Mostrar los datos de una tabla en el formulario mediante un DataGridView
Continuamos con nuestro ejemplo. Ahora vamos a seleccionar y arrastrar la tabla Clientes al
formulario, desde la ventana “Orígenes de datos”.
13
¶
Aparecerán en el formulario un conjunto de controles relacionados con el DataTable de
Clientes.
Comentemos cada uno de ellos.
• ClientesTableAdapter
Un TableAdapter comunica la aplicación con la base de datos. Es decir, rellena los DataTable
del DataSet del origen de datos mediante la ejecución de consultas y devuelve a la base de
datos los datos actualizados desde la aplicación.
Luego se comunica con la base de datos en ambas direcciones, ejecutando consultas o
procedimientos almacenados.
Vamos a editar el diseñador del Dataset, para ello hacemos clic en el segundo icono de la
ventana del origen de datos.
14
Unidad
11 ADO.NET (I)
Nos aparece una ventana con la estructura del DataSet.
Aparecen los tres DataTable, con las relaciones entre ellas, y cada uno de ellos tiene asociado
su TableAdapter, con sus métodos Fill y GetData, para comunicarse con el origen de datos.
Veamos el asistente para configurar un TableAdapter. Para ello nos situamos con el ratón
sobre la referencia que aparece en la tabla Clientes del TableAdapter con el nombre
“clientesTableAdapter”, hacemos clic en el botón derecho y seleccionamos la opción
“Configurar…”.
15
¶
Nos aparecerá la ventana del asistente de configuración del TableAdapter.

16
Unidad
11 ADO.NET (I)
Podemos ver la instrucción SQL utilizada para cargar los datos a la tabla clientes desde la base
de datos. No la modificamos y hacemos clic en el botón “Siguiente”.
Nos mostrará la siguiente ventana del asistente. Si leemos toda la información que contiene,
podemos comprender la utilidad del TableAdapter.
17
¶
Vemos que crea los métodos necesarios para su función: Fill, GetData, Insert, Update y Delete.
Al hacer clic en el botón Finalizar, nos aparece una pantalla informándonos de la correcta
configuración de todos los métodos.
Vamos a hacer otra vez clic con el botón derecho del ratón sobre “clientesTableAdapter” y
seleccionamos la opción “Vista previa de datos”.
18
Unidad
11 ADO.NET (I)
Nos aparecerá la siguiente ventana.
19
¶
Y si hacemos clic en el botón “Vista previa”. Vemos el contenido de la tabla Clientes que
tenemos en el DataSet de la aplicación, llamado “BDClientesDataSet”.
Podemos mostrar los datos de todas las tablas que contiene el DataSet. Por ejemplo,
seleccionemos la tabla productos, hacemos clic en la lista desplegable de la parte superior
izquierda de la ventana y seleccionamos los métodos Fill y GetData de la tabla productos.
Y hacemos clic en el botón “Vista previa”. Nos muestra los datos de la tabla productos del
DataSet.
20
Unidad
11 ADO.NET (I)
• ClientesBindingSource
Es un potente componente que encapsula el origen de datos de un formulario y simplifica el

enlace de controles de un formulario a los datos.
• ClientesBindingNavigator
El control BindingNavigator representa una manera normalizada para desplazarse y

manipular los datos en un formulario. En la mayoría de los casos, se empareja un control
BindingNavigator con un control BindingSource para desplazarse por los registros de datos
de un formulario e interactuar con ellos.
• ClientesDataGridView
El control DataGridView proporciona una tabla personalizable para mostrar datos.
En la versión 2008 nos aparece un nuevo componente TableAdapterManager, proporciona

una funcionalidad importante para guardar datos en tablas de datos relacionadas.
TableAdapterManager usa las relaciones de clave externa que relacionan las tablas de datos
para determinar el orden correcto para enviar las inserciones, actualizaciones y eliminaciones
de un conjunto de datos a la base de datos sin infringir las restricciones (integridad referencial)
en la base de datos.
21
¶
Relación entre controles
Todos estos controles están relacionados entre sí mediante sus propiedades. Veamos cómo.
El control ClientesBindingSource se enlaza con el Dataset del proyecto, “BDClientesDataset”, y
concretamente con la tabla “Clientes”, a través de sus propiedades “DataSource” y
“DataMember”.
El control ClientesBindingNavigator tiene la propiedad “BindingSource” donde se asigna el

control ClientesBindingSource que tenemos en el proyecto.
Y el control ClientesDataGridView mostrará los datos de la tabla Clientes, ya que su propiedad

“DataSource” tiene asignado el control ClientesBindingSource.
22
Unidad
11 ADO.NET (I)
Si ejecutamos la aplicación se mostrará en el control ClientesDataGridView los registros de la

tabla Clientes.
Con la barra de navegación podremos desplazarnos por los registros mostrados en

ClientesDataGridView. También nos informa del número de registros que tiene la tabla Clientes
y el número de registro en el que estamos. Podemos también añadir registros y eliminarlos
mediante los botones que nos ofrece dicha barra de navegación. Después de realizar algunas
de estas acciones debemos de hacer clic en el botón “Guardar datos”.
23
¶
Importante: Mientras estemos depurando la aplicación los cambios en la BD no se van a

guardan. Cuando ya esté la aplicación finalizada y ejecutemos el fichero ejecutable (con
extensión “.exe”) de la carpeta Debug, su funcionamiento será correcto.
El código básico necesario para la ejecución de los botones de la barra de navegación es el

siguiente:

'TODO: esta línea de código carga datos en la tabla
'BDClientesDataSet.clientes' Puede moverla o quitarla según sea
necesario.
Me.ClientesTableAdapter.Fill(Me.BDClientesDataSet.clientes)
End Sub
Al ejecutar la aplicación, se invoca al método “Fill” de ClientesTableAdapter para “cargar” los

datos de la tabla Clientes de la base de datos al dataset BDClientesDataSet.
Private Sub ClientesBindingNavigatorSaveItem_Click(ByVal sender As


ClientesBindingNavigatorSaveItem.Click
Me.Validate()
Me.ClientesBindingSource.EndEdit()
Me.ClientesTableAdapter.Update(Me.BDClientesDataSet.clientes)
End Sub
Este procedimiento se ejecutará al hacer clic en el botón “Guardar datos” de la barra de

navegación. En él realizamos la modificación de la base de datos recogiendo los cambios
efectuados en la edición de la tabla Clientes, para ello invocamos el método “Update” de
ClientesTableAdapter.
24
Unidad
11 ADO.NET (I)
Mostrar los datos de una tabla en el formulario mediante controles TextBox
Vamos añadir otro formulario a nuestra aplicación y realizar el mismo proceso de seleccionar y
arrastrar la tabla clientes de la ventana “Orígenes de datos” al formulario, pero antes vamos a
cambiar la forma en que representaremos los datos de la tabla en el formulario. Cambiaremos
a “Detalles”, en vez de “DataGridView”. Para ello, en la ventana “Orígenes de datos”, hacemos
clic en el botón izquierdo sobre la tabla clientes y seleccionamos la opción “Detalles”.
Una vez modificado. Arrastramos la tabla clientes en formato “Detalles” al formulario.
El formulario quedaría:
25
¶
Los controles BDClientesDataSet, ClientesBindingSource, ClientesTableAdapter y

ClientesBindingNavigator aparecerán también en este formulario. Sin embargo no estará
presente el control ClientesDataGridView, en su caso tendremos una serie de controles
TextBox que serán los encargados de mostrar los campos de la tabla Clientes: IDCliente,
Nombre y Pais. Para el campo FIngreso (Fecha ingreso) se utilizará un control llamado
“DateTimePicker”, que es apropiado para trabajar con fechas.

Los controles están relacionados entre sí por sus propiedades, como en el ejemplo anterior. Y,
como novedad, podemos observar como los TextBox están enlazados a los campos de la tabla
Clientes. En su propiedad Text aparece un icono que identifica este enlace.
Para el control DateTimePicker observaremos su propiedad Value.
26
Unidad
11 ADO.NET (I)
Vamos a iniciar la depuración del proyecto, pero cambiemos el formulario de inicio de la

aplicación para que sea Form2 el formulario que se muestre, y no Form1. Para ello vamos a la
opción de menú “Proyecto + Propiedades de NombreProyecto…”. Y modificamos el formulario
de inicio.
Iniciamos la depuración y vemos como podemos editar los registros de la tabla clientes en los
controles del formulario.
27
¶
28
Unidad
11 ADO.NET (I)
Mostrar en un formulario una relación “maestro-detalle” entre dos tablas
Tal y como diseñamos la base de datos, la tabla clientes está relacionada con la tabla ventas.
Vamos a incluir un DataGridView al formulario para ver las ventas del cliente actual. Para ello
seleccionaremos y arrastraremos al formulario la tabla ventas, pero la tabla ventas que está
dentro de clientes en el Dataset, NO la tabla ventas que está al mismo nivel que la tabla
clientes y productos. Ya que deseamos visualizar las ventas del cliente actual, NO las
ventas de todos los clientes. La entrada “ventas” dentro de “clientes” recoge la relación
entre ambas tablas (relación clientes-ventas). La entrada “ventas” que depende
directamente de “BDClientesDataSet” recoge todas las ventas existentes (OBSERVAR
DETENIDAMENTE LA FIGURA SIGUIENTE):
El formulario nos quedaría:
29
¶
Vemos que además del control VentasDataGridView, tenemos dos nuevos controles,
VentasBindingSource y VentasTableAdapter.
El control VentasTableAdapter comunica la aplicación con el origen de datos, lo utilizaremos
para cargar los datos de la tabla Ventas en el Dataset (Fill) y para actualizar la base de datos
(Update).
Observar que la propiedad DataMember de VentasBindingSource tiene asignado el valor
“clientesventas” ya que este elemento controla la relación existente entre las tablas clientes
y ventas.
30
Unidad
11 ADO.NET (I)
Vamos también a utilizar el VentasDataGridView sólo para ver las ventas del cliente actual, no
podremos añadir ni eliminar registros de la tabla ventas. Para ello modificaremos el valor de las
propiedades AllowUserToAddRows y AllowUserToDeleteRows a valor False.
Con lo que respecta al código, se habrá añadido la sentencia que invoca al método Fill de
VentasTableAdapter para cargar los datos de la tabla ventas al Dataset.

'BDClientesDataSet.ventas' Puede moverla o quitarla según sea
necesario.
Me.VentasTableAdapter.Fill(Me.BDClientesDataSet.ventas)
31
¶
'BDClientesDataSet.clientes' Puede moverla o quitarla según sea
necesario.
Me.ClientesTableAdapter.Fill(Me.BDClientesDataSet.clientes)
End Sub
Al iniciar la depuración del formulario tendremos:

Cuando nos desplazamos de cliente con los botones de navegación, si el nuevo cliente tiene
ventas, se muestran en el DataGridView.
32
Unidad
11 ADO.NET (I)
33
12
Unidad

ADO.NET (II)
MÓDULO

Unidad 12: ACCESO A BASES DE DATOS CON ADO.NET (II)

Permanente
ISBN: 978-84-692-3442-6
Unidad
12 ADO.NET (II)
El objetivo de la unidad es profundizar en el acceso a datos. Mediante el desarrollo de un

ejercicio se emplearán más componentes y clases del ADO.NET.
ESTRUCTURA DE LA BASE DE DATOS BIBLIOTECA. .............................................. 4

MOSTRAR LOS DATOS DE UNA TABLA EN EL FORMULARIO MEDIANTE
CONTROLES LABEL. ..................................................................................................... 4
MOSTRAR DATOS DE UNA RELACIÓN MEDIANTE UN CONTROL LISTBOX. ........ 6
REALIZAR UN PRÉSTAMO. LAS CLASES DATAROW Y DATAROWVIEW. ........... 12
DEVOLVER UN PRÉSTAMO. ....................................................................................... 15
3
¶
Estructura de la base de datos Biblioteca.
Crearemos con Access la base de datos Biblioteca con la siguiente estructura:

IMPORTANTE. Sobre el campo “prestado” de la tabla “libros”: los libros que estén
prestados tendrán el campo “prestado” a valor True. Si no están en préstamo tendrán el valor
False.
Creamos algunos datos de prueba.

Guardamos la base de datos en la carpeta BD que creamos en la anterior unidad. Recordar
que su ruta es: VisualStudio2008\Projects\BD
Mostrar los datos de una tabla en el formulario mediante controles LabeL
Creamos un nuevo proyecto, que podemos llamarle “21.BDBiblioteca”.
Agregaremos un nuevo origen de datos para crear el Dataset de la base de datos Biblioteca, tal
y como hicimos en la unidad anterior. Se creará con el nombre “BibliotecaDataSet”.
A continuación arrastraremos la tabla “socios” al formulario, pero antes modificaremos a
“Detalles” su modo de representación en dicho formulario (como ya hicimos en la unidad
anterior), y además modificaremos también cada campo de la tabla para que se
representen mediante etiquetas (Label). Por defecto se representa con TextBox, pero como
no vamos a realizar ninguna modificación de su contenido, lo representaremos mediante
etiquetas. Tal como se muestra en la siguiente figura, en la ventana “Orígenes de datos”
realizamos las modificaciones.
4
Unidad
12 ADO.NET (II)
Después de realizar las modificaciones, al arrastrar la tabla “socios”, tendremos el siguiente

formulario:
Las etiquetas están enlazadas con los campos de la tabla “socios”. Si vamos a la ventana de
propiedades vemos que se han creado las etiquetas con el nombre del campo más el
literal “Label1” (por ejemplo: “CodsocioLabel1”) y que la propiedad Text tiene el icono que
identifica dicho enlace con la base de datos.
5
¶
Como no vamos a poder modificar los contenidos de los campos mostrados en las etiquetas.
Vamos a suprimir los botones “Agregar nuevo”, “Eliminar”, “Guardar datos” del control
“SociosBindingNavigator”. Seleccionamos con el ratón el icono de cada opción y haciendo
clic en el botón izquierdo escogemos la opción “Eliminar”.
Mostrar datos de una relación mediante un control ListBox.
Vamos también a mostrar los préstamos que tiene el socio que está representado en las
etiquetas en un momento dado. Para ello utilizaremos un ListBox que contendrá los códigos
de los libros en préstamo por ese socio.
Añadiremos un control ListBox al formulario. Le llamaremos “lstPrestamos”. Vamos a añadir

también un control BindingSource al formulario para que recoja la relación socios-
prestamos de la base de datos.
6
Unidad
12 ADO.NET (II)
Vamos a asignarle el nombre “SociosPrestamosBindingSource”. Y en su propiedad

DataSource seleccionamos el BindingSource de la tabla “socios” (SociosBindingSource)
y en la propiedad DataMember, seleccionamos la entrada “sociosprestamos”.
Y ahora enlazaremos el control lstPrestamos con el BindingSource que acabamos de

crear. Para ello seleccionamos en la propiedad DataSource de lstPrestamos el BindingSource
“SociosPrestamosBindingSource” y en la propiedad DisplayMember, el campo “codlibro”
7
¶
Con esto conseguimos que se muestren en el ListBox los códigos de los libros en préstamo del
socio representado en las etiquetas en un momento dado.
8
Unidad
12 ADO.NET (II)
Vamos a añadir al formulario otro ListBox, y en él mostraremos los títulos de los libros que
“no estén prestados”, es decir los que tengan el campo prestado a “false”. Le podemos
llamar “lstLibrosDisponibles” y añadiremos también un control BingingSource que
llamaremos “LibrosSinPrestarBindingSource”. Y para que este control gestione la tabla
“libros” tendremos que realizar las siguientes asignaciones en las propiedades DataSource, y
DataMember (OBSERVAR LAS IMÁGENES SIGUIENTES):
9
¶
Ahora, en la propiedad Filter de LibrosSinPrestarBindingSource, escribiremos la expresión

prestado=false. Con eso conseguiremos que este BindingSource filtre los datos de la tabla
“libros” para seleccionar aquellos registros cuyo campo prestado esté a false, es decir que el
libro esté disponible (sin prestar). En la siguiente imagen vemos como quedaría configurado el
control:
10
Unidad
12 ADO.NET (II)
Y ya configurado, utilizamos este BindingSource para rellenar el ListBox “lstLibrosDisponibles”.

La selección que tenemos que realizar en sus propiedades es la representada en la siguiente
imagen:
Al iniciar, de nuevo, la depuración del ejercicio tendremos el siguiente formulario:
11
¶
Donde ahora tendremos, en el ListBox de la derecha, los libros que no están en préstamo.
Si miramos el código necesario para todo lo que hemos incluido en el formulario hasta ahora
será simplemente:

'BibliotecaDataSet.libros' Puede moverla o quitarla según sea necesario.
Me.LibrosTableAdapter.Fill(Me.BibliotecaDataSet.libros)
'BibliotecaDataSet.prestamos' Puede moverla o quitarla según sea necesario.
Me.PrestamosTableAdapter.Fill(Me.BibliotecaDataSet.prestamos)
'BibliotecaDataSet.socios' Puede moverla o quitarla según sea necesario.
Me.SociosTableAdapter.Fill(Me.BibliotecaDataSet.socios)
End Sub
Esto es, las tres sentencias Fill para cargar los datos de las tres tablas en el DataSet del
proyecto. El procedimiento SociosBindingNavigatorSaveItem_Click, no se utiliza ya
que eliminamos la opción “Guardar” del control SociosBindingNavigator.
Realizar un préstamo. Las clases DataRow y DataRowView.
Vamos a añadirle la funcionalidad de “realizar un préstamo” a nuestro ejercicio. Cuando el

usuario haga doble clic sobre uno de los títulos del ListBox lstLibrosDisponibles, se
interpretará que desea realizar el préstamo de ese libro al socio representado en ese momento
en las etiquetas.
Para la codificación de esta acción utilizaremos las clases DataRow y DataRowView.
Un objeto de la clase DataRow almacenará una fila de datos de una tabla. Por ejemplo un
objeto de la clase DataRow podrá almacenar todos los campos de un registro de la tabla
“libros”: codlibro, titulo, autor, editorial, prestado.
Y un objeto DataRowView representa una “vista” de una fila de datos de una tabla.
12
Unidad
12 ADO.NET (II)
La necesidad que tenemos de utilizar objetos de esta clase en este ejercicio, es porque
estamos empleando ListBox enlazados a datos, y cuando realizamos la selección de un
elemento en uno de estos ListBox, la propiedad SelectedItem devolverá toda la fila del
elemento seleccionado, no sólo el valor que se muestre en el ListBox. Por ejemplo, en el
ListBox lstLibrosDisponibles, si seleccionamos uno de los títulos que nos muestra, la
propiedad SelectedItem nos devuelve un objeto de la clase DataRowView, que
representa a todos los campos del registro o fila cuyo título seleccionamos. Así también,
podemos tener acceso a todos los campos del registro.
En la siguiente imagen vemos que, en la depuración del código, la propiedad SelectedItem del
control lstLibrosDisponibles (Me.lstLibrosDisponibles.SelectedItem) devuelve un
objeto de la clase DataRowView ({System.Data.DataRowView}).
Luego vamos a declarar una variable, que llamaremos “drv”, del tipo DataRowView que
almacenará la fila de datos seleccionada del ListBox “lstLibrosDisponibles”. Y de la variable
“drv” obtendremos el código del libro del registro o fila cuyo título seleccionamos, puesto
que “drv” contiene todos los campos del registro.
Las sentencias serían las siguientes:
' la selección en el listbox devuelve un objeto DataRowView

Dim drv As DataRowView = Me.lstLibrosDisponibles.SelectedItem
' obtenemos el codlibro de la fila devuelta
Dim codlibro As String = drv("codlibro")
Una vez obtenido el código de libro del título seleccionado en lstLibrosDisponibles, el proceso
de realizar un préstamo conlleva los siguientes pasos:
• Poner el campo prestado de la tabla “libros” a True, puesto que ese libro dejará de
estar disponible.
Para ello buscaremos en la tabla “libros” el código de libro seleccionado mediante el método
FindBycodlibro, la expresión es la siguiente.
' buscamos en libros el codlibro a prestar y ponemos el campo prestado a True

Me.BibliotecaDataSet.libros.FindBycodlibro(codlibro).prestado = True
Y actualizamos la base de datos, con Update.
' actualizamos la BD
Me.LibrosTableAdapter.Update(Me.BibliotecaDataSet.libros)
• Crear un registro en la tabla préstamos que recoja el nuevo préstamo.
Creamos una variable del tipo DataRow (fila de datos de una tabla), la llamamos “dr”, y en ella
almacenamos la nueva fila de datos (o registro) de la tabla “préstamos” mediante la
expresión siguiente:
Dim dr As DataRow = Me.BibliotecaDataSet.prestamos.NewprestamosRow
Después asignamos valores para los tres campos de la fila de datos nueva. El código de libro
lo obtenemos de la variable que declaramos para almacenar la selección que se realizó en
lstLibrosDisponibles (“codlibro”). El código de socio nos lo proporciona la etiqueta del formulario
que contiene dicha información (“Me.CodsocioLabel1.Text”), y la fecha del préstamo la
obtenemos con la expresión “Now.ToShortDateString”. Las sentencias serán las
siguientes:
13
¶
dr("codlibro") = codlibro
dr("codsocio") = Me.CodsocioLabel1.Text
dr("fecha") = Now.ToShortDateString
Ahora añadimos la nueva fila de datos (“dr”) a la tabla préstamos con el método Add de la
colección Rows.
' añadir la fila a la tabla prestamos

Me.BibliotecaDataSet.prestamos.Rows.Add(dr)
Y por último actualizamos la tabla préstamos en la base de datos.
Me.PrestamosTableAdapter.Update(Me.BibliotecaDataSet.prestamos)
Recopilando todo el código visto hasta ahora, el evento doble clic de lstLibrosDisponibles sería
el siguiente:
'***************** Realizar un préstamo **************************

Private Sub lstLibrosDisponibles_DoubleClick(ByVal sender As Object, ByVal e
As System.EventArgs) Handles lstLibrosDisponibles.DoubleClick
Try
' la selección en el listbox devuelve un objeto DataRowView (fila de datos)
Dim drv As DataRowView = Me.lstLibrosDisponibles.SelectedItem
' obtenemos el codlibro de la fila devuelta
' PONER EL CAMPO PRESTADO A TRUE DE LA TABLA LIBROS

' buscamos en libros el codlibro a prestar y ponemos el campo prestado a
True
Me.BibliotecaDataSet.libros.FindBycodlibro(codlibro).prestado = True
'CREAR UN REGISTRO EN LA TABLA PRESTAMOS

Dim dr As DataRow = Me.BibliotecaDataSet.prestamos.NewprestamosRow
dr("codlibro") = codlibro
dr("codsocio") = Me.CodsocioLabel1.Text
dr("fecha") = Now.ToShortDateString
' añadir la fila a la tabla prestamos
Me.BibliotecaDataSet.prestamos.Rows.Add(dr)
Catch ex As NullReferenceException
MessageBox.Show("No hay libros disponibles", "Biblioteca",
MessageBox.Show(ex.Message & vbNewLine & ex.Source)
End Try
End Sub
Incluimos un bloque Try…Catch para detectar posibles errores. El primer “Catch” será para
detectar cuando el usuario haga doble clic en lstLibrosDisponibles y no haya ningún elemento
en el ListBox, es decir cuando esté vacío lstLibrosDisponibles. El error que se producirá
será NullReferenceException. Y el segundo será para el resto de posibles errores. En ambos
bloques mostramos un mensaje.
Podemos también limitar el número de préstamos que un socio pueda tener, lo limitaremos a
tres libros. Para ello utilizaremos la expresión Me.lstPrestamos.Items.Count que nos
14
Unidad
12 ADO.NET (II)
devuelve el número de elementos que tiene el ListBox lstPrestamos, es decir, el número de

libros que tiene en préstamo el socio representado en las etiquetas. Mediante el siguiente
bloque if comprobamos si ya tiene tres libros en préstamo, si es así mostramos un mensaje y
salimos del procedimiento. Este código lo escribiremos al comienzo del procedimiento, antes
del bloque Try…Catch que contiene todo el código.
' máximo 3 préstamos

If Me.lstPrestamos.Items.Count = 3 Then
MessageBox.Show("Tiene 3 libros en préstamo", "Biblioteca",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation)
Exit Sub
End If
Con esto ya concluimos el proceso de realizar un préstamo.
Devolver un préstamo.
La devolución de un préstamo se llevará a cabo cuando el usuario seleccione, con doble clic,
uno de los libros que tiene en préstamo, representados en el ListBox lstPrestamos. Al
igual que el proceso anterior, la propiedad SelectedItem de lstPrestamos devuelve un objeto de
la clase DataRowView, es decir toda la fila, no solamente el código de libro representado en el
ListBox. Por lo tanto creamos un objeto de esa clase para almacenar el valor devuelto de la
propiedad SelectedItem.
El proceso será el inverso que el anterior, esto es, habrá que modificar el campo prestado en la
tabla “libros” para ese libro seleccionado, estableciéndolo a valor False, y eliminar la fila
creada para recoger el préstamo en la tabla “prestamos”.
Esto último, la eliminación de la fila en la tabla “prestamo”, se conseguirá con una sola línea, en
la que realizaremos la búsqueda de la fila, en la tabla “prestamos”, mediante el método
FindBycodlibro e invocando al procedimiento Delete, conseguimos la eliminación de la fila en
dicha tabla. La sentencia será la siguiente.
Me.BibliotecaDataSet.prestamos.FindBycodlibro(codlibro).Delete()
Después actualizamos la base de datos.

El procedimiento será el siguiente.
'****************** Devolución de préstamo **********************

Private Sub lstPrestamos_DoubleClick(ByVal sender As Object, ByVal e As
System.EventArgs) Handles lstPrestamos.DoubleClick
Try
Dim drv As DataRowView = Me.lstPrestamos.SelectedItem
' PONER EL CAMPO PRESTADO A False EN LA TABLA LIBROS

Me.BibliotecaDataSet.libros.FindBycodlibro(codlibro).prestado = False
' ELIMINAR EL PRESTAMO EN LA TABLA DE PRESTAMOS

' eliminar la fila en la tabla préstamos
Me.BibliotecaDataSet.prestamos.FindBycodlibro(codlibro).Delete()
' actualizar la BD
Catch ex As NullReferenceException
MessageBox.Show("No hay préstamos", "Biblioteca", MessageBoxButtons.OK,
MessageBoxIcon.Information)
MessageBox.Show(ex.Message & vbNewLine & ex.Source)
End Try
15
¶
También incluimos el código en un bloque Try…Catch para detectar los posibles errores. E
igual que en el procedimiento anterior, el primer “Catch” detectará el error que se producirá si
se realiza un doble clic en lstPrestamos cuando este vacío (NullReferenceException). Y el
segundo será para el resto de errores.
16

Modulo de Diseño y Realizacion de Servicios

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Modulo de Diseño y Realizacion de Servicios

Cargado por

Copyright:

Formatos disponibles

TÉCNICO SUPERIOR EN DESARROLLO DE

Introducción Visual Basic.Net

Título del Módulo: DISEÑO Y REALIZACIÓN DE SERVICIOS DE

Unidad 1: INTRODUCCIÓN VISUAL BASIC .NET

Dirección: Dirección General de Políticas Educativas, Ordenación

Coordinador de los contenidos: Mateo García Parra

Autor: Mateo García Parra

Colección: Materiales didácticos de aula

Serie: Formación profesional especifica

Edita: Consejería de Educación y Ciencia

Deposito Legal: AS-3565-2009

Copyright: ©2009. Consejería de Educación y Ciencia

¿QUÉ ES VISUAL BASIC .NET? ...................................................................................... 4

¿Dónde puedo obtener Visual Basic .NET?

Podéis seleccionar el idioma Español antes de la descarga.

Inicio con Visual Basic Express Edition

Una vez instalada la herramienta, la ejecutamos. Aparecerá la pantalla de bienvenida (página

A continuación vamos a la opción del menú “Archivo” y seleccionamos “Nuevo Proyecto”.

Entorno de desarrollo de Visual Basic. Formularios.

Fig.1. Entorno de desarrollo de Visual Basic

En la parte izquierda tenemos el “Cuadro de herramientas” (fig.2). Si situamos el ratón sobre la

Fig.2. Pestaña cuadro de herramientas

Si no ves la pestaña de la figura anterior (fig.2.). También puedes acceder al cuadro de

Fig.3. Icono “cuadro de herramientas” de la barra de herramientas.

Dibujar controles en el formulario

Fig.4. Cuadro de herramientas. Controles Button y Textbox.

Fig.5. Formulario con los dos controles.

Si nos hemos equivocado y deseamos borrar controles del formulario, simplemente

Otras formas de dibujar controles en el formulario son:

Propiedades de los controles

Fig.6. Icono de la ventana de propiedades.

También podemos acceder a la ventana de propiedades seleccionando la opción Ver +

Fig.7. Ventana de propiedades.

Fig.8. Lista desplegable de la ventana propiedades.

Fig.9. Modificar la propiedad Text del control Button1.

• Seleccionar la opción Ver + Código en el menú.

Nos mostrará la siguiente ventana:

Fig.10. Ventana de código.

Public Class Form1

Me.TextBox1.Text = "¡Hola Mundo!"

Public Class Form1

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As

Me.TextBox1.Text = "¡Hola Mundo!"

Probemos la aplicación ejecutándola, pulsemos la tecla F5 (o también la opción Depurar +

Fig.11. Formulario con el nuevo botón.

Para asignarle el código al nuevo botón, vamos a acceder al procedimiento “Button2.Click” de

Fig.12. Lista desplegable con los objetos del formulario.

Ahora, de la lista desplegable que está a la derecha de la anterior, seleccionamos el evento

Fig.13. Seleccionar el evento “Click”

Ya tenemos el procedimiento “Button2.Click” para programar el segundo botón de nuestro

Añadimos a este procedimiento la siguiente línea de código:

Private Sub Button2_Click(ByVal sender As Object, ByVal e As System.EventArgs)

Ejecutamos la aplicación, pulsar F5, y, cuando aparezca el formulario, pulsamos primero en el

Para detener la ejecución podemos hacerlo de diferentes maneras, en la siguiente figura

Utilización del depurador de proyectos

La ayuda o MSDN Library (Microsoft Development Network Library) es una importantísima

Fig.16. Accediendo a la ayuda.

Fig.17. Búsqueda en la ayuda.

Fig.18. Agregar a favoritos de la Ayuda.

En la Ayuda encontraremos información de muy distintos niveles. Consultas como “Crear el

Características del lenguaje y

Título del Módulo: DISEÑO Y REALIZACIÓN DE SERVICIOS DE

Unidad 2: CARACTERÍSTICAS DEL LENGUAJE Y CONTROLES MÁS