Introducción a visual basic upn 6 final

UNIVERSIDAD PEDAGÓGICA NACIONAL FRANCISCO MORAZÁN PROGRAMA DE APOYO A LA ENSEÑANZA MEDIA DE HONDURAS

PROGRAMA DE CAPACITACIÓN MODULAR (PCM) PARA DOCENTES DE FORMACIÓN PROFESIONAL DE LA ENSEÑANZA MEDIA DE

HONDURAS

MÓDULO: TALLER DE VISUAL BASIC 6.0 BÁSICO

“HONDURAS CRECE CON PROFESIONALES DE CALIDAD”

ELABORADO POR: LEVÍ ASTUL CASTRO ORDÓÑEZ

TEGUCIGALPA M. D. C. MAYO, 2006

MÓDULO: TALLER DE VISUAL BASIC 6.0 BÁSICO

LEVÍ ASTUL CASTRO ORDÓÑEZ

TABLA DE CONTENIDO PRESENTACIÓN ............................................................................................................................................ 1 UNIDAD I. INTRODUCCIÓN ....................................................................................................................... 2

CONTENIDO .................................................................................................................................................... 2 OBJETIVOS DE LA UNIDAD .............................................................................................................................. 2 1. PARADIGMAS DE PROGRAMACIÓN.............................................................................................................. 2

1.1. Programación imperativa ................................................................................................................. 2 1.2. Programación modular..................................................................................................................... 2 1.3. Programación orientada a objetos (POO) ........................................................................................ 3 1.4. Programación visual ......................................................................................................................... 3 1.5. Programación orientada a eventos ................................................................................................... 3

2. CARACTERÍSTICAS DE VISUAL BASIC 6 ...................................................................................................... 4 RESUMEN ....................................................................................................................................................... 5 EJERCICIOS..................................................................................................................................................... 5 EVALUACIÓN.................................................................................................................................................. 5

UNIDAD II. ENTORNO DE DESARROLLO INTEGRADO..................................................................... 6 CONTENIDO .................................................................................................................................................... 6 OBJETIVOS DE LA UNIDAD .............................................................................................................................. 6 1. INICIAR VISUAL BASIC ............................................................................................................................... 6 2. ELEMENTOS DEL ENTORNO DE DESARROLLO INTEGRADO.......................................................................... 7

2.1. El menú principal.............................................................................................................................. 7 2.2. La barra de herramientas ................................................................................................................. 7 2.3. Área de diseño de formulario ........................................................................................................... 7 2.4. El explorador Proyectos.................................................................................................................... 7 2.5. La ventana Propiedades .................................................................................................................... 8 2.6. La ventana posición del formulario.................................................................................................. 9 2.7. La barra de componentes.................................................................................................................. 9 2.8. Manipulación de componentes para crear objetos .......................................................................... 9 2.9. Editor de código .............................................................................................................................. 10 2.10. Ventanas Inmediato, Locales e Inspección .................................................................................. 10

3. OPCIONES DE ENTORNO ............................................................................................................................ 12 4. ESTRUCTURA DE UNA APLICACIÓN. .......................................................................................................... 13 5. TIEMPO DE DISEÑO, TIEMPO DE EJECUCIÓN Y MODO DE INTERRUPCIÓN .................................................... 14

5.1. Tiempo de diseño............................................................................................................................. 14 5.2. Tiempo de ejecución........................................................................................................................ 14 5.3. Modo de interrupción...................................................................................................................... 15

6. OPERACIONES SOBRE APLICACIONES ........................................................................................................ 15 6.1. Abrir un proyecto nuevo ................................................................................................................. 15 6.2. Guardar una aplicación.................................................................................................................. 15 6.2. Cerrar una aplicación ..................................................................................................................... 17 6.2. Abrir una aplicación existente........................................................................................................ 18

7. EJECUTAR UNA APLICACIÓN ..................................................................................................................... 19 RESUMEN ..................................................................................................................................................... 20 EJERCICIOS................................................................................................................................................... 20 EVALUACIÓN................................................................................................................................................ 20

UNIDAD III. BREVE METODOLOGÍA DE PROGRAMACIÓN........................................................... 21 CONTENIDO .................................................................................................................................................. 21 OBJETIVOS DE LA UNIDAD ............................................................................................................................ 21 1. CREACIÓN DE ALGORITMOS ..................................................................................................................... 21 2. PLANIFICACIÓN DE INTERFAZ DE USUARIO .............................................................................................. 22 RESUMEN ..................................................................................................................................................... 24

ii

EJERCICIOS................................................................................................................................................... 24 EVALUACIÓN................................................................................................................................................ 24

UNIDAD IV. IDENTIFICADORES, TIPOS DE DATOS, EXPRESIONES Y SENTENCIAS BÁSICAS.......................................................................................................................................................................... 25

CONTENIDO .................................................................................................................................................. 25 OBJETIVOS DE LA UNIDAD ............................................................................................................................ 25 1. TIPOS DE DATOS........................................................................................................................................ 25 2. DECLARACIÓN DE IDENTIFICADORES........................................................................................................ 26

2.1. Variables.......................................................................................................................................... 26 2.1.1. Ámbito de las variables ................................................................................................................ 27 2.1.2. Declaración implícita ................................................................................................................... 27 2.1.3. Declaración explícita ................................................................................................................... 28 2.1.4. Descripción del alcance de las variables ..................................................................................... 30 2.1.5. Variables estáticas........................................................................................................................ 31 2.2. Constantes ....................................................................................................................................... 32 2.2.1. Crear constantes propias.............................................................................................................. 32

3. EXPRESIONES............................................................................................................................................ 33 4. SENTENCIAS DE ENTRADA, ASIGNACIÓN, SALIDA Y DE LLAMADA............................................................. 34

4.1. Sentencia de entrada ....................................................................................................................... 34 4.2. Sentencia de asignación.................................................................................................................. 35 4.3. Sentencia de salida.......................................................................................................................... 35 4.5 Sentencia de llamada ....................................................................................................................... 36

RESUMEN ..................................................................................................................................................... 36 EJERCICIOS................................................................................................................................................... 36 EVALUACIÓN................................................................................................................................................ 37

UNIDAD V. SENTENCIAS DE DECISIÓN................................................................................................ 38 CONTENIDO .................................................................................................................................................. 38 OBJETIVOS DE LA UNIDAD ............................................................................................................................ 38 1. SENTENCIAS DE DECISIÓN......................................................................................................................... 38

1.1. Sentencia de decisión IF ... THEN ... ELSE ... .............................................................................. 38 1.2. Sentencia de decisión SELECT CASE ........................................................................................... 45

RESUMEN ..................................................................................................................................................... 47 EJERCICIOS................................................................................................................................................... 48 EVALUACIÓN................................................................................................................................................ 48

UNIDAD VI. CAJAS O VENTANAS DE DIALOGO ................................................................................ 49 CONTENIDO .................................................................................................................................................. 49 OBJETIVOS DE LA UNIDAD ............................................................................................................................ 49

1.1. Visualizar datos con MsgBox ......................................................................................................... 49 1.2. Obtener datos con InputBox ........................................................................................................... 50

2. CAJAS DE DIALOGO PERSONALIZADAS...................................................................................................... 51 3. CUADROS DE DIÁLOGO MODALES Y NO MODALES..................................................................................... 54 RESUMEN ..................................................................................................................................................... 55 EJERCICIOS................................................................................................................................................... 56 EVALUACIÓN................................................................................................................................................ 56

UNIDAD VII. ARREGLOS Y SENTENCIAS REPETITIVAS................................................................. 57 CONTENIDO .................................................................................................................................................. 57 OBJETIVOS DE LA UNIDAD ............................................................................................................................ 57 1. ARREGLOS................................................................................................................................................ 57

1.1 Array estático ................................................................................................................................... 58 1.2. Array dinámico................................................................................................................................ 58

2. SENTENCIAS REPETITIVAS ........................................................................................................................ 58 2.1. Sentencia FOR ... NEXT................................................................................................................. 59

iii

2.2. Sentencia WHILE … WEND ......................................................................................................... 61 RESUMEN ..................................................................................................................................................... 62 EJERCICIOS................................................................................................................................................... 62 EVALUACIÓN................................................................................................................................................ 63

UNIDAD VIII. GESTIÓN DE DATOS ........................................................................................................ 64 CONTENIDO .................................................................................................................................................. 64 OBJETIVOS DE LA UNIDAD ............................................................................................................................ 64 1. BASES DE DATOS RELACIONALES............................................................................................................. 64

1.1. Estructura de una Base de Datos ................................................................................................... 64 1.1.1. Campos ......................................................................................................................................... 64 1.1.2. Campo Clave ................................................................................................................................ 64 1.1.3. Registros ....................................................................................................................................... 64 1.2.4. Tablas ........................................................................................................................................... 65 2. Relaciones de Bases de Datos ............................................................................................................ 65 2.1. Tipos de Relaciones......................................................................................................................... 65 2.1.1. Relaciones de uno a uno .............................................................................................................. 65 2.1.2. Relaciones de uno a muchos........................................................................................................ 65 2.1.3. Relaciones muchos a muchos ...................................................................................................... 65

2. CREACIÓN DE UNA BASE DE DATOS EN MSACCESS .................................................................................. 65 RESUMEN ..................................................................................................................................................... 84 EJERCICIOS................................................................................................................................................... 84 EVALUACIÓN................................................................................................................................................ 84

ANEXO I. TABLA DE CÓDIGOS ASCII ................................................................................................... 92 GLOSARIO DE TÉRMINOS ....................................................................................................................... 93 BIBLIOGRAFÍA............................................................................................................................................ 94

1

PRESENTACIÓN La Universidad Pedagógica Nacional (UPNFM) está ejecutando el Programa de Capacitación Modular (CPM) para docentes de Formación Profesional de la Enseñanza Media de Honduras, según convenio de trabajo entre el Programa de Apoyo a la Enseñanza Media de Honduras (PRAEMHO), de la Secretaría de Educación (SE), y la UPNFM. El presente material fue desarrollado en el marco de dicho programa y se utilizará para impartir el Taller de Visual Basic 6.0 dirigido a la formación profesional de la enseñanza madia. En este contexto, este libro ha sido escrito pensando en profesores que posiblemente no tienen conocimientos avanzados de programación y por lo tanto el desarrollo de las unidades es más o menos intuitivo. No se hace un desarrollo profundo ni extenso de los temas, pero se presentan las herramientas necesarias para iniciar al lector en el mundo de la programación con Visual Basic. Se asume que el lector tiene conocimientos básicos del uso de computadoras y del sistema operativo Windows 95, 98, Me o Xp. Se inicia con una presentación general sobre el Entorno de Desarrollo Integrado de Visual Basic. Luego se presentan algunos elementos de Paradigmas y Metodologías de Programación. A continuación se tratan algunos elementos fundamentales de lenguaje de Visual Basic. Para el manejo de Bases de Datos se incluye una pequeña sección sobre Bases de Datos Relacionales y si implementación en MSAccess. Y finalmente se presenta una pequeña aplicación para manipular bases de datos con Visual Basic. Esperamos que el presente material sirva de base y motivación para estudios más profundos de la materia y que contribuya al fortalecimiento de la gestión y docencia en el Nivel Medio de Educación de Honduras.

2

UNIDAD I. INTRODUCCIÓN CONTENIDO

1. Paradigmas de programación. 2. Características generales de Visual Basic 6.

OBJETIVOS DE LA UNIDAD

1. Conocer de manera general los diferentes paradigmas de lenguajes de programación. 2. Conocer de manera general las características de Visual Basic 6

1. PARADIGMAS DE PROGRAMACIÓN De manera general un paradigma puede entenderse como un conjunto de reglas, explícitas o implícitas que rigen una conducta. En el mundo de la computación existen diversos lenguajes de programación de computadoras. Cada uno tiene características que lo ponen en ventaja en relación a otros. Dichas características responden a uno más paradigmas de programación. En el caso de Visual Basic (VB), estamos ante un lenguaje de programación imperativo, modular, orientado a objetos (POO), visual y orientado a eventos, es decir, responde al menos a cinco paradigmas; aunque el paradigma dominante es el de POO ya que éste incluye a los primeros dos. Una de sus características importantes es su Entorno de Desarrollo Integrado (IDE) el cual proporciona al programador todas las herramientas necesarias además de un ambiente amigable para el desarrollo de aplicaciones. Si bien es cierto que los lenguajes visuales con IDE facilitan tremendamente el desarrollo de aplicaciones siempre es necesario conocer el lenguaje y todo lo que implica desarrollar una aplicación. 1.1. Programación imperativa Cuando se construye un programa bajo este paradigma se debe considerar que los elementos fundamentales para la construcción de algoritmos son los identificadores, expresiones y sentencias. De hecho, un algoritmo se considera como un conjunto de sentencias que se ejecutan de manera secuencial. Entonces, cuando se analiza un problema para resolverlo, en él se deben identificar los hechos, atributos y procesos necesarios para su solución. Ejemplo 1.1. Se desean dividir dos números reales y mostrar el resultado. En este problema se identifican los siguientes elementos: Atributos: El numerador: A El denominador: B El resultado de la división: D Procesos: Si B≠0 entonces D=A/B Como se observa toda la información se puede obtener a partir del enunciado del problema. Se asigna identificador únicamente a los atributos y los hechos, mientras que a los procesos no se les asigna identificador. 1.2. Programación modular Cuando se resuelve un problema bajo este paradigma la idea fundamental es que un problema original se puede descomponer en subproblemas más específicos. Cada subproblema debe ser una tarea específica y claramente distinguible del resto de tareas. Luego, se aplica la programación imperativa a esos subproblemas. En este sentido, la programación imperativa es una herramienta dentro de la programación modular. Otro hecho importante es que en la programación modular se asignan identificadores tanto a los atributos, los hechos como a los procesos. A los procesos se les suele llamar módulos, subtareas, subprogramas o rutinas.

3

Ejemplo 1.2. El sistema para control de datos de alumnos en un colegio permite la matrícula de

alumnos, ingresar calificaciones y eliminar alumnos de los listados. Escribir un programa para este sistema.

Subproblemas: Matrícula de alumnos: Matricula Ingreso de calificaciones: Calificaciones Eliminar alumnos de listados: Eliminar Etc. Atributos: Nombres de alumnos: NomAlu Notas parciales de los alumnos: NP Notas finales de los alumnos: NF Nombres de asignaturas: NomA Nombres de profesores: NomP Etc. En el ejemplo anterior no se hizo una lista exhaustiva de los atributos y procesos ni se incluyeron hechos ya que no es la intención resolver el problema sino ejemplificar el concepto de subproblema; nótese que los procesos son los subproblema. 1.3. Programación orientada a objetos (POO) Cuando se resuelve un problema bajo este paradigma la tarea fundamental es identificar objetos. Un objeto se interpreta como un conjunto de propiedades, métodos y eventos que es capaz de responder a estímulos externos. Una vez identificados los objetos se establecen las relaciones entre ellos; estas relaciones usualmente son procesos. Ejemplo 1.3. El sistema para control de datos de alumnos en un colegio permite la matrícula de

alumnos, ingresar calificaciones y eliminar alumnos de los listados. Escribir un programa para este sistema.

Objetos: Alumnos: Alumno Un alumno tiene como atributos: Nombre, Edad, Sexo, Año académico, notas parciales por asignatura, etc

Asignaturas: Asignatura Una asignatura tiene como atributos: …

Profesores: Profesor Un profesor tiene como atributos: …

Etc. 1.4. Programación visual Un lenguaje visual es aquel cuyo método para crear la interfaz gráfica de usuario (GUI) consiste en la ubicación de los elementos de la interfaz agregando objetos prefabricados en su lugar dentro de la pantalla en lugar de escribir numerosas líneas de código para describir la apariencia. Debe quedar claro que la gran ventaja de los lenguajes visuales que el programador no invierte muchas horas en la construcción de la interfaz sino en aspectos de fondo de la aplicación como procesamiento de datos y funcionamiento. 1.5. Programación orientada a eventos En las aplicaciones tradicionales o "por procedimientos", la aplicación es la que controla qué partes de código y en qué secuencia se ejecutan. La ejecución comienza con la primera línea de código y continúa con una ruta predefinida a través de la aplicación, llamando a los procedimientos según se

4

necesiten. En una aplicación controlada por eventos, el código no sigue una ruta predeterminada; se ejecutan distintas secciones de código como respuesta a los eventos. Los eventos pueden desencadenarse por acciones del usuario, por mensajes del sistema o de otras aplicaciones, o incluso por la propia aplicación. La secuencia de estos eventos determina la secuencia en la que se ejecuta el código, por lo que la ruta a través del código de la aplicación es diferente cada vez que se ejecuta el programa. El código también puede desencadenar eventos durante la ejecución. Por ejemplo, cambiar mediante programación el texto de un cuadro de texto hace que se produzca el evento Change del cuadro de texto. Esto causaría la ejecución del código (si lo hay) contenido en el evento Change. Si se supone que este evento sólo se desencadenará mediante la interacción del usuario, podría verse resultados inesperados. Por esta razón es importante comprender el modelo controlado por eventos y tenerlo en cuenta cuando se diseña una aplicación. Independientemente del paradigma que se utilice exciten al menos tres elementos que son fundamentales en la programación: Los identificadores se utilizan para representar un elemento de la realidad ya sea hechos, atributos, procesos, objetos, entre otros. Los valores literales son aquellos valores específicos de un atributo o hecho el cual se expresa sin necesidad de un identificador. Por ejemplo,

Si se hace referencia al atributo “edad de una persona”, se puede utilizar la palabra Edad para identificar ese atributo. Luego para referirse a la edad de una persona en particular, digamos 23 años, se puede hacer a través del identificador o mediante el valor literal 23.

Los operadores se utilizan para producir o acceder a información. Generalmente actúan sobre identificadores y valores literales. Por ejemplo,

Si la edad de Ana es cinco años más que la de Sandra y la edad de Sandra está almacenada en el identificador Edad, entonces la edad de Ana es Edad+5

2. CARACTERÍSTICAS DE VISUAL BASIC 6 Visual Basic se encuentra disponible en tres versiones, cada una de las cuales está orientada a unos requisitos de programación específicos.

1. La Edición de Aprendizaje de Visual Basic permite a los programadores crear robustas aplicaciones para Microsoft Windows y Windows NT®. Incluye todos los controles intrínsecos, además de los controles de cuadrícula, de fichas y los controles enlazados a datos.

2. La Edición Profesional proporciona a los profesionales un conjunto completo de herramientas para desarrollar soluciones para terceros. Incluye todas las características de la Edición de Aprendizaje, así como controles ActiveX adicionales, el diseñador de aplicaciones para Internet Information Server y Visual Database Tools and Data.

3. La Edición Empresarial permite a los profesionales crear sólidas aplicaciones distribuidas en un entorno de equipo. Incluye todas las características de la Edición Profesional, así como herramientas de Back Office como SQL Server, Microsoft Transaction Server, Internet Information Server, Visual SourceSafe, SNA Server, etc.

Visual Basic es un lenguaje de desarrollo para Windows, por ello es necesario familiarizarse con el entorno Windows. El funcionamiento de Windows incluye tres conceptos clave: ventanas, eventos y mensajes. Una ventana es simplemente una región rectangular con sus propios límites. Existen varios tipos de ventanas pero todas ellas comparten algunas características y otras son propias: cuadro de diálogo, un botón de comando, los iconos, cuadros de texto, botones de opción y barras de menús entre otros. El sistema operativo Microsoft Windows administra todas estas ventanas asignando a cada una un único número identificador (controlador de ventana o hWnd). El sistema controla continuamente

5

cada una de estas ventanas para ver si existen signos de actividad o eventos. Los eventos pueden producirse mediante acciones del usuario, como hacer clic con el ratón o presionar una tecla, mediante programación o incluso como resultado de acciones de otras ventanas. Cada vez que se produce un evento se envía un mensaje al sistema operativo. El sistema procesa el mensaje y lo transmite a las demás ventanas. Entonces, cada ventana puede realizar la acción apropiada, basándose en sus propias instrucciones para tratar ese mensaje en particular. Todas las combinaciones posibles de ventanas, eventos y mensajes las controla automáticamente Visual Basic, mientras que otros se tratan como procedimientos de evento. Esto le permite crear rápidamente eficaces aplicaciones sin tener que tratar detalles innecesarios. El proceso de desarrollo de las aplicaciones tradicionales se puede dividir en tres etapas diferentes: escritura, compilación y comprobación del código. A diferencia de los lenguajes tradicionales, Visual Basic utiliza una aproximación interactiva para el desarrollo, de manera que no se distingue entre estos tres pasos. En la mayoría de los lenguajes, si comete un error al escribir el código, el compilador intercepta este error cuando comience a compilar la aplicación. Entonces el programador debe encontrar y corregir el error y comenzar de nuevo con el ciclo de compilación, repitiendo el proceso para cada error encontrado. Visual Basic interpreta el código a medida que lo escribe, interceptando y resaltando la mayoría de los errores de sintaxis en el momento. Es casi como tener un experto vigilando cómo escribe el código. Además, para interceptar errores sobre la marcha, Visual Basic también compila parcialmente el código según se escribe. Cuando el programador está preparado para ejecutar y probar la aplicación, tardará poco tiempo en terminar la compilación. Si el compilador encuentra un error, quedará resaltado en el código. Se puede corregir el error y seguir compilando sin tener que comenzar de nuevo. RESUMEN Cuando se desea resolver un problema mediante un algoritmo (o un programa) es necesario establecer bajo que paradigma de programación se trabajará. El paradigma determinará la metodología a utilizar. Visual Basic 6 es un lenguaje de programación que responde a varios paradigmas: imperativo, modular, orientado a objetos, visual y orientado a eventos. Independientemente de los paradigmas aquí mencionados existen tres elementos que son de suma importancia al momento de construir programas, ellos son los atributos, los hechos y los procesos. Con estos elementos básicos se construyen el resto de elementos que conforman una aplicación. El compilador de Visual Basic proporciona al programador la ventaja de que compila según se va escribiendo el código. Así, el programador cuenta con un “asistente” que le indica en cada momento se ha cometido un error de sintaxis o no en lugar de esperar hasta terminar todo el código. Por otra parte, ya que algunos errores no se detectan en tiempo de diseño, Visual Basic conserva una memoria de las líneas de código que compilaron hasta el momento de error. Así, cuando el programador corrige el error Visual Basic puede compilar más rápidamente la aplicación pues inicia en el punto donde dejó de compilar. EJERCICIOS

1. Investigar acerca de otros paradigmas de programación. 2. Investigar acerca de los diferentes lenguajes según los paradigmas de programación.

EVALUACIÓN Presentar un breve ensayo, de al menos una página tamaño carta, tipo de letra NewRoman de 11, acerca de los temas investigados en los dos ejercicios anteriores.

6

UNIDAD II. ENTORNO DE DESARROLLO INTEGRADO CONTENIDO

1. Definición de Entorno de Desarrollo Integrado. 2. Elementos del Entorno de Desarrollo Integrado. 3. Estructura de una aplicación.


1. Definir Entorno de Desarrollo Integrado. 2. Identificar los elementos del Entorno de Desarrollo Integrado. 3. Comprender la importancia del Entorno de Desarrollo Integrado para el desarrollo de

aplicaciones. 4. Conocer la estructura de una aplicación.

1. INICIAR VISUAL BASIC En una instalación típica de Visual Basic en Windows XP la manera para iniciar el programa es la siguiente:

1. Hacer clic en Inicio en la barra de tareas de Windows. 2. Seleccionar Todos los Programas, Microsoft Visual Studio 6.0 y luego Microsoft Visual

Basic 6.0.

Figura 2.1. Iniciar Visual Basic

O bien, si no está instalado Visual Studio completamente: Haga doble clic en el icono de Microsoft Visual Basic 6.0.

También se puede crear un acceso directo a Visual Basic en el escritorio y hacer doble clic en él. Cuando se inicia el Visual Basic 6 aparece una pantalla como la Figura 2.2. La ventana que aparece en el centro de la pantalla, Nuevo Proyecto, es un menú que permite seleccionar el tipo de aplicación que se desea desarrollar. Si bien es cierto que en Visual Basic se pueden desarrollar diversos tipos de aplicaciones, en este manual sólo se estudiará cómo escribir aplicaciones EXE Standard.

7

FIGURA 2.2. Pantalla inicial de Visual Basic 6.

2. ELEMENTOS DEL ENTORNO DE DESARROLLO INTEGRADO Un Entorno de Desarrollo Integrado (IDE) es un conjunto de herramientas integradas que permite el desarrollo de aplicaciones en un solo entorno. Las herramientas típicas en un IDE don el compilador (elemento no visible), el editor de texto para la escritura del código fuente y el depurador entre otros. Si se selecciona la opción Exe Estándar aparece la ventana de la Figura 2 en el cual se pueden visualizar algunos de los elementos del IDE. Los elementos de esta ventana son: 2.1. El menú principal Presenta los comandos que se usan para trabajar con Visual Basic. Además de los menús estándar Archivo, Edición, Ver, Ventana y Ayuda, se proporcionan otros menús para tener acceso a funciones específicas de programación como Proyecto, Formato o Depuración. 2.2. La barra de herramientas Proporcionan un rápido acceso a los comandos usados normalmente en el entorno de programación. De forma predeterminada, al iniciar Visual Basic se presenta la barra de herramientas Estándar. Es posible activar o desactivar otras barras de herramientas adicionales para modificar, diseñar formularios desde el comando Barras de herramientas del menú Ver. Las barras de herramientas se pueden acoplar debajo de la barra de menús o pueden "flotar" si se selecciona la barra vertical del borde izquierdo y la arrastra fuera de la barra de menús. 2.3. Área de diseño de formulario Funciona como una ventana en la que se personaliza el diseño de la interfaz de su aplicación. Allí se agregue controles, gráficos e imágenes a un formulario para crear la apariencia que se desea. Cada formulario de la aplicación tiene su propia ventana diseñador de formulario. 2.4. El explorador Proyectos Enumera los formularios y módulos del proyecto actual. Un proyecto es la colección de archivos que usa para generar una aplicación. Mediante el explorador es fácil pasar de un formulario a otra cuando la aplicación consta de más de uno.

8

FIGURA 2.3. Pantalla de trabajo para aplicaciones Exe Estándar. 2.5. La ventana Propiedades Enumera los valores de las propiedades del control o formulario seleccionado. Una propiedad es una característica de un objeto, como su tamaño, título o color. Muchas propiedades de un objeto pueden ser modificadas mientras se escribe la aplicación o mientras se ejecuta

Figura 2.4. Elementos de la ventana Propiedades

Barra de componentes

Barra de herramientas

Menú Principal

Ventana de propiedades

Posición del formulario

Explorador de proyectos

Área de diseño de Formulario

Lista desplegable de propiedades en el

formulario

Lista de propiedades del objeto

seleccionado

Cuadro de explicación de la propiedad seleccionada

Clasificación de las propiedades

Barra de desplazamiento

9

Las propiedades están clasificadas por orden alfabético y por categorías. Dependiendo de su experiencia usted decidirá trabajar con una u otra clasificación. Al lado izquierdo aparece el nombre de la propiedad y el lado derecho aparece el valor de la propiedad, por ejemplo, en la figura anterior la propiedad Caption tiene el valor Form1. Con la barra de desplazamiento se puede desplazar para buscar el resto de propiedades del objeto seleccionado. 2.6. La ventana posición del formulario La ventana Posición del formulario permite colocar los formularios de su aplicación utilizando una pequeña representación gráfica de la pantalla. Esto es útil porque muestra la posición que tendrá la pantalla de la aplicación cuándo ésta se ejecute. 2.7. La barra de componentes Proporciona un conjunto de herramientas que puede usar durante el diseño para colocar controles en un formulario. Además del diseño del cuadro de herramientas predeterminado, puede crear su propio diseño personalizado si selecciona Agregar ficha en el menú contextual y agrega controles a la ficha resultante. A continuación se describen los componentes de la barra de componentes:

FIGURA 2.5. Elementos de la barra de componentes.

2.8. Manipulación de componentes para crear objetos Para colocar elementos (objetos) de la barra de componentes en el formulario se procede de una de las siguientes formas:

1. Pulsar doble clic sobre el elemento, en este caso el elemento insertado aparecerá justo en el centro del formulario con un tamaño predeterminado. Si se desea a continuación se puede arrastrar el objeto y cambiar sus dimensiones.

2. Pulsar clic sobre el elemento y luego ubicar el puntero de ratón en la posición donde se desea que aparezca el elemento, a continuación se presiona el botón izquierdo del ratón y

Caja de imagen

Caja de texto

Botón de comando

Botón de opción

Caja de lista

Barra de desplazamiento vertical

Lista de unidades de disco

Lista de ficheros

Línea

Datos

Puntero

Etiqueta

Marco

Casilla de verificación

Lista desplegable

Temporizador

Barra de desplazamiento vertical

Lista de direcciones

Figuras

Imagen

Ole

10

se arrastra el puntero hasta obtener el tamaño deseado del objeto que se está clocando en el formulario.

2.9. Editor de código Funciona como un editor de texto para escribir el código de la aplicación. Se crea una ventana editor de código diferente para cada formulario o módulo del código de la aplicación. Esta ventana si visualiza pulsando doble clic sobre el formulario. Desde la lista desplegable de objetos se puede seleccionar el objeto para el cual se desea escribir o modificar código. Desde la lista desplegable de eventos de objeto se puede seleccionar el evento para el cual se ha de escribir el código.

2.10. Ventanas Inmediato, Locales e Inspección Estas ventanas adicionales se proporcionan para la depuración de la aplicación. Sólo están disponibles cuando ejecuta la aplicación dentro del IDE. Ejemplo 2.1. Inicie correctamente Visual Basic identifique cada uno de los elementos mencionados. Si acerca el puntero del ratón a un elemento del IDE aparecerá un indicador del nombre del elemento. Además, realice las siguientes actividades.

1. En la barra de herramientas identifique el elemento Examinador de objetos 2. Pulse clic sobre Form1 para seleccionarlo como objeto actual. En la ventana de propiedades

identifique la propiedad Font. 3. Pulse doble clic sobre Form1 y aparecerá el editor de código. 4. Utilizando la lista desplegable de eventos de objeto en el formulario selecciona el evento

Activate; observe lo que ocurre en el área de edición de código. 5. Utilizando la lista desplegable de objetos en el formulario selecciona la sección General;

observe lo que ocurre en el área de edición de código. 6. En la ventana Explorador de proyectos pulse doble clic sobre Form1 (Form1) ¿Qué ocurre? 7. Cambie el tamaño de Form1 y observe lo que ocurre en la ventana posición del formulario.

El siguiente ejemplo ilustra algunos de los elementos que se han mencionado hasta el momento. Ejemplo 2.2. Colocar objetos en el formulario y manipular algunas propiedades. El objetivo es obtener el formulario siguiente:

Lista desplegable de objetos en el formulario

Lista desplegable de eventos de objeto en el

formulario

Ventana para edición de código

11

1. Colocar una etiqueta (Label) para mostrar el texto “Bienvenido” como título

a. Pulse doble clic sobre el componente Label (Etiqueta). b. En la ventana de propiedades busque la propiedad Caption. c. Pulse clic sobre el valor Form1 y cámbielo por Bienvenido. d. Para cambiar el tamaño de letra busque la propiedad Font. Al pulsar clic sobre el

valor de propiedad y aparecerá un cuadrito con tres puntos suspensivos , pulse clic sobre dicho cuadrito y aparecerá la ventana

e. En Estilo de fuente seleccione Negrita y en Tamaño seleccione 14, luego pulse clic

en Aceptar. Observe la etiqueta en el formulario y si no se logra ver todo el texto Bienvenido modifique su tamaño convenientemente.

f. Para cambiar el color de letra busque la propiedad ForeColor, luego pulse clic sobre el valor de la propiedad y aparecerá el cuadrito , pulse clic sobre él y aparecerá la ventana

12

g. Pulse clic sobre paleta y seleccione el color apropiado h. Cambie el nombre de la Etiqueta de Label1 por lTitulo. Para ello busque la propiedad

(Nombre) y cambie su valor por lTitulo. 2. Colocar un botón de comando (Command) con etiqueta Cerrar

a. Pulse doble clic sobre el componente CommandButton (Botón de comando) b. En la ventana de propiedades busque la propiedad Caption y cambie su valor por

Cerrar. c. Cambie el nombre del Botón de Command1 por cCerrar. Para ello busque la

propiedad (Nombre) y cambie su valor por cCerrar. 3. Guarde la aplicación en la carpeta de trabajo

a. Cree una subcarpeta con el nombre Ejemplos

b. Vuelva a Visual Basic y pulse clic en el botón Guardar grupo de proyectos . c. Guarde el formulario con el nombre Principal d. Guarde el proyecto con el nombre Suma e. Si aparece una ventana preguntando si ¿Desea agregar este proyecto a SourceSafe?

Pulse clic en No. f. Guarde el grupo con el nombre con que aparece Grupo1.

3. OPCIONES DE ENTORNO Visual Basic proporciona un alto grado de flexibilidad, permitiéndole configurar el entorno de trabajo que mejor se adapte a su propio estilo. Puede elegir entre una interfaz de documentos simple o múltiple, y puede ajustar el tamaño y la posición de varios elementos del Entorno de Desarrollo Integrado (IDE). Con el IDE de Visual Basic hay disponibles dos estilos diferentes: la interfaz de documento simple (SDI) o la interfaz de documentos múltiples (MDI). Con la opción SDI todas las ventanas del IDE se pueden mover libremente por cualquier lugar de la pantalla; siempre y cuando Visual Basic sea la aplicación actual, permanecerán encima de las demás aplicaciones. Con la opción MDI, todas las ventanas del IDE están contenidas en una única ventana primaria de tamaño ajustable. Para cambiar entre los modos SDI y MDI

1. En el menú Herramientas, seleccione Opciones. 2. Aparecerá el cuadro de diálogo Opciones. 3. Seleccione la ficha Avanzado. 4. Active o desactive la casilla de verificación Entorno de desarrollo SDI. 5. El IDE comenzará en el modo seleccionado la próxima vez que inicie Visual Basic.

Muchas de las ventanas del IDE se pueden acoplar o conectar a otra o al borde de la pantalla. Entre estas ventanas se incluyen el cuadro de herramientas, la ventana Posición del formulario, el

13

Explorador de proyectos, la ventana Propiedades, la Paleta de colores y las ventanas Inmediato, Locales e Inspección. Con la opción MDI las ventanas pueden acoplarse en cualquier lado de la ventana primaria, mientras que con SDI sólo se pueden acoplar debajo de la barra de menús. Las capacidades de acoplado se pueden activar o desactivar para una ventana dada si activa la casilla de verificación apropiada de la ficha Acople del cuadro de diálogo Opciones, disponible desde el comando Opciones del menú Herramientas. Para acoplar o desacoplar una ventana

1. Seleccione la ventana que desee acoplar o desacoplar. 2. Arrastre la ventana a la ubicación deseada manteniendo presionado el botón primario del

ratón. 3. El contorno de la ventana se mostrará al arrastrar la ventana. 4. Suelte el botón del ratón.

4. ESTRUCTURA DE UNA APLICACIÓN. Una aplicación tiene una estructura jerárquica definida por los elementos que la componen. Cada forma recibe el nombre de módulo. Cada módulo puede contener objetos y para cada objeto existe una sección. Cada sección puede contener uno o más procedimientos. De manera general la estructura se puede representar como:

FIGURA 2.6. Estructura de una aplicación

Por ejemplo, en la Figura x, una aplicación con una forma y un botón en la forma tiene: Un módulo y tres secciones

FIGURA 2.7. Estructura de una aplicación

Sección para el objeto Command1

Sección para el objeto Form

Sección General

Módulo

14

5. TIEMPO DE DISEÑO, TIEMPO DE EJECUCIÓN Y MODO DE INTERRUPCIÓN Para probar y depurar una aplicación necesita entender en cuál de los tres modos se encuentra en un momento dado. Visual Basic en tiempo de diseño se utiliza para crear una aplicación y en tiempo de ejecución para ejecutarla. Este capítulo presenta el modo de interrupción, que suspende la ejecución de un programa para que usted pueda examinar y modificar datos. Identificar el modo actual La barra de título de Visual Basic siempre muestra el modo actual. La figura 13.6 muestra la barra de título para el tiempo de diseño, el tiempo de ejecución y el modo de interrupción.

Figura 2.8. Identificación del modo actual con la barra de título de Visual Basic 5.1. Tiempo de diseño La mayor parte del trabajo de creación de una aplicación se realiza en tiempo de diseño. Se puede diseñar formularios, dibujar controles, escribir código y usar la ventana Propiedades para establecer o ver los valores de las propiedades. No puede usar herramientas de depuración, excepto para establecer los puntos de interrupción y crear expresiones de inspección. En el menú Ejecutar, elegir Iniciar o hacer clic en el botón Ejecutar o pulsar F5 en el teclado para cambiar a tiempo de ejecución. Si su aplicación contiene código que se ejecuta cuando la aplicación se inicia, elegir Paso a paso por instrucciones del menú Ejecutar (o presionar F8) para que la aplicación entre en modo de interrupción en la primera instrucción ejecutable. 5.2. Tiempo de ejecución Cuando una aplicación toma el control, el programador puede interactúa con la aplicación del mismo modo que lo haría un usuario. Además, se puede ver el código, pero no cambiarlo. En el menú Ejecutar, seleccionar Terminar o hacer clic en el botón Terminar para volver al tiempo de diseño.

Barra de título en tiempo de diseño

Barra de título en tiempo de ejecución

Barra de título en tiempo de interrupción

Botón Iniciar estará activo

Botón Iniciar estará inactivo, Interrumpir y Terminar estarán activos

Botón Iniciar y Terminar estarán activos, Interrumpir estará inactivo

15

5.3. Modo de interrupción En el menú Ejecutar, elegir Interrumpir, hacer clic en el botón Interrumpir o presionar Ctrl-Pausa para cambiar al modo de interrupción. La ejecución de la aplicación queda suspendida. Se puede ver y modificar código (elegir Código en el menú Ver o presionar F7), examinar o modificar datos, reiniciar la aplicación, terminar la ejecución o reanudarla desde el mismo punto. Se puede establecer puntos de interrupción y expresiones de inspección en tiempo de diseño, pero hay otras herramientas de depuración que sólo funcionan en modo de interrupción. Ver "Usar el modo de interrupción", más adelante en este mismo capítulo. Ejemplo 2.3. Si no se encuentra ejecutando Visual Basic, inícielo correctamente.

1. Pulse clic sobre el botón Iniciar (o presione F5) para ejecutar la aplicación actual. 2. Pulse clic sobre el botón Interrumpir ¿Qué ocurre?. 3. Pulse clic sobre el botón Terminar ¿Qué ocurre?.

6. OPERACIONES SOBRE APLICACIONES Una aplicación un es programa que realiza una tarea más o menos compleja. Una aplicación es un conjunto de proyectos o grupo. Cada proyecto a su vez es un conjunto de formularios (o módulos). También cada formulario es un conjunto de funciones y procedimientos, los cuales son pequeños programas que realizan tareas específicas. La sintaxis de de un procedimiento y una función son respectivamente:

<Ámbito> Sub <ip> (argumentos) <sentencias> End Sub

<Ámbito> Function <if> (argumentos) <As tipo> <sentencias> End Function

No se tratará el tema de funciones y procedimientos de manera amplia pero el lector debe conocer su estructura para comprender mejor los ejemplos desarrollados en este material. 6.1. Abrir un proyecto nuevo Para abrir un proyecto nuevo se procede de varias formas, sin embargo el lector debe recordar que aunque existen diversos tipos de proyectos aquí sólo se verán los de tipo Exe Estándar.

1. Una forma para abrir un proyecto es seleccionar Exe Estandar de la ventana inicial de Visual Basic.

2. Otra forma es pulsar clic en la flecha del botón , lo cual desplegará una ventana. Seleccione de esa ventana Exe Estándar.

Si ya cuenta con un proyecto abierto puede agregar otro proyecto a la aplicación siguiendo la instrucción 2. 6.2. Guardar una aplicación Como recordará una aplicación es un conjunto de proyectos que a su vez es un conjunto de módulos. Para guardar una aplicación completa se debe guardar cada módulo y cada proyecto. Los nombres que asigne a cada uno deben ser representativos del objetivo de cada uno de ellos. Para guardar una aplicación competa se procede varias formas:

16

1. Pulsar clic en el botón de la barra de herramientas. Entonces aparecerá la ventana Guardar archivo como:

Con esta ventana puede crear una nueva carpeta para guardar la aplicación o guardarla en la carpeta actual. Una vez seleccionada la carpeta actual y escrito el nombre del formulario debe pulsar clic en Guardar; nótese que la extensión de un formulario es frm. Después de pulsar Guardar aparecerá la ventana Guardar proyecto como:

Crear carpeta

Nombre del formulario

Carpeta actual

Extensión o tipo

17

Los elementos de esta ventana son los mismos que en la anterior pero en la sección Tipo aparece Proyecto (*.vbp); nótese que la extensión de un proyecto es vbp. Por omisión el poryecto se guarda en la misma carpeta que el formulario. Una vez asignado el nombre del proyecto pulse clic en Guardar. Si la aplicación consta de más de un proyecto aparecerá la ventana Guardar grupo de proyectos como:

Nótese que la extensión de un grupo de proyectos es vbg. Por omisión el grupo se guarda en la misma carpeta que los formularios y proyectos. Una vez asignado el nombre del grupo pulse clic en guardar. Una vez guardada la aplicación si realiza cambios en los diferentes elementos entonces al

pulsar el botón se guardarán dichos cambios pero no aparecerán las ventanas anteriores a menos que haya agregado formularios o proyectos a la aplicación. En algún momento del proceso de guardado es posible que aparezca la ventana siguiente, pulse clic en No.

2. Otra forma de guardar aplicaciones es seleccionar en el menú principal Archivo, Guardar

grupo de proyectos como y proceda según lo explicado en las líneas anteriores. Este mecanismo se utiliza también si desea almacenar la aplicación con otro nombre o en otro lugar.

6.2. Cerrar una aplicación Para cerrar una aplicación seleccione, en el menú principal, Archivo luego Quitar Proyecto. Debe repetir esta operación hasta que el Explorador de proyectos esté vacío. Si ha realizado cambios antes de que la aplicación se cierre le pedirá que guarde los cambios realizados:

18

Si dichos cambios no interesan pulse clic en No, de lo contrario pulse clic en Si. Si pulsa clic en Cancelar, entonces se cancelará la operación Quitar proyecto. 6.2. Abrir una aplicación existente Para abrir una aplicación existente puede proceder de dos formas.

1. En la barra de herramientas, pulse clic en el botón , aparecerá la ventana:

Usualmente la carpeta actual es la última que utilizó si no ha cerrado Visual Basic. Debe seleccionar la carpeta donde tiene almacenada la aplicación.

a. Si su aplicación es un grupo de proyectos pulse clic en el nombre del grupo y luego en Abrir. El icono de un grupo es .

19

b. Si su aplicación solo tiene un proyecto pulse clic en el nombre del proyecto y luego en Abrir. El icono de un proyecto es .

c. También puede abrir un formulario únicamente, pero si el formulario es único se abrirá también el proyecto. El icono de un formulario es .

Una vez abierta la aplicación para ver los formularios pulse doble clic en el formulario deseado en el Explorador de proyectos.

2. La otra forma para abrir una aplicación es a través del menú Archivo. Una vez seleccionada esta opción las instrucciones son las mismas que las descritas anteriormente.

7. EJECUTAR UNA APLICACIÓN En cuanto a la ejecución de una aplicación existen diferentes opciones, algunas de ellas son útiles para la depuración del código; no obstante, no se explicarán todas estas opciones. La forma de

ejecutar una aplicación es pulsando clic en el botón de la barra de herramientas. Si no existen errores de sintaxis la aplicación se ejecutará correctamente, de lo contrario aparecerá un mensaje de error

Si pulsa clic en Aceptar aparecerá un indicador del lugar donde se detectó el error

Desafortunadamente el error puede ser originado en otra sección del código. También puede seleccionar Ayuda en la ventana de error y se desplegará una ventana indicando las posibles fuentes de error.

Indicador de lugar donde se detecta el error

20

Si no existe ningún error de sintaxis entonces la aplicación se ejecutará. Para detener la ejecución basta pulsar clic en el botón cerrar de la ventana; dicho botón se encuentre en la esquina superior

derecha del formulario en ejecución. También puede pulsar clic en el botón de la barra de herramientas. RESUMEN El Entorno de Desarrollo Integrado de Visual Basic proporciona al programador de una serie de herramientas que facilitan la escritura de aplicaciones. De esta forma el programador se puede dedicar a pensar más en el funcionamiento de la aplicación que en aspectos de interfaz. Una aplicación en Visual Basic se puede ver como un conjunto de módulos cada uno de los cuales está dividido en secciones. Esto es importante comprenderlo al momento de definir los identificadores (lo cual se verá más adelante). EJERCICIOS

1. Al inicial Visual Basic aparece la ventana Nuevo Proyecto a. ¿Para que sirve la ficha Existente? b. ¿Para que sirve la ficha Recientes?

2. Cierre Visual Basic a. Inicie Visual Basic y pulse Cancelar en la Ventana de Nuevo proyecto b. Describa al menos dos formas para Abrir un Nuevo Proyecto Exe Estándar.

Sugerencia: Explore la Barra de Herramientas y el menú Proyecto. 3. Utilizando el menú Ayuda investigue la definición de ASCII 4. ¿En Cuál modo se encuentra actualmente el IDE de Visual Basic?

a. Interfaz de Documento Simple (SDI) b. Interfaz de Documentos Múltiples (MDI)

5. Utilizando el menú Ayuda ubique el manual de Visual Basic que viene incorporado. 6. ¿Cómo puede hacer para guardar un formulario únicamente? 7. Suponga que tiene una aplicación con un formulario y que ya ha guardado la aplicación

¿Cómo puede hacer para cambiar el nombre al formulario? 8. Describa los pasos para abrir una aplicación mediante el menú principal.

EVALUACIÓN La evaluación de esta unidad será en base a la participación activa. Se incentivará la curiosidad cautelosa al explorar las diferentes opciones del IDE de Visual Basic.

21

UNIDAD III. BREVE METODOLOGÍA DE PROGRAMACIÓN CONTENIDO

1. Creación de algoritmos. 2. Planificación de interfaz de usuario.


1. Aplicar una metodología para la construcción de algoritmos para el paradigma modular y Orientado a Objetos.

2. Aplicar una metodología para la creación de interfaz de usuario. 1. CREACIÓN DE ALGORITMOS Cuándo se va a desarrollar una aplicación buena parte del tiempo consiste en el diseño de la misma. Se debe planificar cada algoritmo que será codificado y la interfaz a utilizar. También se debe procurar planificar ambas cosas independientemente del lenguaje de programación pero en función de uno o más paradigmas de programación. Dado que VB responde a más de un paradigma de programación, existen varias fases en las que se debe construir algoritmos. La siguiente es una breve metodología para facilitar la construcción de aplicaciones.

1. Comprender el problema. 2. Identificar los subproblemas en que se puede dividir el problema 3. Identificar los elementos importantes. Estos pueden ser:

a. Objetos b. Relaciones entre objetos

4. Escribir un algoritmo general donde se establecen las relaciones entre subproblemas 5. Escribir un algoritmo para cada subproblema.

A continuación se presenta un resumen del lenguaje algorítmico de pseudocódigo y flujograma para la construcción de algoritmos mediante programación imperativa y modular.

Tabla 3.1. Símbolos para el lenguaje de pseudocódigo y flujograma Pseudocódigo Flujograma

Inicio (o fin)

Leer <iv1>, <iv2>, ..., <ivn>

<iv1>, <iv2>, ..., <ivn><iv1>, <iv2>, ..., <ivn>

Hacer <i1>←<e1> <i2>←<e2> ... <in>←<en>

<i1>=<e1>,<i2>=<e2>,

...<in>=<en>

<i1>=<e1>,<i2>=<e2>,

...<in>=<en>

22

Pseudocódigo Flujograma

Escribir <e1>, <e2>,... , <en>

<e1>, <e2>, ..., <en><e1>, <e2>, ..., <en>

<i>

Ejemplo 3.1. Se desea dividir dos números reales y mostrar el resultado. Objetos: Los operando: A y B

Un operando tiene dos propiedades: Etiqueta y Campo de información La suma: S

Un operando tiene dos propiedades: Etiqueta y Campo de información Relaciones: La relación entre los operando y la suma es el operador: S=A+B Algoritmo Inicio Repetir Leer A y B Si (Clic en Sumar) Entonces Hacer S←A+B Sino Si (Clic en Limpiar) Entonces Hacer A←’’, B←’’ Hasta_que (Clic en Salir) Fin Dado que este es un curso introductorio a Visual Basic 6 no se profundizará en la POO, más bien se presentarán algunas ideas intuitivas para el desarrollo de aplicaciones. Por ello, no se declararán objetos, más bien se utilizarán los objetos existentes para construir los necesarios para las aplicaciones. 2. PLANIFICACIÓN DE INTERFAZ DE USUARIO Para crear una interfaz de usuario es necesario haber creado el algoritmo. Luego se planifican las diferentes pantallas que se mostraran al usuario al realizar ciertas acciones. Ejemplo 3.2. Interfaz para el Ejemplo 3.1. Al ejecutar la aplicación aparecerá la ventana:

23

Al pulsar clic en Sumar se efectuar la suma de la celda bajo A y B y se mostrará en la celda bajo S. Al pulsar clic en Limpiar se borrarán los números de de las celdas bajo A, B y C. Al pulsar Salir se cerrará la ventana. Si al pulsar Sumar no hay valores en las celdas bajo A o B entonces aparecerá otra ventana

Faltan datos numéricos, revise el contenido de las celdas bajo A o B

Cerrar

Al pulsar clic en Cerrar esta ventana se cerrará y quedará la anterior tal y como estaba anteriormente. Algunas aplicaciones son más complejas y requieren de más de una ventana. El siguiente ejemplo ilustra este hecho. Ejemplo 3.3. El registro de estudiantes de un instituto de educación media requiere de las

siguientes operaciones. 1. Ingresar nuevos estudiantes 2. Eliminar estudiantes 3. Ingresar notas de los estudiantes por cada bimestre 4. Emitir un reporte de calificaciones para cada estudiante. 5. Actualizar o corregir datos de estudiantes

Para realizar estas tareas el sistema cuenta con un sistema de base de datos relacional con los siguientes archivos:

1. Alumnos 2. Curso 3. Asignatura 4. Profesor

Para escribir una aplicación que simule este sistema es necesario segmentar el problema en subproblemas. Aquí son evidentes los siguientes:

1. Agregar 2. Eliminar 3. Notas 4. Reporte 5. Actualizar

Estas operaciones requieren un algoritmo de búsqueda por lo que se agrega el subproblema: 6. Buscar

Un detalle sumamente importante al planificar la interfaz de una aplicación es el principio “Menos es mas”. Lo cual significa que cuánto menos detalles innecesarios se incorporen a la interfaz más productiva y atractiva será la aplicación. No es conveniente utilizar toda la gama de colores o recargar una ventana con información. Cada ventana debe contener la información necesaria para que el usuario se sienta cómodo y sea productivo. La interfaz debe permitir que el usuario utilice el tiempo mínimo para realizar una actividad.

24

RESUMEN Cuándo se va a desarrollar una aplicación buena parte del tiempo consiste en el diseño de la misma. Se debe planificar cada algoritmo que será codificado. También se debe planificar cada sección de interfaz de manera que permita realizar una tarea en el mínimo tiempo posible. La planificación de los algoritmos y de la interfaz depende de los paradigmas a que responde la aplicación. En general esto se planifica independientemente del lenguaje de programación. EJERCICIOS

1. Para el Ejemplo 3.3 escriba en papel un boceto de la interfaz que podría presentarse al desarrollar la aplicación.

2. Escriba un algoritmo para calcular el interés simple para un capital C prestado para un tiempo T con una taza de interés de R. Luego diseñe una interfaz para la aplicación que calcula en monto de interés.

EVALUACIÓN Para esta unidad se evaluarán los Ejercicios propuestos. Se discutirán las soluciones plateadas y se retroalimentará a fin de consolidar lo aprendido.

25

UNIDAD IV. IDENTIFICADORES, TIPOS DE DATOS, EXPRESIONES Y SENTENCIAS BÁSICAS CONTENIDO

1. Tipos de datos definidos en Visual Basic 6. 2. Declaración de identificadores. 3. Construcción y clasificación de expresiones. 4. Tipo de sentencias definidas en Visual Basic.


1. Identificar los tipos de datos definidos en Visual Basic 6. 2. Definir identificadores necesarios para una aplicación. 3. Construir expresiones para la construcción de aplicaciones. 4. Identificar los diferentes tipos de sentencias básicas.

1. TIPOS DE DATOS Un tipo de dato en un lenguaje de programación define un conjunto y operaciones sobre él. Un elemento pertenece a dicho conjunto si cumple con las características del tipo de dato. Una de esas características es cómo se almacenan los bits que representan esos valores en la memoria de la computadora. Uno de los usos más frecuentes de los tipos de datos es la declaración de variables. Cuando se declara una variable también puede proporcionar un tipo de dato. Todas las variables tienen un tipo de dato que determina la clase de datos que pueden almacenar. De forma predeterminada, si no proporciona un tipo de dato, la variable toma el tipo de dato Variant, este se explicará más adelante. Los tipos de datos se aplican a otras cosas además de a las variables. Cuando asigna un valor a una propiedad, dicho valor tiene un tipo de dato; los argumentos de las funciones tienen también tipos de datos. De hecho, todo lo relacionado con datos en Visual Basic tiene un tipo de dato. Visual Basic proporciona varios tipos de datos:

Tabla 4.1 Tipos de datos definidos en Visual Basic

Tipo Descripción Carácter

para declaración

Rango

Integer Long Single Double Currency

Entero Entero largo Punto flotante Punto flotante Punto decimal fijo

% & ! # @

-32768 a 32767 -2147483648 a -2147483647 -3.49 E+38 a 3.49 E+38 -1.78 E+308 a -1.78 E+308 ±922337203685477.5807

String Byte

Cadena de caracteres Carácter

$

231 caracteres 0 a 255

Boolean Date Object Variant Decimal

Lógico Fecha/Hora Referencia a un objeto Tipo variable Números con 0 a 28 decimales Este tipo no se puede declarar directamente como decimal, debe ser declarado como tipo Variant

False o True 1/Enero/100 a 31/Diciembre/9999 Cualquier referencia a tipo Object Almacena datos de cualquier tipo de los anteriores Con 0 decimales: ±79,228,162,514,264,337,593,543,950,335Con 28 decimales: ±7,9228162514264337593543950335 ±0,0000000000000000000000000001

26

Aunque el tipo Variant acepta datos de cualquier otro tipo usar un tipo de dato numérico emplea normalmente menos espacio de almacenamiento que un tipo Variant. Visual Basic proporciona varias funciones de conversión que puede usar para convertir valores en tipos de datos específicos. Por ejemplo, para convertir un valor a Currency, utilice la función CCur: PagoPorSemana = CCur(horas * PagoPorHora)

Tabla 4.2 Funciones de conversión entre tipos de datos Funciones de conversión

Convierten una expresión en

Cbool Boolean Cbyte Byte Ccur Currency Cdate Date CDbl Double Cint Integer

CLng Long CSng Single CStr String Cvar Variant

CVErr Error 2. DECLARACIÓN DE IDENTIFICADORES Un identificador es una palabra que se utiliza para representar algo. En POO este algo puede ser un objeto, un proceso, un atributo o un hecho. Algunos identificadores tienen memoria asociada en la cual es posible almacenar información, ejemplos de ellos son las variables y constantes. Un identificador debe cumplir los siguientes requisitos:

• Debe comenzar con una letra. • No puede incluir un punto o un carácter de declaración de tipo. • No debe exceder de 255 caracteres. • Debe ser único en el mismo alcance o ámbito, que es el intervalo desde el que se puede

hacer referencia a la variable: un procedimiento, formulario, etc. 2.1. Variables Una variable es un identificador que almacena información de manera variable durante la ejecución de un programa, es decir la información no necesariamente permanece constante en dicha variable en el transcurso de la ejecución de la aplicación. Al declarar una variable se sigue el siguiente formato:

<Ámbito> <iv> As <tipo> donde <Ámbito> puede ser: Public, Dim, Private, Static. As <tipo> declara el tipo de dato que acepta <iv>. Esta parte puede ser omitida en una declaración, en este caso también se omite el <Ámbito>. Para almacenar valores durante la ejecución de una aplicación se utilizan variables. Al definir una variable se debe especificar el identificador o nombre y el tipo de dato que almacena la variable. El siguiente diagrama de ámbitos ilustra el alcance de una variable en relación al ámbito

27

Public

Dim o Private

Dim o Static

Ámbito 1

Ámbito 2

Ámbito 3

FIGURA 4.1. Diagrama de ámbitos de una aplicación El diagrama muestra como se divide la aplicación en ámbitos en relación a los subprogramas que contiene. Al ámbito 1 se refiere a toda la aplicación, es decir, una variable Public puede ser utilizada en cualquier parte del Módulo, Dim y Private en una sección y Dim y Static en un procedimiento. Si la variable a declarar es de tipo Variant entonces se omite As <tipo> en la sintaxis de declaración. Ejemplo 4.1. Declaración de variables

Private I As Integer Dim Cantidad As Double Static SuNombre As String Public PagadoPorJuan As Currency Private H As Integer, Amt As Double Private Nombre As String, Pagado As Currency Private Prueba, Cantidad, J As Integer

En el ejemplo anterior note que Prueba y Cantidad son variables de tipo Variant pues no se especificó un tipo de dato para ellas. 2.1.1. Ámbito de las variables Las variables que se declaran en un procedimiento mediante la instrucción Dim sólo existen mientras se ejecuta el procedimiento. Cuando termina el procedimiento, desaparece el valor de la variable. Además, el valor de una variable en un procedimiento es local a dicho procedimiento; es decir, no puede tener acceso a una variable de un procedimiento desde otro procedimiento. Estas características le permiten usar los mismos nombres de variables en distintos procedimientos sin preocuparse por posibles conflictos o modificaciones accidentales. Declarar una variable en la sección declaraciones (General) de un módulo de formulario, estándar o de clase, en vez de en un procedimiento, hace que la variable esté disponible para todos los procedimientos del módulo. Declarar una variable mediante la palabra clave Public hace que esté accesible para toda la aplicación. Declarar una variable local mediante la palabra clave Static preserva su valor aunque termine el procedimiento. 2.1.2. Declaración implícita Contrario a otros lenguajes de programación en Visual Basic no se tiene por qué declarar una variable antes de usarla. Esto puede resultar ventajoso el momento de desarrollar una aplicación pero también puede ser peligroso para un programador inexperto. Las siguientes sentencias son válidas aun sinde clarar las variables:

TempVal = Abs(num)

28

SafeSqr = Sqr(TempVal) Visual Basic crea automáticamente una variable con ese nombre, la cual se puede usar como si la hubiera declarado explícitamente. Aunque es cómodo, puede provocar errores sutiles en el código si se equivoca de nombre de variable. 2.1.3. Declaración explícita Para evitar problemas al equivocarse de nombre en las variables, puede estipular que Visual Basic le avise siempre que encuentre un nombre que no se haya declarado explícitamente como una variable. Para declarar variables de forma explícita se incluye esta instrucción en la sección General del módulo de clase, de formulario o estándar:

Option Explicit o bien en el menú Herramientas, elija Opciones, haga clic en la ficha Editor y active la opción Requerir declaración de variables. Esto inserta automáticamente la instrucción Option Explicit en los módulos nuevos, pero no en los ya creados, por lo que tendrá que agregar manualmente Option Explicit a los módulos existentes en el proyecto.

Si no se declara apropiadamente una variable aparecerá

Indicando la variable que no ha sido definida Al activar Requerir declaración de variables deberá reiniciar Visual Basic para que tenga efecto.

Marcar aquí para que exija siempre declaración explícita de variables

29

Ejemplo 4.2.

1. Inicie Visual Basic si no está ejecutándose 2. Pulse doble clic sobre Form1 3. Escriba el código necesario para ver lo siguiente en el editor

Private Sub Form_Load() A = 3 End Sub

4. Ejecute la aplicación (pulsando F5 o )

5. Detenga la ejecución de la aplicación pulsando . 6. Active Requerir declaración de variables 7. Cierre Visual Basic sin guardar la aplicación 8. Inicie nuevamente Visual Basic 9. Pulse doble clic sobre Form1 10. Escriba el código necesario para ver lo siguiente en el editor

Private Sub Form_Load() A = 3 End Sub

11. Ejecute la aplicación. 12. ¿Qué ocurre? 13. Corrija el código de manera que se lea como:

Private Sub Form_Load() Dim A A=3 End Sub

14. Ejecute la aplicación 15. ¿Qué ocurre? 16. Desactive Requerir declaración de variables 17. Cierre Visual Basic 18. Inicie nuevamente Visual Basic 19. Pulse doble clic sobre Form1 20. Escriba el código necesario para ver lo siguiente en el editor

Private Sub Form_Load() a = 3 End Sub

21. Ejecute la aplicación. 22. ¿Qué ocurre? 23. Seleccione de Lista desplegable de objetos en el formulario la sección (General) 24. Escriba Option Explicit en la sección (General) 25. Ejecute la aplicación. 26. ¿Qué ocurre?

La instrucción Option Explicit funciona sobre módulo a módulo; debe colocarse en la sección Declaraciones de todos los módulos de formulario, estándar o de clase en los que desee que Visual Basic obligue a declarar explícitamente las variables. Si activa Requerir declaración de variables, Visual Basic insertará Option Explicit en todos los módulos de formulario, estándares o de clase siguientes, pero no lo agregará en el código existente. Deberá agregar manualmente Option Explicit a los módulos ya existentes en el proyecto.

30

2.1.4. Descripción del alcance de las variables El alcance de una variable define qué partes del código son conscientes de su existencia. Cuando declara una variable en un procedimiento, sólo el código de dicho procedimiento puede tener acceso o modificar el valor de la variable; tiene un alcance que es local al procedimiento. A veces, sin embargo, se necesita usar una variable con un alcance más general, como aquella cuyo valor está disponible para todos los procedimientos del mismo módulo o incluso para todos los procedimientos de toda la aplicación. Visual Basic le permite especificar el alcance de una variable cuando la declara. Dependiendo de cómo se declara, una variable tiene como alcance un procedimiento (local) o un módulo.

Alcance Privado Público Nivel de procedimiento

Las variables son privadas del procedimiento en el que aparecen.

No es aplicable. No puede declarar variables públicas dentro de un procedimiento.

Nivel de módulo Las variables son privadas del módulo en el que aparecen.

Las variables están disponibles para todos los módulos.

Las variables a nivel de procedimiento sólo se reconocen en el procedimiento en el que se han declarado. Se las conoce también como variables locales. Se declaran mediante las palabras clave Dim o Static. Por ejemplo:

Dim Temp As Integer Static Permanent As Integer

Los valores de variables locales declaradas con Static existen mientras se ejecuta la aplicación, mientras que las variables declaradas con Dim sólo existen mientras se ejecuta el procedimiento. Las variables locales resultan una elección apropiada para cálculos temporales. Por ejemplo, puede crear varios procedimientos distintos que contengan una variable llamada Temp. Como cada Temp se ha declarado como una variable local, cada procedimiento sólo reconoce su propia versión de Temp. Cualquier procedimiento puede alterar el valor de Temp local sin que ello afecte a las variables Temp de los demás procedimientos. Ejemplo 4.3. Declaración de variables

1. Inicie Visual Basic y seleccione Exe Estándar 2. Pulse doble clic en el botón CommandButton de la barra de controles. 3. Pulse doble clic en el botón Label de la barra de controles 4. Mueva los objetos para obtener la siguiente ventana:

5. Pulse doble clic sobre el formulario y seleccione la sección General y escriba el siguiente

código: Function Suma(A, B As Single) As Single

31

Suma=A+B End Function

6. Pulse doble clic en el botón Command1 y escriba el siguiente código: Private Sub Command1_Click() Dim X, Y As Single X = 3 Y = 11 Label1.Caption = CStr(Suma(X, Y)) End Sub

7. Ejecute la aplicación y observe lo que ocurre al pulsar clic en el botón Command1 8. Detenga ejecución de la aplicación 9. Pulse doble clic en el botón Command1 y cambie las variables X y Y por A y B en

Command1_Click, el código debe quedar así: Private Sub Command1_Click() Dim A, B As Single A = 3 B = 11 Label1.Caption = CStr(Suma(A, B)) End Sub

10. Ejecute nuevamente la aplicación. Nota algo diferente En este último caso A y B aparecen definidas en la función Suma, como parámetros (variables locales) y en el evento Command1_Click, como variables locales. Entonces A y B en Suma son diferentes a A y B en Command1_Click. No obstante, como A y B son argumentos en la sentencia de llamada:

Suma(A, B)) entonces el contenido de A y B de Command1_Click es transferido a A y B de la función Suma.

De forma predeterminada, una variable a nivel de módulo está disponible para todos los procedimientos del módulo, pero no para el código de otros módulos. Cree variables a nivel de módulo declarándolas con la palabra clave Private en la sección Declaraciones al principio del módulo (General). Por ejemplo:

Private Temp As Integer A nivel de módulo, no hay diferencia entre Private y Dim, pero es preferible Private porque contrasta con Public y hace que el código sea más fácil de comprender. Para hacer que una variable a nivel de módulo esté disponible para otros módulos, utilice la palabra clave Public para declarar la variable. Los valores de las variables públicas están disponibles para todos los procedimientos de la aplicación. Al igual que todas las variables a nivel de módulo, las variables públicas se declaran en la sección Declaraciones al principio del módulo (General). Por ejemplo:

Public Temp As Integer No se puede declarar variables públicas en un procedimiento, sólo en la sección Declaraciones de un módulo. 2.1.5. Variables estáticas Además de un alcance, las variables tienen un tiempo de vida, el periodo de tiempo durante el cual mantienen su valor. Se preservan los valores de las variables a nivel de módulo y públicas durante el tiempo de duración de la aplicación. Sin embargo, las variables locales declaradas con Dim sólo

32

existen mientras se ejecuta el procedimiento en el cual se han declarado. Normalmente, cuando termina la ejecución de un procedimiento, no se conservan los valores de sus variables locales y se reclama la memoria utilizada por las variables locales. La próxima vez que se ejecute el procedimiento se reinicializarán todas sus variables locales. Sin embargo, puede preservar el valor de una variable local si hace que la variable sea estática. Para hacer que todas las variables locales de un procedimiento sean estáticas, incluya la palabra clave Static al principio del encabezado del procedimiento. Por ejemplo:

Static Function Total(Vent) Esto hace que todas las variables del procedimiento sean estáticas sin tener en cuenta si se declararon con Static, Dim, Private o de forma implícita. Puede colocar Static delante de cualquier encabezado de procedimientos Sub o Function, incluyendo los procedimientos de eventos y aquellos que se declararon como Private. 2.2. Constantes A menudo existen en el código contiene valores constantes que reaparecen una y otra vez, o puede que el código dependa de ciertos números que resulten difíciles de recordar (números que, por sí mismos, no tienen un significado obvio). En estos casos se puede mejorar mucho la legibilidad del código y facilitar su mantenimiento si se utiliza constantes. Una constante es un identificador significativo que sustituye a un número o una cadena que no varía (constantes literales). Aunque una constante recuerda ligeramente a una variable, no puede modificar una constante o asignarle un valor nuevo como ocurre con una variable. 2.2.1. Crear constantes propias La sintaxis para declarar una constante es la siguiente:

<Ámbito> Const <ic> As <tipo>=<expresión> donde <Ámbito> puede se: Public o Private. <ic> es el identificador de constante. As <tipo> declara el tipo de dato que acepta <iv>. Esta parte puede ser omitida en una declaración. <expresión> determina el valor que toma la constante. Ejemplo 4.4. Declaración de constantes

Const cPi = 3.14159265358979 Public Const cMaxPlanetas As Integer = 9

Una vez que defina las constantes, puede colocarlas en el código para hacerlo más legible. Por ejemplo:

Static SistemaSolar(1 To conMaxPlanetas) If numPersonas > conPopMundial Then Exit Sub

Una instrucción Const tiene igual alcance que una declaración de variable y se le aplican las mismas reglas:

• Para crear una constante que sólo exista en un procedimiento, declárela dentro del procedimiento.

• Para crear una constante disponible para todos los procedimientos de un módulo, pero no para el código que está fuera del módulo, declárela en la sección Declaraciones del módulo.

• Para crear una constante disponible en toda la aplicación, declare la constante en la sección Declaraciones de un módulo estándar y coloque delante de Const la palabra clave Public. No se pueden declarar las constantes públicas en un módulo de clase o de formulario.

33

3. EXPRESIONES Una expresión es la operación válida entre identificadores y valores literales. Existe una gran variedad de operadores: aritméticos, de cadena, relacionales, lógicos, para conversión entre tipos de datos, sobre arreglos, sobre objetos, entre otros. Los operadores son importantes porque permiten producir y tener acceso a información. Algunos de los operadores más importantes utilizados en este material son:

Tabla 4.3 Operaciones de Visual Basic Tipo Operación Operador Aritmético Potencia

Multiplicación División Suma Resta

^ * / + -

Relacional Igual Distinto Menor Mayor Menor o igual Mayor o igual

= <> < > <= >=

Lógico Negación Conjunción Disyunción inclusiva

Not And Or

Cadena de caracteres Concatenación & Visual Basic cuenta además con una serie de funciones que permiten manipular cadenas de caracteres.

Tabla 4.4. Funciones sobre cadenas de caracteres Función Descripción

Len(iv) Número de caracteres de una cadena LCase(x), UCase(x) Conversión a minúsculas o a mayúsculas Str(n), CStr(n),Val(string) Conversión de cadenas a números y de

números a cadenas Mid(string, ini[, n]), Right(string, length), Left(string, length)

Extracción de un nº de caracteres en un rango, de la parte derecha o izquierda de una cadena el parámetro n de Mid es opcional e indica el número de caracteres a extraer a partir de "ini"

Split(string, [[delim], n]) Extracción de sub-cadenas devuelve un array con las n (-1 para todas) subcadenas separadas por delim (por defecto, el espacio)

Join(string, [delim]) Unión de sub-cadenas strComp(str1, str2) Comparación de cadenas de caracteres

devuelve -1, 0, 1 según str1 sea menor, igual o mayor que str2

34

Función Descripción InStr([n], str1, str2) Hallar si una cadena es parte de otra

(está contenida como sub-cadena) devuelve la posición de str2 en str1 buscando a partir del carácter n

InstrRev(str1, str2, [n]) Hallar una cadena en otra a partir del final (reverse order) devuelve la posición de str2 en str1 buscando a partir del carácter n

Replace(string, substring, replacewith)

Buscar y reemplazar una subcadena por otra en una cadena reemplaza substring por replacewith

Visual Basic también cuanta con funciones sobre tipos de datos numéricos

Tabla 4.5. Funciones sobre tipos de datos numéricos Función Descripción

Abs(x) Valor absoluto Log(x) Logaritmo Exp(x) Exponencial Rnd Nº aleatorio Sgn(x) Signo (1, 0, -1) Round(x, ndec) Redondeo Int(x), Fix(x) Parte entera Sqr(x) Raíz cuadrada Sin(x), Cos(x) Seno y coseno Tan(x) Tangente Atn(x) Arco tangente

4. SENTENCIAS DE ENTRADA, ASIGNACIÓN, SALIDA Y DE LLAMADA La estructura básica de un algoritmo consiste de un mecanismo para capturar datos provenientes de un entorno, un mecanismo para procesar esos datos y un mecanismo para devolver información al entrono. Visial Basic cuenta con más de una sentencia que permite realizar estas tareas. Una sentencia es una instrucción que indica que la aplicación debe realizar algo. Las sentencias más básicas en una aplicación son las de entrada, las de proceso y las de salida. 4.1. Sentencia de entrada Las sentencias de entrada permiten que la aplicación capture datos desde el entorno. La fuente de datos en el entorno puede ser un usuario o un archivo de datos, entre otros. En el caso de que el usuario proporcione datos a la aplicación usualmente lo hace mediante el teclado o el ratón. Algunos componentes típicos para esto son los Caja de texto, Botón de opción (OptionBox) y Casilla de verificación (CheckBox). Se tratará con más detalle la Caja de texto (TextBox) porque permite al usuario ingresar a la aplicación datos de diversos tipos. Cuando el usuario ingresa datos mediante una Caja de texto lo que hace es modificar la propiedad Text, la cual, como su nombre lo indica, almacena texto. Sin embargo mediante operaciones de conversión es posible pasar de texto a otro tipo de datos siempre y cuando sea compatible.

35

4.2. Sentencia de asignación Este tipo de sentencia es de suma importancia porque permite trasladar el valor de una expresión a una variable. Una sentencia de asignación tiene la sintaxis siguiente:

<iv>=<e> Donde <iv> es un identificador de variable, el cual puede ser una variable declarada por el programador o una propiedad de un objeto. La expresión <e> es evaluada y el valor resultante es asignado a <iv>. Por supuesto, el tipo de dato de <e> debe ser compatible con el de <iv>. 4.3. Sentencia de salida Al igual que la sentencia de entrada la sentencia de salida es una forma de comunicación entre el entorno y el algoritmo. Este tipo de sentencia permite que la aplicación devuelva información hacia el entorno ya sea a un usuario, a un archivo entre otros. En el caso de que se proporcione información al usuario se pueden utilizar objetos como Etiqueta y Caja de texto entre otros Ejemplo 4.6. Escribir una aplicación para el Ejemplo x.

1. Sino está ejecutando Visual Basic inícielo. Si ya está en ejecución cierre la aplicación actual y abra una nueva de tipo Exe Estándar

2. Coloque sobre el formulario Form1 los elementos necesario para obtener lo siguiente:

Procure que los elementos que coloca en el formulario estén en el orden Label1 para A, Label2 para B, Label3 para S, Label4 para + y Label5 para =; Text1 para tA, Text2 para tB y Text3 para tS; Command1 para Sumar, Command2 para Limpiar y Command3 para Salir.

3. Cambie la propiedad Caption de acuerdo a las indicaciones anteriores y la propiedad Text de los objetos Text debe estar en blanco.

4. Cambie el nombre de los objetos: a. Label1 por lA, Label2 por lB y Label3 por lS b. Text1 por A, Text2 por B y Text3 por S c. Command1 por cSumar, Command2 por cLimpiar y Command3 por cSalir.

5. Pulse doble clic en el botón Limpiar y escriba el siguiente código: Private Sub cSumar_Click() Dim A, B, S As Single A = CSng(tA.Text) B = CSng(tB.Text) S = A + B tS.Text = CStr(S) End Sub

6. Pulse doble clic en Salir y escriba el siguiente código Private Sub cSalir_Click() End End Sub

7. Pulse clic en Limpiar y escriba el siguiente código Private Sub cLimpiar_Click()

36

tA.Text = "" tB.Text = "" tS.Text = "" End Sub

8. Guarde la aplicación en una carpeta llamada Suma a. El formulario con nombre Principal b. El proyecto con nombre Suma

El lector puede identificar en esta aplicación los diferentes tipos de variables, expresiones y sentencias. 4.5 Sentencia de llamada En el Ejemplo 4.3 la sentencia

Suma(A, B)) Es una sentencia de llamada. Una sentencia de llamada permite ejecutar funciones y procedimientos. Casi todos los objetos en Visual Basic poseen un conjunto de funciones y procedimientos llamados eventos, por ello las sentencias de llamada son fundamentales en este lenguaje. Muchas sentencias de llamada se ejecutan de manera automática, otras se ejecutan por la acción del usuario a través del teclado o el ratón. En el Ejemplo 4.3 cuando el usuario pulsa clic en el botón Command1 se ejecuta el evento Command1_Click. RESUMEN En un lenguaje de programación, con los paradigmas aquí mencionados, los conceptos de valor literal, identificador, tipo de dato, expresión y sentencia son fundamentales por que una aplicación es, en última instancia un conjunto de dichos elementos. Los tipos de datos en un lenguaje caracterizan a los valores en un determinado conjunto y determinan que operaciones se pueden efectuar sobre ellos. Un identificador representa un hecho, atributo, proceso u objeto. Algunos identificadores permiten almacenar valores ya sea de manera variable o constante. Las operaciones válidas entre valores literales e identificadores generan expresiones. Visual Basic facilita una gran variedad de operaciones y funciones sobre expresiones ya sean de tipo numérico, cadena o lógicas. Las sentencias son órdenes que el programa debe ejecutar y usualmente actúan sobre expresiones. Tres de las sentencias más básicas son las de entrada, las de proceso y las de salida pero en el caso de los lenguajes orientados a objetos y a eventos son fundamentales las sentencias de llamada o invocación, las cuales se requieren para utilizar funciones y procedimientos. Un tipo especial de funciones y procedimientos son los eventos, los cuales están presentes en casi todos los objetos de Visual Basic Los identificadores en una aplicación tienen efecto en diferentes ámbitos de la aplicación. Estos ámbitos están relacionados con la sección de la aplicación donde se declaran y también se especifican con las palabras Public, Dim, Static y Private. EJERCICIOS

1. Escriba una aplicación que muestre el área de un círculo. El usuario deberá ingresar el radio. También la aplicación deberá contener una constante llamada cPi con valor 3.14. Además, la aplicación deberá tener una función llamada Area para el cálculo del área, dicha función será invocada al pulsar clic en el botón Calcular, luego se mostrará el área en la etiqueta correspondiente. La interfaz de la aplicación será:

37

2. Escriba una aplicación para el Ejercicio 2 de la unidad anterior. EVALUACIÓN Se revisará la correcta realización de los ejercicios de esta sección. También se considerará la participación y generación de ideas.

38

UNIDAD V. SENTENCIAS DE DECISIÓN CONTENIDO

1. Concepto de sentencias de decisión. 2. Sentencia If… Then… Else 3. Sentencia Select Case. 4. Sentencias de decisión anidadas.


1. Definir sentencia de decisión 2. Comprender la sentencia If… Then… Else 3. Aplicar sentencias If… Then… Else 4. Aplicar sentencias de decisión anidadas. 5. Comprender la sentncia Select Case 6. Aplicar sentencias Select Case

Existen otras sentencias que son de suma importancia para la creación de aplicaciones. Estas son las sentencias de decisión y las sentencias repetitivas. Visual Basic cuenta con más de una sentencia para cada uno de estos tipos. 1. SENTENCIAS DE DECISIÓN Una sentencia de decisión permite ejecutar otras sentencias en función del valor de verdad de una expresión lógica. Estas sentencias son de suma importancia porque en la mayoría de los procesos de la realidad las acciones están condicionadas. 1.1. Sentencia de decisión IF ... THEN ... ELSE ... Permite ejecutar una o más sentencias de manera condicionada. Existen tres formas para escribir la sentencia if. Su sintaxis es la siguiente:

If <el> Then <sentencia 1>

If <el> Then

<sentencia 1> Else <sentencia 2> End If

If <el1> Then <Sentencia 1>

ElseIf <el2> Then <sentencia 2> … ElseIf <eln> Then <sentencia n> Else <sentencia n+1> End If

Donde <el> es una expresión lógica

Los grupos de sentencias <Sentencia i> se ejecutan dependiendo del valor de verdad de la expresión lógica

Ejemplo 5.1. Dados el nombre y cuatro notas parciales de un alumno calcular su nota promedio y mostrar el nombre, la nota promedio y un mensaje según la siguiente tabla:

39

Promedio (P) Mensaje 0-59 Reprobado60-100 Aprobado

1. El siguiente algoritmo muestra como se ha de calcular la nota y determinar el mensaje Notas {Este algoritmo capturar el nombre y cuatro notas parciales, luego calcula la nota promedio y muestra el nombre, la nota promedio y un mensaje Nombre es el nombre del alumno N1, N2, N3, N4 son als cuatro notas parciales NP es la nota promedio} Inicio Leer Nombre, N1, N2, N3, N4 Hacer NP← (N1+N2+N3+N4)/4 Escribir Nombre, NP Si NP<60 Entonces Escribir “Reprobado” Sino Escribir “Aprobado” Fin

2. Se diseñará la siguiente interfaz:

La siguiente tabla resume las propiedades de cada objeto:

Objeto Propiedad Valor Form1 (Nombre)

Caption Principal Cálculo de Nota Promedio

Label1 (Nombre) Font Caption

lNombre Negrita, 12 Nombre

Label2 (Nombre) Caption

lN1 Nota 1:

40

Objeto Propiedad Valor Label3 (Nombre)

Caption lN2 Nota 2:


lN3 Nota 3:


lN4 Nota 4:


lResultados Resultados

Text1 (Nombre) Text

tNombre En blanco

Text2 (Nombre) Text

tN1 En blanco

Text3 (Nombre) Text

tN2 En blanco

Text4 (Nombre) Text

tN4 En blanco

Text5 (Nombre) Text

tN4 En blanco

Command1 (Nombre) Caption

cCalcular Calcular


cLimpiar Limpiar


cCerrar Cerrar

3. Pulse doble clic en Calcular y escriba el siguiente código:

Private Sub cCalcular_Click() Dim Nombre As String * 45 Dim N1, N2, N3, N4 As Single Dim NP As Integer N1 = CSng(tN1.Text) N2 = CSng(tN2.Text) N3 = CSng(tN3.Text) N4 = CSng(tN4.Text) Nombre = tNombre.Text NP = CInt(N1 + N2 + N3 + N4) / 4 tResultados.Text = Nombre + " " + CStr(NP) End Sub

4. Pulse doble clic en Limpiar y escriba el siguiente código: Private Sub cLimpiar_Click() tNombre = "" tN1 = "" tN2 = "" tN3 = "" tN4 = "" tResultados = "" End Sub

5. Pulse doble clic en Cerrar y escriba el siguiente código Private Sub cCerrar_Click()

41

End End Sub

6. Guarde la aplicación en una carpeta llama Notas a. Guarde el formulario Principal (Form1) con el nombre Principal b. Guarde el proyecto con el nombre Notas

7. Ejecute el programa y pruébelo con algunos datos 8. Cierre la aplicación

También pueden existir sentencias de decisión anidadas. El siguiente ejemplo ilustra esta situación Ejemplo 5.2. Una empresa de correos ha clasificado los lugares de destino en cuatro grupos. El costo de envío de un paquete depende del peso, en gramos, y del lugar de destino conforme a la siguiente tabla:

Grupo de destino Peso Costo Grupo 1 0-1

1-3 3-5

7.50 15.20 20.90

Grupo 2 0-3 3-6 6-12

20.00 40.00 55.50

Grupo 3 0-5 5-10 10-15

21.50 45.00 62.10

Dados el peso en gramos de una carta y el lugar de destino determinar el costo de envío 1. El siguiente algoritmo muestra como se ha de calcular la nota y determinar el mensaje

Correo {Este algoritmo permite capturar el peso en gramos y el lugar de destino de un paquete y devuelve el costo de envío Lugar es el lugar de destino Peso es el peso en gramos Costo es el costo de envío} Inicio Leer Lugar, Peso Si Lugar=1 Entonces Si 0<Peso≤1 Entonces Hacer Costo=7.5 Sino Si 1<Peso≤3 Entonces Costo=15.20 Sino Si 3<Peso≤5 Entonces Costo=20.90 Sino Escribir “Peso no válido para un paquete” Sino Si Lugar=2 Entonces Si 0<Peso≤3 Entonces Costo=20.00 Sino Si 3<Peso≤6 Entonces Costo=40.00 Sino Si 6<Peso≤12 Entonces Costo=55.50 Sino Escribir “Peso no válido para un paquete” Sino Si Lugar=3 Entonces Si 0<Peso≤5 Entonces Costo=21.50 Sino Si 5<Peso≤10 Entonces Costo=45.00 Sino Si 10<Peso≤15 Entonces Costo=62.10 Sino Escribir “Peso no válido para un paquete”

42

Sino Escribir “Lugar no válido” Fin

2. Se diseñará la siguiente interfaz:

3. La siguiente tabla resume las propiedades de cada objeto:


Caption Principal Costo de envío de paquetes


lLugar Negrita, 12 Lugar


lPeso Negrita, 12 Peso


lCosto Negrita, 12 Costo:


lMensaje Negrita, 12 En blanco

ListBox (Nombre) List Font

lbLugar Grupo 1 Grupo 2 Grupo 3 Normal, 12

Text1 (Nombre) Text Font

tPeso En blanco Normal, 12


cCalcular Calcular


cLimpiar Limpiar


cCerrar Cerrar

4. para agregar elementos a la propiedad List del objeto ListBox

43

a. Pulse doble clic en la casilla de valor (Lista) de la propiedad y se desplegará una lista vacía

b. Escriba Grupo 1 y luego pulse ctrl.+Enter para añadir una nueva fila vacía c. Escriba Grupo 2 y luego pulse ctrl.+Enter para añadir una nueva fila vacía d. Escriba Grupo 3 y luego pulse Enter para finalizar la lista

5. Para Label4 colóquela justo por encima de los botones Calcular , Limpiar y Cerrar 6. Pulse doble clic en Calcular y escriba el siguiente código:

Private Sub cCalcular_Click() Dim Lugar As String Dim Peso, Costo As Single lbLugar.ListIndex = 0 Lugar = lbLugar.ListIndex Peso = CSng(tPeso.Text) If Lugar = 0 Then If (0 < Peso) And (Peso <= 1) Then Costo = 7.5 ElseIf (1 < Peso) And (Peso <= 3) Then Costo = 15.2 ElseIf (3 < Peso) And (Peso <= 5) Then Costo = 20.9 Else lMensaje.Caption = "Peso no válido para un paquete" End If ElseIf Lugar = 1 Then If (0 < Peso) And (Peso <= 3) Then Costo = 20 ElseIf (3 < Peso) And (Peso <= 6) Then Costo = 40 ElseIf (6 < Peso) And (Peso <= 12) Then Costo = 55.5 Else lMensaje.Caption = "Peso no válido para un paquete" End If ElseIf Lugar = 2 Then If (0 < Peso) And (Peso <= 5) Then Costo = 21.5 ElseIf (5 < Peso) And (Peso <= 10) Then Costo = 45 ElseIf (10 < Peso) And (Peso <= 15) Then Costo = 62.1 Else lMensaje.Caption = "Peso no válido para un paquete" End If Else lMensaje.Caption = "Lugar no válido" End If If Costo > 0 Then lCosto.Caption = "Costo: " + CStr(Costo) End Sub

44

Al comparar el código con el psudocódigo nótese que los valores de lugar de destino son 0, 1 y 2 en lugar de 1, 2 y 3. Esto es así porque el objeto ListBox contiene una lista de valores cuya numeración inicia en 0. Otro aspecto a señalar es que en la penúltima línea de código aparece la sentencia:

If Costo > 0 Then lCosto.Caption = "Costo: " + CStr(Costo) En la cual

lCosto.Caption = "Costo: " + CStr(Costo) significa que a la propiedad Caption se le asignará la cadena de caracteres “Costo: ” concatenado con el valor de Costo convertido en String (es decir en cadena de caracteres).

7. Pulse doble clic en Limpiar y escriba el siguiente código: Private Sub cLimpiar_Click() Private Sub cLimpiar_Click() tPeso.Text = "" lCosto.Caption = "Costo:" lMensaje.Caption = "" lbLugar.ListIndex = 0 End Sub

8. Pulse doble clic en Cerrar y escriba el siguiente código Private Sub cCerrar_Click() End End Sub

9. Pulse doble clic sobre el formulario y escriba el código Private Sub Form_Load() lbLugar.ListIndex = 0 End Sub Esta línea se ejecutará al momento de ejecutar la aplicación y el objetivo es inicializar como grupo de destino el Grupo 1. Esto es necesario porque al ejecutarse la aplicación el usuario leerá en el lugar de destino Grupo 1 y entonces es casi seguro que no seleccionará ninguna opción de la lista. Pero en realidad el valor que devuelve la lista es -1 pues no se ha seleccionado ningún lugar de destino. Nótese que al seleccionar un valor de destino este se torna de color azul.

10. Guarde la aplicación en una carpeta llama Correo a. Guarde el formulario Principal (Form1) con el nombre Principal b. Guarde el proyecto con el nombre Correo

11. Ejecute el programa y pruébelo con algunos datos 12. Cierre la aplicación

En el ejemplo anterior existen varias sentencias de decisión anidadas. En relación a la variable Lugar hay tres sentencias de decisión anidadas y dentro de las sentencias correspondientes a Then hay sentencias de decisión anidadas. Por ejemplo, en la parte Then, cuando Lugar = 1 se ejecuta la sentencia:

45

If (0 < Peso) And (Peso <= 1) Then Costo = 7.5 ElseIf (1 < Peso) And (Peso <= 3) Then Costo = 15.2 ElseIf (3 < Peso) And (Peso <= 5) Then Costo = 20.9 Else lMensaje.Caption = "Peso no válido para un paquete" End If

La cual, a su vez, es un conjunto de tres sentencias de decisión anidadas. Nótese que con respecto a la variable Lugar las expresiones lógicas se construyeron utilizando el operador =, mientras que para la variable Peso se utilizan expresiones lógicas mas complejas. Cuando se tienen sentencias de decisión anidadas con expresiones lógicas como en el caso de la variable lugar, resulta conveniente utilizar la sentencia de decisión Select… Case. 1.2. Sentencia de decisión SELECT CASE Esta sentencia permite ejecutar una de entre varias acciones en función del valor de una expresión. Es una alternativa a If ... Then ... ElseIf anidados. Su forma general es la siguiente:

Select Case <e> Case <etiq1> <sentencias1> Case etiq2 <sentencias2> Case Else <Sentenciasn> End Select

Donde <e> es una expresión numérica o alfanumérica, y <etiq1>, <etiq2> son valores que puede tomas <e> <sentencias> es un conjunto de sentencias

<etiq> pude ser un valor literal o una lista de valores literales o bien un intervalo Ejercicio 5.3.

1. Cambie el código del botón Calcular por lo siguiente: Private Sub cCalcular_Click() Dim Lugar As Integer Dim Peso, Costo As Single Lugar = CInt(lbLugar.ListIndex) Peso = CSng(tPeso.Text) Select Case Lugar Case 0 If (0 < Peso) And (Peso <= 1) Then Costo = 7.5 ElseIf (1 < Peso) And (Peso <= 3) Then Costo = 15.2 ElseIf (3 < Peso) And (Peso <= 5) Then Costo = 20.9 Else lMensaje.Caption = "Peso no válido para un paquete"

46

End If Case 1 If (0 < Peso) And (Peso <= 3) Then Costo = 20 ElseIf (3 < Peso) And (Peso <= 6) Then Costo = 40 ElseIf (6 < Peso) And (Peso <= 12) Then Costo = 55.5 Else lMensaje.Caption = "Peso no válido para un paquete" End If Case 2 If (0 < Peso) And (Peso <= 5) Then Costo = 21.5 ElseIf (5 < Peso) And (Peso <= 10) Then Costo = 45 ElseIf (10 < Peso) And (Peso <= 15) Then Costo = 62.1 Else lMensaje.Caption = "Peso no válido para un paquete" End If Case Else lMensaje.Caption = "Lugar no válido" End Select If Costo > 0 Then lCosto.Caption = "Costo: " + CStr(Costo) End Sub

2. Luego ejecute la aplicación para verificar que funciona correctamente. 3. Ahora cambie el código anterior por el siguiente

Private Sub cCalcular_Click() Dim Lugar As Integer Dim Peso, Costo As Single Lugar = CInt(lbLugar.ListIndex) Peso = CSng(tPeso.Text) Select Case Lugar Case 0 Select Case Peso Case 0 To 1 Costo = 7.5 Case 1 To 3 Costo = 15.2 Case 3 To 5 Costo = 20.9 Case Else lMensaje.Caption = "Peso no válido para un paquete" End Select Case 1 Select Case Peso Case 0 To 3 Costo = 20 Case 3 To 6 Costo = 40

47

Case 6 To 12 Costo = 55.5 Case Else lMensaje.Caption = "Peso no válido para un paquete" End Select Case 2 Select Case Peso Case 0 To 5 Costo = 21.5 Case 5 To 10 Costo = 45 Case 10 To 15 Costo = 62.1 Case Else lMensaje.Caption = "Peso no válido para un paquete" End Select Case Else lMensaje.Caption = "Lugar no válido" End Select If Costo > 0 Then lCosto.Caption = "Costo: " + CStr(Costo) End Sub

4. Ejecute la aplicación y verifique que funcione correctamente.

En el ejemplo anterior es de hacer notar que en los intervalos 0 To 1 y 1 To 3, por ejemplo, si Peso toma el valor 1 entonces se ejecutará

Costo = 7.5 Mientras que se Peso toma el valor 1.001 entonces se ejecutará

Costo = 15.2 Es decir los intervalos son excluyente porque en una sentencia Select se ejecutan las sentencias en el primer Case donde la expresión toma valor de su etiqueta correspondiente. Para ilustar mejor esta idea considere el primer Case y modifique el código como sigue:

Case 0 Select Case Peso Case 0 To 1 Costo = 7.5 Case 1 To 3 Costo = 15.2 Case 2 To 5 ‘en lugar de 3 se escribió 2 Costo = 20.9 Case Else lMensaje.Caption = "Peso no válido para un paquete" End Select

En este segmento de código se cambió un 3 por un 2 en la séptima línea. Ahora ejecute la aplicación y seleccione el Grupo 1 con un peso de 2.3; en este caso la salida será 15.2. Nótese que 2.3 es un valor en los intervalos 1 To 3 y 2 To 5, sin embargo sólo se ejecuta la sentencia Costo=15.2. RESUMEN En la mayoría de las aplicaciones para resolver problemas existen tareas que deben realizarse de manera condicionada, por ello Visual Basic incorpora sentencias de decisión. Ellas permiten ejecutar de manera selectivas segmentos de código. Dichas sentencias son If… Then… Else y

48

Select Case. Ellas se pueden escribir de manera anidada para tareas más complejas o múltiplemente condicionadas. EJERCICIOS

1. Escriba una aplicación para determinar el estado físico del agua a partir de la temperatura y la escala en que se mide. Para ello, el usuario debe proporcionar el valor de la temperatura y la escala mediante la siguiente interfaz:

Al pulsar en Limpiar deberá dejar en blanco la caja para temperatura y estado, y en escala debe aparecer seleccionado Fahrenheit. 2. Una compañía tiene dos tipos de empleados: tipo A o administrativos y tipo B o de servicio.

Para el pago del salario neto se hacen algunas deducciones sobre el salario bruto y se suman algunos bonos. Si el empleado es tipo A, entonces si las transacciones son mayores que 500 se dará un bono de Lps. 700 y las deducciones son el 12% del salario bruto. Si el empleado es tipo B las deducciones son de un 8% del salario bruto. Dados la categoría del empleado, el salario bruto y número de transacciones determine el salario neto. Escriba una aplicación que para este problema.

EVALUACIÓN Se evaluará la realización del segundo ejercicio. También se considerará la participación creativa durante el desarrollo de esta unidad.

49

UNIDAD VI. CAJAS O VENTANAS DE DIALOGO CONTENIDO

1. Cajas de dialogo predefinidas. 2. Cajas de dialogo personalizadas.


1. Utilizar apropiadamente cajas de dialogo predefinidas. 2. Crear cajas de dialogo personalizadas.

1. CAJAS DE DIALOGO PREDEFINIDAS Un tipo especial de ventana, debido a su función, son las ventanas o cajas de dialogo. Estas se utilizan para realizar tareas simples y rutinarias como la captura de una clave de acceso o un mensaje de error. Una caja de dialogo es una ventana que normalmente se utiliza para mostrar o requerir información para que una aplicación pueda continuar. Visual Basic proporciona una forma muy fácil de solicitar o mostrar información al usuario mediante el tipo predefinido de cajas de dialogo. Estas se visualizan utilizando inputBox o MsgBox respectivamente. 1.1. Visualizar datos con MsgBox La función MsgBox muestra un mensaje en una caja de dialogo como figura:

Faltan datos numéricos, revise el contenido de las celdas bajo A o B

Cerrar

La sintaxis es:

MsgBox <mensaje> <, botones><, titulo> La longitud máxima de <mensaje> es de aproximadamente 1024 caracteres, según el ancho de los caracteres utilizados. Si <mensaje> consta de más de una línea, puede separarlos utilizando un carácter de retorno de carro mediante & vbCrLf & ente las dos cadenas de texto. Ejemplo 6.1. Agregar una caja de dialogo a la aplicación Suma del Ejemplo 3.1.

1. Abra la aplicación que creo en el Ejemplo 4.5 2. Pulse doble clic sobre el botón Sumar, el código debe quedar como el siguiente:

Private Sub cSumar_Click() Dim A, B, S As Single If tA = "" Or tB = "" Then MsgBox "Faltan datos numéricos,”, & vbCrLf & ,”revise el contenido de las celdas bajo A o B", vbCritical, "Error" Else A = CSng(tA.Text) B = CSng(tB.Text) S = A + B tS.Text = CStr(S) End If

50

End Sub 3. Ejecute la aplicación y pulse clic en sumar sin ingresar datos en A y B ¿Qué ocurre? Otra forma de escribir el código anterior es:

Private Sub cSumar_Click() Dim A, B, S As Single Dim Mensaje As String Mensaje="Faltan datos numéricos,” , & vbCrLf &, “revise el contenido de las celdas bajo A o B" If A = "" And B = "" Then MsgBox Mensaje, vbCritical, "Error" Else A = CSng(tA.Text) B = CSng(tB.Text) S = A + B tS.Text = CStr(S) End If End Sub

1.2. Obtener datos con InputBox La función MsgBox muestra un mensaje en una caja de dialogo y captura un dato como figura:

La sintaxis es:

InputBox <mensaje> <, botones><, titulo> La longitud máxima de <mensaje> es de aproximadamente 1024 caracteres, según el ancho de los caracteres utilizados. Si <mensaje> consta de más de una línea, puede separarlos utilizando un carácter de retorno de carro mediante & vbCrLf & ente las dos cadenas de texto. Ejemplo 6.2. Crear una caja de dialogo para ingresar una clave

1. Se cerró la aplicación del ejemplo anterior vuélvalo a abrir 2. Pulse doble clic sobre el área del formulario y escriba el código necesario para obtener lo

siguiente:

Private Sub Form_Load() Dim Clave As String Dim Mensaje As String Mensaje = "Ingrese la Clave de Acceso" Clave = InputBox(Mensaje, "Clave de acceso") If Clave <> "fantasia" Then MsgBox "Clave incorrecta, la aplicación se cerrará", vbMsgBoxRight, "Error" End End If

51

End Sub 3. Ejecute la aplicación e introduzca la palabra tendencias, luego pulse clic en aceptar ¿Qué

ocurre? 4. Vuelva ejecutar la aplicación, esta vez introduzca la palabra fantasia, luego pulse clic en

aceptar ¿Qué ocurre? 5. ¿Qué ocurre si en lugar de escribir una palabra y pulsar clic en aceptar pulsa cancelar?

2. CAJAS DE DIALOGO PERSONALIZADAS Una dificultad de la caja de dialogo anterior para ingresar un clave de acceso es que se puede ver que palabra se está escribiendo. Esto no es correcto para las claves de acceso pues siempre se desea que nadie pueda ver dicha clave. No obstante lo anterior, el programador puede crear su propia caja de dialogo personalizada. Ejemplo 6.3. Crear una caja de dialogo para ingresar una clave

1. Se cerró la aplicación del ejemplo anterior vuélvalo a abrir 2. Ahora guárdelo con otro nombre en otra carpeta

a. La nueva carpeta se llamará SumaV2 b. Pulse clic en Archivo del menú principal. Luego pulse clic sobre Guardar proyecto

como… y aparecerá la siguiente ventana:

c. Seleccione la carpeta donde está guardando sus trabajos (C:\Prehemo). Luego pulse

clic en Crear nueva carpeta y escriba SumaV2 y luego pulse doble clic sobre el icono de la carpeta que está creando

d. Cambie el nombre del proyecto Suma por SumaV2 y pulse clic en Guardar. Ahora tiene dos versiones de la aplicación que suma dos números reales, trabajaremos con la última que hemos creado.

3. Pulse doble clic sobre el área del formulario y elimine el código de procedimiento Form_Load lo siguiente:

Private Sub Form_Load() End Sub

4. Añada un nuevo formulario a la aplicación. Para ello pulse clic en la flecha de Añadir Formulario de la barra de herramientas, se desplegará la ventana siguiente:

52

Luego pulse clic en Formulario, se desplegará la ventana

Luego seleccione Formulario y pulse clic en el botón Abrir (o simplemente pulse doble clic en Formulario)

5. Coloque los objetos necesario para que el nuevo formulario tenga la siguiente apariencia:

53

6. Haga los cambios necesarios para que las propiedades de los objetos en el formulario 2

tengan las siguientes valores: Objeto Propiedad Valor

Form2 (Nombre) fClave Label1 (Nombre)

Font Alignment

lClave Negrita, tamaño 12 2-Center

Text1 (Nombre) Text Font PasswordChar

tClave En blanco Negrita, tamaño 12 *


cAceptar Aceptar


cCancelar Cancelar

7. Pulse doble clic en Cancelar y escriba el código necesario para obtener:

Private Sub cCancelar_Click() Form1.Final End Sub

8. Pulse doble clic en Aceptar y escriba el código necesario para obtener: Private Sub cAceptar_Click() If tClave.Text = "fantasia" Then Form1.Show Else Form1.Final End If Hide End Sub

9. Seleccione el formulario 1 y pulse doble clic sobre el área del formulario. Luego escriba el código necesario para obtener lo siguiente: Private Sub Form_Load() Hide fClave.Show End Sub

10. Seleccione la sección (General) del Formulario 1 y escriba el siguiente procedimiento Public Sub Final() End

54

End Sub 11. Guarde la aplicación 12. Ejecute la aplicación y pruébala

Siempre que incluya una clave de acceso en una aplicación deberá tomas medidas para proteger la clave y para no extraviarla. Existen métodos más sofisticados para utilizar claves en aplicaciones pero esos no se tratan en este material. 3. CUADROS DE DIÁLOGO MODALES Y NO MODALES Los cuadros de diálogo pueden ser modales y no modales. Un cuadro de diálogo modal se debe cerrar antes de poder continuar trabajando con el resto de la aplicación. Esto requiere, por ejemplo, que se haga clic en Aceptar o en Cancelar antes de poder cambiar a otro formulario o cuadro de diálogo. El cuadro de diálogo Acerca de de Visual Basic es modal. Los cuadros de diálogo que presenten mensajes importantes deberían ser siempre modales; es decir, el usuario tendrá que cerrar el cuadro de diálogo o responder a su mensaje antes de continuar. Ejemplo 6.4. Ver el cuadro Acerca de

1. Si cerró Visual Basic ejecútelo 2. Pulse clic en Ayuda del menú principal 3. Pulse clic en Acerca de Microsoft Visual Basic… 4. Aparecerá el cuadro Acerca de, intente pulsar clic en algún elemento de IDE ¿Qué ocurre? 5. Pulse clic en Aceptar del cuadro de dialogo

Los cuadros de diálogo no modales le permiten cambiar el enfoque entre el cuadro de diálogo y otro formulario sin tener que cerrar el cuadro de diálogo. Puede seguir trabajando en cualquier parte de la aplicación actual y seguir presentando el cuadro de diálogo. Los cuadros de diálogo no modales no son frecuentes. En el menú Edición de Visual Basic, el cuadro de diálogo Buscar es un ejemplo de cuadro de diálogo no modal. Ejemplo 6.5. Ver el cuadro Buscar

1. Si cerró Visual Basic ejecútelo 2. Pulse clic en Edición del menú principal 3. Pulse clic en Buscar… 4. Aparecerá el cuadro Buscar, intente pulsar clic en algún elemento de IDE ¿Qué ocurre? 5. Pulse clic en Cancelar del cuadro de dialogo 6. Cierre Visual Basic sin guardar cambios

Utilice los cuadros de diálogo no modales para presentar comandos o información que se usen con frecuencia. La sintaxis para presentar un cuado como modal es:

<formulario>.Show vbModal vbModal es una constante cuyo valor es 1. La sintaxis para presentar un cuado como modal es:

<formulario>.Show

55

Si un formulario se presenta como modal, el código que sigue al método Show no se ejecutará hasta que se cierre el cuadro de diálogo. Sin embargo, cuando un formulario se presenta como no modal, el código que sigue al método Show se ejecuta inmediatamente después de presentar el formulario. El método Show tiene otro argumento opcional que puede usarse para especificar una relación primario-secundario para un formulario. Puede pasar a este argumento el nombre de un formulario para que ese formulario sea el propietario del nuevo formulario. La sintaxis para presentar un cuado como modal es:

<formulario1>.Show vbModeless, <formulario2> En este caso <formulario> es secundario en relación al <formulario2> Usar el argumento propietario con el método Show asegura que el cuadro de diálogo se minimizará cuando se minimice su primario o se descargará si se cierra el formulario primario. Ejemplo 6.6. Uso de cuadros modales

1. Si cerró Visual Basic ejecútelo 2. Seleccione Exe Estándar 3. Añada dos formularios más 4. Utilizando el explorador de proyector seleccione el formulario 1 5. Pulse doble clic sobre el formulario y escriba el siguiente código:

Private Sub Form_Load() Form2.Show End Sub

6. Ejecute la aplicación ¿Observa la ventana Form2? Si no la observa arrastre un poco hacia abajo la ventana Form1 ¿Observa ahora la ventana Form2?

7. ¿Observa la ventana Form3? Si no la observa arrastre un poco hacia abajo la ventana Form2 ¿Observa ahora la ventana Form3? Se puede observar la ventana Form2 porque al ejecutarse Form1 inmediatamente se ejecutó Form2.Sow, sin embargo la ventana dos quedó detrás de Form1 ya que no se utilizó el argumento Modal Por el contrario Form3 no se podrá visualizar porque no se ha ejecutado ninguna instrucción para ello.

8. Finalice la ejecución de la aplicación y seleccione el formulario 2 9. Pulse doble clic sobre el formulario 2 y escriba el siguiente código:

Private Sub Form_Load() Form3.Show vbModal End Sub

10. Ejecute la aplicación ¿Observa las ventanas Form2 y Form1? Si no la observa arrastre un poco hacia abajo la ventana Form3 ¿Observa ahora las ventanas Form2 y Form1? No se puede observar la ventana Form2 ni Form1 porque al ejecutarse Form1 inmediatamente se ejecutó Form2.Sow y a su vez se ejecutó Form3.Show Modal

11. Cierre el formulario 3, ahora si podrá ver Form1 (y posiblemente form2). Recuerde que Form2 se ejecutó con Form2.Show y por tanto podrá intercambiar entre ambas ventanas.

12. Finalice la ejecución de la aplicación 13. Cierre Visual Basic sin guardar cambios

RESUMEN Un tipo especial de ventana, debido a su función, son las ventanas o cajas de dialogo. Estas se utilizan para realizar tareas simples y rutinarias como la captura de una clave de acceso o un mensaje de error. Visual Basic cuanta con varios tipos de cajas de dialogo aunque aquí solo se

56

vieron las predefinidas y las construidas por el programador. Una caja de dialogo puede ser modal o no modal. Las de tipo modal bloquean el acceso al resto de la aflicción mientras que las no modales no. EJERCICIOS

1. Crear una caja de dialogo que muestre una ventana de inicio como la siguiente

La cual se ejecutará al iniciar la aplicación y debe ser modal. Nota. Para insertar la imagen se utilizó el componente Image, usted puede seleccionar cualquier otra imagen si no cuenta con la de la ventana. Además, para que la ventana aparezca desde el inicio debe incluir la línea de código que la invoca en el evento Load al cual se tiene acceso pulsando doble clic sobre el formulario principal.

2. Modifique el Ejemplo 5.3 de modo que utilice un cuadro modal secundario para la caja de clave de acceso.

EVALUACIÓN Se considerará el desarrollo del primer ejercicio y la participación creativa para la construcción del mismo.

57

UNIDAD VII. ARREGLOS Y SENTENCIAS REPETITIVAS CONTENIDO

1. Arreglos. 2. Sentencias repetitivas.


1. Comprender el concepto de arreglo. 2. Aplicar arreglos para la construcción de aplicaciones. 3. Identificar los diferentes tipos de procesos repetitivos. 4. Aplicar sentencias repetitivas en la construcción de aplicaciones.

1. ARREGLOS En ocasiones es necesario manipular listas de datos para un mismo atributo. En este caso, los tipos de datos que se han presentado no son suficientes pues las variables así definidas solo pueden almacenar un único valor. Un arreglo es un conjunto de espacios de memoria donde se pueden almacenar datos de un sólo tipo. En Visual Basic el tipo de dato para definir arreglos es el array. Para declarar un identificador de tipo array se utiliza la sintaxis siguiente:

<Ámbito> <ia>(<t1>,<t2>,…, <t60>) As <tipo> Donde

<Ámbito> puede ser: Public, Dim, Private, Static dependiendo de donde se va ha declarar. <ia> es un identificador <t1> hasta <t60> son los tamaños de cada índice

En el caso anterior los valores de cada índice inician en 0 y terminan en el valor especificado, es decir:

• El primer índice inicia en 0 y termina en t1 • El segundo índice inicia en 0 y termina en t2 • Etc.

Por ejemplo: Dim Nombre(29) As String*45

Tiene un solo índice que inicia en 0 y termina en 29, es decir tiene 30 celdas de memoria. También se puede declarar array de la siguiente manera

<Ámbito> <ia>(<vi1> To <vf1>,<vi2> To <vf2>,…,<vi60> To <vf60>) As <tipo> Donde cada índice se especifica con el valor inicial y el valor final Por ejemplo:

Dim Nombre(1 To 30) As String*45 Tiene un solo índice que inicia en 1 y termina en 30, es decir tiene 30 celdas de memoria. La dimensión de un array es igual al número de índices; un array de un índice se llama unidimensional y usualmente se le llama vector; un array de dos índices se llama bidimensional y usualmente se le llama matriz; en general un array de n índices se llama n-dimensional. En Visual Basic se puede definir un array de hasta 60 índices. Una de las ventajas del uso de array es el hecho de poder hacer referencia a un conjunto de datos con un único identificador, no obstante para hacer referencia a un dato específico es necesario especificar la posición del dato en el array. Suponga que se declara la siguiente variable de tipo array:

Dim Nombre(19) As String * 45 Entonces una representación de memoria de dicha variable es:

58

Nombre es un array de 20 celdas y en cada una de ellas se pueden guardar datos de tipo String con un máximo de 45 caracteres. En la figura anterior se señala la segunda celda Nombre(1). Suponga que se declara la siguiente variable:

Dim Notas(19,3) As Single Entonces una representación de memoria de dicha variable es:

Notas es un array de 20 filas y 4 columnas y en cada celda se puede almacenar un dato de tipo Single. En la figura anterior se señala la celda 2 de la fila 1. Existen dos tipos de array de variables: 1.1 Array estático Cuya dimensión es siempre la misma. Todos los ejemplos anteriores son array estáticos. Este tipo de array tiene el inconveniente que en la mayoría de los casos están sobredimensionados y utilizan más memoria de la que realmente necesitan. Esto implica que se está malgastando memoria 1.2. Array dinámico Cuya dimensión se puede modificar durante la ejecución del programa. Para declarar un array dinámico se omite la especificación de los índice:

<Ámbito> <ia>() As <tipo> Por ejemplo

Dim Comision() As Single Posteriormente se puede asignar los índices al array dinámico con la sentencia ReDim:

ReDim Comision(9,14) Pero en este caso toda la información que contiene el array se pierde después de la sentencia ReDim. Si es necesario conservar la información contenida en el array dinámico entonces se debe utilizar la sentencia ReDim Preserve:

ReDim Preserve Comision(9,14) Por supuesto para que esto funcione es necesario que la nueva dimensión sea mayor que la anterior. En general, para manipular variables de tipo array es necesario un tipo especial de sentencias repetitivas. Aunque dicho tipo de sentencias tienen una utilidad más general se introducen en esta sección por fines didácticos y prácticos únicamente. 2. SENTENCIAS REPETITIVAS Visual Basic también cuenta con un conjunto de sentencias para realizar tareas en forma repetitiva. Este tipo de tareas abunda en aplicaciones de la vida real. Por ejemplo, atender clientes en un supermercado, calcular la nota final de varios estudiantes, emitir las facturas de teléfono, entre muchas otras.

59

Los procesos repetitivos pueden clasificarse de tres formas diferentes: 1. El proceso se repite cero o más veces

Por ejemplo, un cajero en un banco puede atender muchos clientes, pero también es posible que no atienda a nadie (si no llegara ningún cliente)

2. El proceso se repite una o más veces pero con el número de veces desconocido Por ejemplo, si un cliente llega a la caja de un supermercado con varios artículos el cajero deberá ingresar los datos de al menos un artículo a pesar de que él no sabe exactamente cuantos artículos lleva el cliente hasta que los ha ingresado todos.

3. El proceso se repite un número conocido de veces Por ejemplo, si un docente tiene 40 alumnos deberá calcular exactamente 40 notas finales.

Entender los tipos de procesos repetitivos es importante porque así es posible seleccionar la sentencia repetitiva más apropiada en la escritura de una aplicación. 2.1. Sentencia FOR ... NEXT La sentencia For da lugar a un ciclo que permite ejecutar un conjunto de sentencias un número de veces conocido. Su forma general es:

For <v> = <e1> To <e2> Step <e3> <sentencia>

Next <v> Cuando se ejecuta una sentencia For primero se asigna el valor de la expresión <e1> a la variable <v> y luego puede ocurrir una de dos cosas:

1. Si <e3> es positiva, se comprueba si <v> tiene valor menor o igual que <e2> y si esto se cumple se ejecutan las sentencias <sentencias>

2. Si <e3> es negativa, se comprueba si <v> tiene valor mayor o igual que <e2> y si esto se cumple se ejecutan las sentencias <sentencias>

Se comprueba si su valor es menor que <e2> si <e3> es negativa. Ejemplo 7.1. Dada una lista de 20 números reales calcular su media aritmética y luego mostrar la

lista de números y su media. Para resolver este problema se consideran los siguientes identificadores Lista de números: Num Media aritmética: M Y se necesitará la siguiente interfaz:

60

1. La siguiente tabla resume las propiedades de los objetos de la ventana anterior. Objeto Propiedad Valor

Form1 (Nombre) Caption

fMedia Media

Label1 (Nombre) Caption Font Alignment

lTitulo Cálculo de media aritmética de 20 números Negrita, 12 2-Center

Label2 (Nombre) Caption Font

lNumero Ingrese un número: Negrita, 12

Label3 (Nombre) Caption Font Alignment

lResultado Resultado Negrita, 12 2-Center


cOtro Otro número


cFin Fin

Commnad3 (Nombre) Caption

CCerrar Cerrar

Commnad4 (Nombre) Caption

CLimpiar Limpiar

Text1 (Nombre) Caption Font

tNumero En blanco Normal, 12

Text2 (Nombre) Caption MultiLine ScrollBar

TResultado En blanco True 2-Vertical

2. Seleccione la sección (General) del formulario y escriba el siguiente código

Dim Num(1 To 20) As Single Dim i As Integer

3. Pulse doble clic en Fin y escriba el siguiente código Private Sub cFin_Click() Dim M As Single Dim j As Integer Dim N As Single tResultado = "Valores" M = 0 If i > 0 Then For j = 1 To i M = M + Num(j) tResultado.Text = tResultado.Text & vbCrLf & CStr(Num(j)) Next M = M / i tResultado.Text = tResultado & vbCrLf & "M= " + CStr(M) End If tNumero.SetFocus

61

End Sub Cuándo se utiliza un objeto Text Box (Caja de texto) con la propiedad MultiLine True se puede escribir en una nueva línea añadiendo & vbCrLf & en la expresión, tal y como aparece en tResultado.Text = tResultado.Text & vbCrLf & CStr(Num(j)) La propiedad SetFocus permite que el objeto esté seleccionado por omisión, por ejemplo tNumero.SetFocus mostrará el cursor dentro de la caja de texto

4. Pulse doble clic en Otro Número y escriba el siguiente código Public Sub cOtro_Click() If tNumero.Text <> "" Then i = i + 1 Num(i) = CSng(tNumero.Text) tNumero = "" End If tNumero.SetFocus End Sub

5. Pulse doble clic en Cerrar y escriba el siguiente código Private Sub cCerrar_Click() End End Sub

6. Pulse doble clic en Limpiar y escriba el siguiente código Private Sub cLimpiar_Click() tNumero = "" tResultado = "" tNumero.SetFocus End Sub

7. Guarde la aplicación en una carpeta llamada Media a. El formulario con el nombre fMedia b. El proyecto con el nombre Media

8. Ejecute la Aplicación y pruebe con varios valores 2.2. Sentencia WHILE … WEND Esta sentencia es otra forma de generar ciclos que se ejecutan mientras se cumpla la condición inicial. Su sintaxis es la siguiente:

While <el> <sentencias>

Wend Ejemplo 7.2.

1. Si cerró la aplicación del ejemplo anterior vuélvala a abrir. 2. Cambie el código de Fin por el siguiente

Private Sub cFin_Click() Dim M As Single Dim j As Integer Dim N As Single

62

tResultado = "Valores" M = 0 If i > 0 Then j=1 While j <= i M = M + Num(j) tResultado.Text = tResultado.Text & vbCrLf & CStr(Num(j)) Wned M = M / i tResultado.Text = tResultado & vbCrLf & "M= " + CStr(M) End If tNumero.SetFocus End Sub

3. Guarde la aplicación en una carpeta llamada Media2 4. Ejecute la aplicación y pruebe con varios valores

Existen otras sentencias repetitivas en Visual Basic pero estas no se verán en este material. RESUMEN En ocasiones es necesario manipular listas de datos para un mismo atributo. Para que esto sea posible es necesario utilizar el tipo de dato array. Este tipo de dato permite declarar variables que son capaces de almacenar más de un valor en su memoria. Los array pueden ser estáticos o dinámicos, cada uno de ellos presenta características que los hacen útiles en ciertas condiciones. Para manipular variables de tipo array usualmente es necesario utilizar ciclos. Los ciclos son un tipo especial de estructura en la cual un conjunto de sentencia se ejecutan hasta que o mientras que se cumple una condición. Visual Basic cuenta con varias sentencias repetitivas para implementar ciclos. En este material se presentaron las sentencias For… Next y While… Wend. Estas sentencias repetitivas no se utilizan de manera exclusiva para manipular array. EJERCICIOS

1. Escribir una aplicación que reciba varios números reales y devuelva como respuesta al mayor y al menor y la media aritmética de los números.

2. El siguiente es un algoritmo de ordenación Burbujeo Antes: Una lista de datos: ListaD La posición del último dato de la lista: U Después: ListaD tiene todos sus elementos ordenados en forma ascendente {Ordena de menor a mayor los elementos de una lista de datos Cambios: es una variable lógica que toma el valor verdadero si hay cambios en la lista Aux: es una variable auxiliar para almacenar temporalmente valores de ListaD i: es un contador para recorrer la lista} Inicio Hacer Cambios←Verdadero Mientras Cambios Hacer Hacer Cambios←Falso Hacer i←1 Mientras (i≤U–1) Hacer Si (ListaDi>ListaDi+1) Entonces Hacer Cambios←Verdadero

63

Hacer Aux←ListaDi

Hacer ListaDi←ListaDi+1

Hacer ListaDi+1←Aux Hacer i←i+1 Fin Escriba una aplicación que reciba una lista de nombres y los devuelva en forma ordenada.

EVALUACIÓN Se considerará la realización del Ejercicio 2. También deberán resolver una guía de trabajo que se incluye en el material complementario para el desarrollo de los talleres.

64

UNIDAD VIII. GESTIÓN DE DATOS CONTENIDO

1. Bases de Datos Relacionales 2. Creación de una base de datos en MSAccess 3. Creación de un programa de acceso a datos con Visual Basic


1. Conocer aspectos generales sobre bases de datos relacionales. 2. Conocer la estructura de una base de datos. 3. Conocer las relaciones existentes en una base de datos. 4. Crear una base de datos en MSAccess. 5. Crear una aplicación de acceso a datos de MSAccess.

1. BASES DE DATOS RELACIONALES Visual Basic permite manipular bases de datos creadas con otros programas. También permite gestionar sistemas de archivos en varios formatos. Sin embargo, dado que este es un curso introductorio no se presentarán todas las posibilidades. Nos enfocaremos en el concepto de Bases de Datos Relacionales y específicamente se explicará como crearlas en MSAccess. Una base de datos relacional se define como una colección de datos cuyos elementos tienen vínculos entre si. En otras palabras, una base de datos relacional es una colección de datos afines. Una colección de datos relacional incluye tres elementos fundamentales: Campos, Registros y Tablas. 1.1. Estructura de una Base de Datos Una base de datos se interpreta como un conjunto de tablas. Dichas tablas deben referirse a registros que están relacionados de alguna forma. Por ejemplo, una universidad podría tener una base de datos con las tablas Alumnos, Profesores, Asignaturas, entre otras. Todas estas tablas estarán relacionadas porque existe una relación entre profesores, alumnos y asignaturas. Pero la misma universidad podrá tener otra base de datos donde relaciona tablas con información relacionada con asuntos administrativos. 1.1.1. Campos Los cuales se refieren a un atributo o característica como ser edad, sexo, salario, entre otros. Un campo es el menor elemento de dato que puede almacenarse en una base de datos. Por ejemplo si desea almacenar el nombre de un alumno deberá crear un campo y darle un nombre “NombreAlu”, si desea almacenar el apellido se creara otro campo con el nombre “ApellidoAlu”. Así todos los campos que cree se almacenaran en la Base de Datos. 1.1.2. Campo Clave Este tipo de campo se utiliza en las Bases de Datos relacionales para mantener su integridad y establecer las relaciones en las tablas. Las claves principales se conocen también como “primary key”, “campos de índice”, o “índices”. Una tabla puede tener solo una clave principal. Esta clave se utiliza para definir un único registro en toda la tabla, esto significa que no podrá haber dos registros en esta tabla que tengan el mismo valor en este campo. Cualquier intento de agregar más de un registro que tenga un mismo valor en la clave principal dará por resultado un error. 1.1.3. Registros Es un conjunto de campos que se relacionan de alguna manera. Por ejemplo, la edad, el sexo y el salario de un empleado; en este caso los campos edad, sexo y salario están relacionados porque son

65

atributos de un empleado. Los registros son colección de campos relacionados entre si, por ejemplo un registro podría contener los campos NombreAlu, ApellidoAlu, DireccionAlu de manera que estos tres campos definen a un alumno en la Base de Datos. En la teoría formal de Bases de Datos se hace referencia a un registro como una fila de datos. Campo campo campo

NombreAlu ApellidoAlu DireccionAlu

1.2.4. Tablas Se conciben como un conjunto de registro. Por ejemplo, los datos de todos los empleados de una compañía forman una tabla. Cada registro de la tabla es una fila y cada campo de la tabla es una columna. Una tabla es la combinación de campos y registros. Una tabla contiene varios registros, y cada registro contiene varios campos. Las tablas al igual que los campos tienen nombres significativos es decir nombres que sirven para identificar fácilmente su contenido. 2. Relaciones de Bases de Datos Al igual que un registro puede contener campos relacionados entre si una Base de Datos puede contener varias tablas relacionadas entre si. El uso de relaciones es una manera muy eficiente de almacenar información compleja. Las relaciones se establecen en las tablas mediante campos apuntadores o calificadores. Los campos apuntadores se utilizan para apuntar a registros que se encuentran en otras tablas, estos campos se utilizan en relaciones de uno a muchos. Los campos calificadores suelen describir lo que se conoce como relaciones de uno a uno. 2.1. Tipos de Relaciones Al estructurar los datos se debe tener en cuenta los diferentes tipos de relaciones que pueden existir entre tablas. 2.1.1. Relaciones de uno a uno Las relaciones uno a uno se utilizan para vincular los registros de una tabla maestra a un sólo registro que se encuentre en otra tabla. 2.1.2. Relaciones de uno a muchos Las relaciones de uno a muchos se utilizan para vincular los registros de una tabla principal a varios registros de otra tabla. 2.1.3. Relaciones muchos a muchos Las relaciones de muchos a muchos se utilizan para vincular varios registros de una tabla con varios registros de otra. 2. CREACIÓN DE UNA BASE DE DATOS EN MSACCESS Por la forma como fue concebido Visual Basic trabaja muy bien con bases de datos creadas con MSAccess. A continuación se creará una Base de Datos en MSAccess con las siguientes características. Ejemplo 8.1. Crear una base de datos en MSAccess conforme al Ejemplo 3.3 Se consideran las Tablas (archivos de datos) especificadas en la a continuación

66

Tabla 8.1 Nombre de la Tabla Nombre del Campo Tipo de Campo

Alumno AluID NombreAlumno

Autonumerico Texto

Asignatura AsigID NombreAsignatura

Autonumerico Texto

Bimestre BimestreID Bimestre

Autonumerico Texto

Curso CursoID Curso

Autonumerico Texto

Notas NotasID Nombre Alumno Bimestre Parcial Asignatura Nota

Autonumerico Texto Texto Texto Texto Numérico

1. Abra MSAccess , seleccione File en la barra de menús, seleccione nuevo, base de datos en

blanco. Access le pedirá un nombre para su nuevo proyecto nómbrelo “Notas” y haga clic en crear. Ahora crearemos las tablas que conformaran la Base de Datos “Notas”.

2. Haga doble clic en la opción “crear una tabla en vista de diseño”

Figura 8.1

3. En la vista de diseño definiremos los campos de la tabla Alumno.

Figura 8.2

67

4. En primer lugar escriba “AluID” en la primera fila de la columna “Nombre del Campo” y seguidamente en la columna “Tipo de datos” seleccione “Autonumerico”. El tipo de dato Auto numérico es muy propio de MSAccess y se utiliza para mantener la integridad del campo llave.

5. A continuación ingrese el siguiente campo y en tipo de datos seleccione tipo “Texto” para ambos casos como lo muestra la tabla 8.1. Para la tabla alumno nuestro campo clave será

“aluID” con el campo “aluID” seleccionado, haga clic en el icono clave principal en la barra de herramientas. Note que el icono de la llave principal aparece en el campo “aluID”. Figura 8.3

Figura 8.3

6. Ahora ya podemos guardar la tabla “Alumno”. Haga clic en guardar. Access le preguntaraá si desea guardar los cambios, haga clic en aceptar y seguidamente le pedirá el nombre de la tabla nómbrela Alumno. Ahora puede visualizar su tabla Alumno en la sección de Tablas de MS Access

Figura 8.4

Si hace doble clic sobre la tabla Alumno esta deberá verse así:

Figura 8.5

68

7. Siga el mismo procedimiento para crear las Tablas Asignatura, Bimestre, Curso y Notas de acuerdo a las especificaciones de la Tabla 8.1. Al final su Base de Datos deberá verse como en la Figura 8.6.

Figura 8.6

Ahora que nuestra Base de Datos esta lista podemos usarla en una aplicación para Visual Basic.

Ahora se escribirá una aplicación para la captura de datos completamente funcional. Esta aplicación deberá poder acceder a tablas de datos que se encuentran en una base de datos (diseñada en MS Access) existente que le permitirá agregar, editar, y eliminar registros. Ejemplo 8.2. Escribir una aplicación que manipule la base de datos del ejemplo anterior.

1. Para esta aplicación se utilizarán varios formularios. El principal deberá tener la siguiente interfaz:

69

1. Para iniciar Abra Visual Basic, seleccione el icono EXE STANDARD y haga clic en aceptar (abrir). En el cuadro de propiedades del formulario seleccione la propiedad Name y sustituya Form1 por frm_Inicio y en la propiedad Caption escriba Formulario de Inicio tal y como se muestra en la Figura 8.1:

Figura 8.1

El resto de objetos en el formulario deberán cumplir con las características de la tabla siguiente:

Tabla 8.1. Adición de controles al formulario Inicio. Objeto Propiedad Valor Command1 (Nombre)

Caption cmd_alu Alumno


cmd_asig Asignatura


cmd_Bimestre Bimestre


cmd_Curso Curso


cmd_Notas Notas


cmd_Salir Salir

2. Pulse doble clic en Alumno y escriba el siguiente código

Private Sub cmd_alu_Click() frm_alu.Show ‘carga el Formulario frm_alu End Sub

3. Haga click en el menú Proyecto, seleccione “Propiedades de Proyecto”. En la Opción

“Objeto Inicial” de la viñeta General Asegúrese de que el formulario frm_inicio esta seleccionado, para que sea este el formulario de inicio del proyecto.

70

4. Haga click en el menú Proyecto y agregue un formulario. En el cuadro de propiedades del

formulario seleccione la propiedad (Nombre) y sustituya Form1 por frm_alu. En la propiedad Caption escriba “Mantenimiento de Alumnos”. El formulario se vera así:

5. Seleccione Proyecto en la barra de menús, seleccione Componentes, en la sección Controles seleccione el componente Microsoft ADO Data Control 6.0 (OLEDB), finalmente pulse clic en Aceptar.

6. Del cuadro de herramientas seleccione con doble click el Control ADO 6.0 (que acaba de

agregar).

Objeto Inicial

71

7. En el cuadro de propiedades del control Adodc seleccione Connection string, este le llevará a la Pagina de propiedades donde puede seleccionar el origen de los datos.

8. Seleccione la tercera opción, usar cadena de conexión y haga clic en Generar, ahora tiene una lista de proveedores de datos.

Control ADODB

72

9. Como en este ejemplo usaremos una base de datos de MS Access seleccione Microsoft Jet

4.0 OLE DB Provider, haga clic en Siguiente. Aquí seleccionará la Base de Datos y su ubicación. Seleccione la Base de Datos Notas. Seleccione la casilla contraseña en blanco, luego prueba de conexión, si esta es satisfactoria haga clic en Aceptar.

73

10. Pulse clic con el botón derecho sobre el control Adodb y seleccione propiedades del control Adodc. Luego seleccione la viñeta Origen de registros y en el tipo de comandos seleccione la opcion 2-adCmdTable. Luego, en Tabla o nombre de procedimiento almacenado seleccione la tabla Alumno y pulse Aceptar.

El control ADO ya esta vinculado a la base de datos Notas y a la tabla Alumno. Ahora puede agregar controles al formulario para ser enlazados al control ADO. Al proceso de asociar un control con un campo de una tabla se le conoce como enlazar un control, por ello a estos se les llama controles enlazados.

11. Ahora coloque los objetos necesarios al formulario para obtener la siguiente ventana:

En el objeto Text1se debe establecer dos propiedades para que interactuar con el control ADO. Las propiedades son las siguientes tal y como se muestra en la figura:

74

Es conveniente establecer la propiedad Locked del Control Text1 como True, de esta manera no se podrá modificar el contenido de dicho control. Lo anterior es necesario ya que el valor de este campo es generado automáticamente por Access y debe ser un valor único por cada registro. Las propiedades de cada objeto deben ser como en la tabla siguiente:


Caption Frm_alum Mantenimiento de Alumno

Adodc1 (Nombre) Caption

Adodc_alu En blanco

Label1 Caption ID de Estudiante Label2 Caption Nombre y Apellido Text1 DataSourse

DataField Locked

Adodc_alu AluID True

Text2 DataSuorce DataField

Adodc_alu NomApe


cmd_Agregar &Agregar


cmd_Update &Guardar


cmd_Eliminar &Eliminar


cmd_Editar E&ditar


cmd_Salir &Salir

Al agregar un ampersand (&) a la propiedad Caption la letra que le sigue será subrayada, a esta tecla se le conoce como tecla aceleradora y le indica al usuario que si oprime Alt + la tecla subrayada será como si hubiera hecho clic sobre el control. Su formulario deberá lucir más o menos así:

12. Haga doble clic en Agregar y escriba el código siguiente:

Private Sub cmd_Agregar_Click()

75

Adodc_alu.Recordset.AddNew 'agrega un registro a la tabla Text2.SetFocus cmd_Agregar.Enabled = False 'deshabilita el control cmd_agregar cmd_Eliminar.Enabled = False 'deshabilita el control cmd_eliminar cmd_Editar.Enabled = False 'deshabilita el control cmd_Editar cmd_Guardar.Enabled = True End Sub Adodc_alu.Recordset.AddNew prepara la tabla para agregar un Nuevo registro. La propiedad SetFocus en el control Text2 hace que en el momento de hacer clic sobre el botón Nuevo el enfoque pase al control Text2 lo que lo deja listo para comenzar a ingresar los datos. Al establecer la propiedad Enable del control cmd_Agregar como False deshabilita el control hasta que este sea habilitado en el evento Guardar (en el botón Guardar).

13. Haga doble clic en el control Guardar y escriba el siguiente código:

Private Sub cmd_Guardar_Click() Adodc_alu.Recordset.Update 'Actualiza la tabla Adodc_alu.Refresh Adodc_alu.Recordset.MoveLast 'se posiciona en el ultimo registro cmd_Agregar.Enabled = True 'deshabilita el control cmd_agregar cmd_Eliminar.Enabled = True 'deshabilita el control cmd_eliminar cmd_Editar.Enabled = True 'deshabilita el control cmd_update cmd_Guardar.Enabled = False End Sub

14. Haga doble clic en el control Eliminar y escriba el siguiente código: Private Sub cmd_Eliminar_Click() Adodc_alu.Recordset.Delete Adodc_alu.Recordset.MoveLast End Sub

15. Haga doble clic en el control Salir y escriba el siguiente código: Private Sub cmd_Salir_Click() Unload Me 'Cierra el formulario End Sub

16. Haga doble clic en el control Editar y escriba el siguiente código: Private Sub cmd_Editar_Click() Adodc_alu.Refresh cmd_Agregar.Enabled = False cmd_Guardar.Enabled = True End Sub Una vez que ha concluido de agregar el código a cada evento, el formulario ya esta listo para ser ejecutado.

17. Pulse doble clic sobre formulario y escriba el siguiente código: Private Sub Form_Load() cmd_Guardar.Enabled = False End Sub Necesitamos crear un formulario para cada tabla de la Base de Datos Notas que creamos en la sección anterior. Para ello seguiremos los mismos pasos que en el formulario Mantenimiento de Alumnos. Solo que para agregar los formularios subsiguientes lo haremos desde el menú Proyecto y agregaremos un formulario para cada Tabla.

76

18. Guarde la aplicación en una carpeta llamada Colegio. a. El formulario guárdelo con el nombre frm_alu b. El proyecto con nombre Notas

19. Creación del Formulario Mantenimiento de Asignatura. Agregue al proyecto un nuevo formulario y sigua las especificaciones.

Para vincular la base de datos correspondiente a Adodc_Asig debe seguir los pasos 6 al 10. Pero en este último paso debe seleccionar Asignatura para Tabla o nombre de procedimiento almacenado.

Cada objeto debe los siguientes valores para sus propiedades. Debe repetir los pasos anteriores cuando sea pertinente a fin de obtener el efecto deseado.


Caption Frm_Asig Mantenimiento de Asignatura

77

Objeto Propiedad Valor Adodc1 (Nombre)

Caption Adodc_Asig En blanco

Text 1 DataSourse DataField Locked

Adodc_Asig AsigID True

Text 2 DataSourse DataField

Adodc_Asig NombreAsignatura

Label1 Caption ID Asignatura Label2 Caption Asignatura Command1 (Nombre)

Caption cmd_Agregar &Agregar


cmd_Guardar &Guardar




cmd_Editar E&ditar


cmd_Salir &Salir

20. En el Formulario de Inicio pulse doble clic en Asignatura y escriba el siguiente código

Private Sub cmd_Asig_Click() frm_Asig.Show End Sub

21. Guarde la aplicación en una carpeta llamada Colegio. El nuevo formulario guárdelo con el

nombre frm_Asig 22. Creación del formulario Bimestre. Agregue al proyecto un nuevo formulario y sigua las

especificaciones.

Para vincular la base de datos correspondiente a Adodc_Bimestre debe seguir los pasos 6 al 10. Pero en este último paso debe seleccionar Bimestre para Tabla o nombre de procedimiento almacenado.

78


Objeto Propiedad Valor

Form1 (Nombre) Caption

Frm_Bimestre Bimestre


Adodc_Bimestre En blanco


Adodc_Bimestre BimestreID True


Adodc_Bimestre Bimestre

Label1 Caption ID Asignatura Label2 Caption Asignatura Command1 (Nombre)







cmd_Editar E&ditar


cmd_Salir &Salir

23. En el Formulario de Inicio pulse doble clic en Bimestre y escriba el siguiente código

Private Sub cmd_Bimestre_Click() frm_Bimeste.Show End Sub

79

24. Guarde la aplicación en una carpeta llamada Colegio. El nuevo formulario guárdelo con el nombre frm_Bimestre

25. Creación del formulario Mantenimiento de Cursos. Agregue al proyecto un nuevo formulario y sigua las especificaciones.

Para vincular la base de datos correspondiente a Adodc_Curso debe seguir los pasos 6 al 10. Pero en este último paso debe seleccionar Curso para Tabla o nombre de procedimiento almacenado. Cada objeto debe los siguientes valores para sus propiedades. Debe repetir los pasos anteriores cuando sea pertinente a fin de obtener el efecto deseado.


Caption Frm_Curso Mantenimiento de Curso


Adodc_Curso En blanco


Adodc_Curso CursoID True


Adodc_Curso NombreCurso

Label1 Caption ID Curso: Label2 Caption Curso: Command1 (Nombre)







cmd_Editar E&ditar


cmd_Salir &Salir

80

26. En el Formulario de Inicio pulse doble clic en Curso y escriba el siguiente código Private Sub cmd_Curso_Click() frm_Curso.Show End Sub

27. Guarde la aplicación en una carpeta llamada Colegio. El nuevo formulario guárdelo con el nombre frm_Curso

28. Para el siguiente formulario Mantenimiento de Notas necesitamos agregar un componente más a nuestro proyecto. Pulse clic en el menú proyecto, componentes, y seleccione Microsoft DataList Controls 6.0, aceptar. Con esto esta agregando dos controles más el DataList y el DataCombo. Construya el formulario siguiente:



Caption Frm_Nota Mantenimiento de Notas


Adodc_Nota En blanco

Adodc2 (Nombre) Caption Visible

Adodc_Asig Asignatura False


Adodc_Curso Curso False

81

Objeto Propiedad Valor Adodc4 (Nombre)

Caption Visible

Adodc_Parcial Bimestre False


Adodc_Alu Alumno Flase

Data1 (Nombre) Text

DataCombo_nomcurso Nombre del Curso

Data2 (Nombre) Text

DataCombo_bimestre Bimestre

Data3 (Nombre) Text

DataCombo_nomape Nombre Apellido

Data4 (Nombre) Text

DataCombo_nomasig Asignatura


Adodc_Nota NotasID True


Adodc_Nota Bimestre

Text3 DataSourse DataField

Adodc_Nota NombreCurso


Adodc_Nota NombreAlumno


Adodc_Nota Asignatura


Adodc_Nota Nota

Label1 Caption ID Notas: Label2 Caption Nombre del Curso: Label3 Caption Bimestre: Label4 Caption Nombre del Alumno: Label5 Caption Asignatura: Label6 Caption Nota: Command1 (Nombre)







cmd_Editar E&ditar


cmd_Salir &Salir

En este formulario se capturarán algunos datos desde los controles Data Combo para guardarlos en la tabla Notas.

82

29. Para comenzar seleccione el control Adodc_alu. Haga clic con el botón derecho del Mouse, haga clic en propiedades, usar cadena de conexión, generar, seleccione la Base de Datos Notas, probar conexión, aceptar.

30. En la viñeta Origen de Registros, seleccione el tipo de comando 8-adcmdUnknown, en texto de comando escriba la siguiente línea “select NombreCurso from curso”. Clic en Aceptar.

La obtención de los registros en este caso se realiza por medio de una consulta SQL de esta manera se obtiene solo el campo que se necesita.

31. La propiedad “Visible” en los Controles Adodc los hará invisibles durante la ejecución del

programa. Conecte el resto de los controles Adodc y copie la línea de consulta SQL según lo indica la tabla siguiente:

Objeto Origen de registro Valor

Adodc_Bimestre Texto de comando SQL select bimestre from bimestre Adodc_alu Texto de comando SQL select NomApe from Alumno Adodc_asig Texto de comando SQL select NombreAsignatura from

Asignatura

El control Adodc_nota se conecta normalmente a la Base de Datos y a la Tabla Notas.

Ahora que se ha conectado los controles Adodc. Conecte los controles Data Combo con su respectiva fuente de datos, establezca las propiedades de cada uno según la tabla siguiente:

Objeto Propiedad Valor DataCombo_nomcurso RowSource

List Field Adodc_nomcurso NombreCurso

DataCombo_bimestre Row Source List Field

Adodc_parcial Bimestre

DataCombo_alu Row Source List Field

Adodc_alu NomApe

DataCombo_asig Row Source List Field

Adodc_asig NombreAsignatura

83

Ahora se agregará algo de código en el evento Data Combo para pasar su contenido a los Text Box para completar la captura de datos. Agregue el siguiente código como lo muestra la tabla anterior

32. Pulse doble clic sobre DataCombo_nomcurso y escriba el siguiente código: Private Sub DataCombo_nomcurso_Click(Area As Integer) Text1.Text = DataCombo_nomcurso.Text End Sub

33. Pulse doble clic sobre DataCombo_bimestre y escriba el siguiente código: Private Sub DataCombo_bimestre_Click(Area As Integer) Text3.Text = DataCombo_bimestre.Text End Sub

34. Pulse doble clic sobre DataCombo_nomape y escriba el siguiente código: Private Sub DataCombo_nomape_Click(Area As Integer) Text4.Text = DataCombo_nomape.Text End Sub

35. Pulse doble clic sobre DataCombo_nomasig y escriba el siguiente código: Private Sub DataCombo_nomasig_Click(Area As Integer) Text5.Text = DataCombo_nomasig.Text End Sub

36. Haga doble clic en el formulario y escriba el siguiente código: Private Sub Form_Load() DataCombo1.Enabled = False DataCombo2.Enabled = False DataCombo3.Enabled = False DataCombo4.Enabled = False End Sub

Se establece la propiedad Enable = False de los Controles Data Combo para deshabilitarlos y serán habilitados en el evento Agregar.

37. En el formulario, pulse doble clic sobre Agregar y escriba el siguiente código: Private Sub cmd_agregar_Click() DataCombo1.Enabled = True DataCombo2.Enabled = True DataCombo3.Enabled = True DataCombo4.Enabled = True Adodc_nota.Recordset.AddNew Text2.SetFocus cmd_guardar.Enabled = True End Sub

38. En el formulario, pulse doble clic sobre Guardar y escriba el siguiente código: Private Sub cmd_guardar_Click() Adodc_nota.Recordset.Update cmd_guardar.Enabled = False End Sub

39. En el formulario, pulse doble clic sobre Eliminar y escriba el siguiente código: Private Sub cmd_eliminar_Click() Adodc_nota.Recordset.Delete Adodc_nota.Recordset.MoveLast End Sub

40. En el formulario, pulse doble clic sobre Modificar y escriba el siguiente código:

84

Private Sub cmd_modificar_Click() Adodc_nota.Refresh cmd_guardar.Enabled = True End Sub

41. En el formulario, pulse doble clic sobre Agregar y escriba el siguiente código: Private Sub cmd_Salir_Click() Unload Me End Sub

42. En el Formulario de Inicio pulse doble clic en Nota y escriba el siguiente código

Private Sub cmd_Nota_Click() frm_Nota.Show End Sub

43. Guarde la aplicación en una carpeta llamada Colegio. El nuevo formulario guárdelo con el nombre frm_Nota

44. Ejecute la aplicación y prueba con diferentes valores. RESUMEN Existen diferentes formas de gestionar la información, por ejemplo los sistemas de archivos y los sistemas de bases de datos. Dentro de los sistemas de bases de datos, las Bases de Datos Relacionales dominan actualmente en el mundo de la información. En un sistema de bases de datos relacional se establecen diferentes relaciones entre las entidades. A partir de dichas relaciones se definen los archivos de datos. Visual Basic permite manipular diferentes formatos de archivos de datos pero en este material se expusieron las bases de datos generadas con MSAccess. EJERCICIOS

1. Escriba una base de datos en Access para administrar jugadores en los equipos de la liga nacional. Luego escriba una aplicación para la gestión de datos. La información que se desea manipular es Nombre del jugador, posición que juega, equipo a que pertenece. Y para el equipo se desea su nombre y posición en la tabla de clasificación.

2. Repita el ejercicio anterior pero con datos de su institución. Planifique bien la estructura de la base de datos y la interfaz de usuario ya que este puede ser un problema complejo.

EVALUACIÓN Se considerará la realización del ejercicio 1 y la guía de trabajo que se entregará en el desarrollo del taller.

85

UNIDAD IX. PROGRAMA DE INSTALACIÓN DE APLICACIONES CONTENIDO

1. Instalación de Aplicaciones OBJETIVOS DE LA UNIDAD

1. Generar un programa de instalación de aplicaciones Todas las aplicaciones que se han escrito hasta el momento se encuentran en su código fuente y para ser ejecutadas es necesario que se encuentre instalado el Visual Basic en la computadora. Normalmente, cuando se escribe una aplicación se debe generar el código objeto a fin de poder distribuirla en otras computadoras aun cuando no tengan instalado Visual Basic. Este proceso genera un archivo de extensión EXE y posiblemente otros archivos complementarios dependiendo de la opción que se elija para tal fin. Otra de las razones por las que no se distribuye el código fuentes es para proteger los derechos de autor, a menos que el autor de la aplicación sea partidario de la distribución de código libre. En esta unidad se explicará solamente un método, aunque para aplicaciones sencillas existe un proceso más corto. Se presenta un ejemplo para ilustrar el proceso, para ello es necesario haber instalado las Herramientas de Microsoft Visual Studio 6.0 Ejemplo 9.1. Crear un programa de instalación para la aplicación generada en el Ejemplo 5.1

1. Pulse clic en el botón Inicio del Escritorio, seleccione Todos los programas, luego Microsoft Visual Studio 6.0, luego Herramientas de Microsoft Visual Studio 6.0 y finalmente Asistente para empaquetado y distribución. Aparecerá la ventana:

2. Pulse clic en Examinar, aparecerá la ventana:

86

3. Busque la carpeta que contiene la aplicación Notas y pulse clic en el proyecto Notas, luego

pulse clic en Abrir. Regresará a la ventana anterior. Pulse clic en empaquetar, posiblemente aparezca la ventana siguiente:

4. Esto ocurre cuando no existe un archivo ejecutable (extensión exe) para la aplicación.

Entonces ante la pregunta ¿Desea volver a compilar? Pulse clic en Si, aparecerá momentáneamente la ventana:

La cual permanecerá un poco de tiempo en relación al tamaño de la aplicación. Espere hasta que la ventana se cierre, cuando esto ocurra aparecerá la ventana:

87

5. Esta ventana permite elegir el tipo de empaquetado. Seleccione Paquete de instalación

estándar y pulse clic en Siguiente. Aparecerá la ventana:

La cual permite seleccionar la carpeta donde se almacenará el programa de instalación. Déje tal y como está y pulse clic en Siguiente. Aparecerá la ventana:

88

6. Pulse clic en Si, aparecerá la ventana

7. Esta ventana permite agregar archivos que se incluyen en el paquete. Deje todo como está y

pulse clic en Siguiente. Aparecerá la ventana:

89

Esta ventana permite seleccionar entre crear un único archivo cab o múltiples. Si la aplicación es pequeña seleccione Un archivo único. Si la aplicación es grande y la distribuirá en disquetes entonces seleccione Múltiples archivos, pero si la distribución es por medio de CD puede seleccionar cualquiera de las dos.

8. Deje todo como está y pulse clic en Siguiente. Aparecerá otra ventana, escriba Notas en Título de la instalación y pulse clic en Siguiente. Aparecerá la ventana:

90

La cual permite seleccionar los grupos del menú Inicio y otros elementos que se crearán al momento de ejecutar la instalación. Deje todo como está y pulse clic en Siguiente. Aparecerá la ventana:

9. Deje todo como está y pulse clic en Siguiente. Aparecerá la ventana:

91

10. Pulse clic en la casilla de verificación de Notas.exe y pulse clic en Siguiente. Aparecerá otra ventana. En la sección Nombre de secuencia de comandos escriba Paquete de Instalación Notas y pulse clic en Finalizar. Aparecerá una ventana similar a la del paso 4, espere hasta que esta desaparezca. Si todo ocurrió con normalidad aparecerá una ventana de información del proceso, si lo desea pulse clic en Guardar informe de lo contrario pulse clic en Cerrar.

11. Finalmente pulse clic en Cerrar de la ventana inicial. 12. Entre a la carpeta donde está la aplicación para la cual se creó el programa de instalación.

Allí encontrará una carpeta llamada Paquete. El contenido de dicha carpeta puede ser transferido a un disquete u un CD, dependiendo del tamaño del mismo.

13. Si ejecuta el archivo Setup (pulsando doble clic sobre él) entonces iniciará el proceso de instalación de la aplicación. Ejecútelo.

14. Localice la aplicación instalada en Inicio, Todos los programas, Proyecto 1 y pulse clic en Proyecto 1. La aplicación se ejecutará como cualquier otra aplicación en ambiente Windows.

La venta de este forma de distribución de aplicaciones es que es más personalizada y se tiene acceso ciertos segmentos de la aplicación (pero no para editarla). También se puede desinstalar la aplicación siguiendo el proceso mediante el Panel de Control de Windows en Agregar o Quitar programas. Además si la aplicación es muy grande permite dividir en varios archivos Cab que facilitan su distribución. El método alterno crea un solo archivo exe que no es posible segmentar. Para utilizar ese método basta con abrir la aplicación, Seleccionar Archivo del menú principal y pulsar clic en Generar Notas.exe (si la aplicación tiene ese nombre). RESUMEN Las aplicaciones no se distribuyen en código fuente pues para que sean ejecutadas en computadoras que no tienen instalado el Visual Basic es necesario ejecutar el programa objeto (archivo ejecutable) Visual Studio proporciona herramientas para la distribución de aplicaciones EJERCICIOS EVALUACIÓN

92

ANEXO I. TABLA DE CÓDIGOS ASCII

ASCII

Hex

Símbolo

0 1 2 3 4 5 6 7 8 9

10 11 12 13 14 15

0 1 2 3 4 5 6 7 8 9 A B C D E F

NUL SOH STX ETX EOT ENQ ACK BEL BS

TAB LF VT FF CR SO SI

ASCII

Hex

Símbolo

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F

DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US

ASCII

Hex

Símbolo

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F

(espacio)! " # $ % & ' ( ) * + , - . /

ASCII

Hex

Símbolo

48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F

0 1 2 3 4 5 6 7 8 9 : ; < = > ?

ASCII

Hex

Símbolo

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F

@ A B C D E F G H I J K L M N O

ASCII

Hex

Símbolo

80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F

P Q R S T U V W X Y Z [ \ ] ^ _

ASCII

Hex

Símbolo

96 97 98 99

100 101 102 103 104 105 106 107 108 109 110 111

60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F

` a b c d e f g h i j k l

m n o

ASCII

Hex

Símbolo

112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F

p q r s t u v w x y z { | } ~ �

93

GLOSARIO DE TÉRMINOS Aplicación, 18. Es un programa que realiza

un un conjunto de tareas. En Visual Basic se interpreta como un conjunto de proyectos.

Atributos, 5. Característica que define a un objeto de estudio.

Bases de Datos Relacionales, 67. Conjunto de archivos de datos en los que se definen relaciones matemáticas entre las entidades.

Compilador, 8. Programa de computadora que traduce el código fuente en código objeto, es decir el código del lenguaje de programación a lenguaje de máquina.

Entorno de Desarrollo Integrado, 5, 9. Conjunto de herramientas que se presentan en un entorno único y que facilitan el desarrollo de aplicaciones.

Evento, 7. En la programación orientada a objetos, ocurrencia de una acción asociado a un objeto . En Visual Basic se definen a través de funciones y procedimientos.

Hechos, 5. Estado de la ocurrencia de un proceso.

Objetos, 6. E Porgramación orientada a objetos es un conjunto de propiedades, métodos y eventos que definen el comportamiento de un objeto de la realidad.

Paradigma, 5. Conjunto de normas que rigen el pensamiento.

Paradigmas de programación, 5. Paradigma que determina la manera como se interpreta un problema y como se desarrolla la solución.

Procesos, 5. Conjunto de acciones Programación imperativa, 5. Paradigma de

programación donde los elementos fundamentales son las sentencias sobre atributos, hechos y procesos.

Programación modular, 5. Paradigma de programación donde un problema se concibe como un conjunto de subproblemas.

Programación orientada a objetos, 6. Paradigma de programación donde un problema se concibe como un conjunto de objetos que interactuan en un medio ambiente.

Programación visual, 6. Paradigma de programación donde los elementos visuales concebidos como objetos son los elementos principales.

Visual Basic, 5. Lenguaje de Porgramación en ambiente visual para Microsoft Windows.

94

BIBLIOGRAFÍA

(1) Microsoft Visual Basic 6. Ayuda en línea. (2) Halvorson, M. Aprenda Visual Basic 6.0 ya. McGraw-Hill/Interamericana. España,1999. (3) Smith, C. y Amundsen, M. Aprendiendo Programación de Bases de Datos con Visual Basic

6. Prentice Hall. México, 1999. (4) Ceballos, F. Visual Basic Versión 5, Curso de Programación. Alfaomega. Colombia, 1998. (5) Castro, L. Metodología de Programación con Aplicaciones en Turbo Pascal. Honduras,

2006. (6) Wikipedia, Enciclopedia libre. es.wikipedia.org. (7) La Web del programador. www.lawebdelprogramador.com

Education

Introducción a visual basic upn 6 final