Aprenda Custom Corseware.visual Basic 2008.Demo

Aprenda Custom CourseWare

Cuando ningún material impreso se ajusta a tus necesidades específicas de conocimiento, nosotros podemos ayudarte.

Puedes armar tu propio texto a partir de los módulos que componen nuestros más de 20 cursos profesionales: Visual Studio, VB, C#, ASP.NET, ADO.NET, SQL Server, Algoritmos, DB, ITIL, COBIT.

Integramos un texto con los temas que tú elijas, a un precio increíble.

• Materiales en español.• Materiales con apoyos didacticos

(Presentaciones, Videos, Archivos complementarios, etc.)

• Estructura didáctica de la serie de libros “Aprenda Practicando”: sólo ejercicios pertinentes aplicables en el ejercicio profesional.

01-800-APRENDA | [email protected]

MMiiccrroossoofftt VViissuuaall BBaassiicc

EEddiicciióónn 22000088

Felipe Ramírez

Facultad de Contaduría Pública y Administración

Facultad de Ingeniería Mecánica y Eléctrica

Universidad Autónoma de Nuevo León, México.

Francisco Salazar

Facultad de Contaduría Pública y Administración

Universidad Autónoma de Nuevo León, México.

MÉXICO WWW.APRENDA.MX

01-800-APRENDA

El contenido de este documento está sujeto a cambios sin previo aviso. Las organizaciones, productos, personas, o eventos referidos en los ejemplos son ficticios, por lo cual no debe establecerse relación alguna, inferirse o atribuirse dicha relación, respecto a organizaciones, produc-tos, personas, o eventos de la realidad.

El contenido del presente material tiene protegidos los derechos de au-tor de la manera más amplia posible, por lo cual queda estrictamente prohibida su reproducción parcial o total.

Queda estrictamente prohibido su almacenamiento o introducción a cualquier sistema de recuperación de datos.

Queda estrictamente prohibida su reproducción o transmisión en cual-quier medio conocido o por conocer, sin importar el propósito. La re-producción sólo podrá realizarse previa autorización por escrito del titular de los derechos.

De acuerdo a lo establecido por la Ley Federal del Derecho de Autor, se someterá a proceso a aquél que PRODUZCA, REPRODUZCA, ALMACENE, DISTRIBUYA, TRANSPORTE O COMERCIALICE COPIAS DE LA OBRA SIN LA AUTORIZACIÓN DEL TITULAR DE LOS DERECHOS.

Los nombres de organizaciones y productos comerciales que aparecen en el presente material son propiedad de sus respectivos dueños y titu-lares de derechos.

© DERECHOS RESERVADOS POR LOS RESPECTIVOS TITULARES

Aprenda Practicando

http://www.Aprenda.mx

1

Técnicas de desarrollo usando

Visual Studio 2008

Contenido:

Objetivos ................................................................................. 2 Soluciones y proyectos ............................................................ 3 Trabajo colaborativo recomendado en .NET .......................... 5 Creando aplicaciones en Visual Studio .................................. 7 Elementos de sintaxis de Visual Basic ................................ 10 Ejercicios 12 Lab.01: Creando una aplicación en Visual Studio

2008. .................................................................... 13 AAbbrriieennddoo VViissuuaall SSttuuddiioo ........................................................................................ 1133 CCrreeaannddoo uunnaa ssoolluucciióónn ............................................................................................ 1144 AAggrreeggaannddoo pprrooyyeeccttooss aa uunnaa ssoolluucciióónn ............................................ 1166 HHeerrrraammiieennttaass ddee TTeexxtt EEddiittoorr ...................................................................... 1188 IInntteelllliisseennssee yy ddeetteecccciióónn ddiinnáámmiiccaa ddee eerrrroorreess ...................... 2200 MMooddiiffiiccaannddoo ccóóddiiggoo uussaannddoo TTeexxtt EEddiittoorr .................................. 2233

2 Programación en Visual Basic 2008 Edition

Objetivos

Los objetivos del presente módulo son los siguientes:

1. Aprenderá la forma en que Visual Studio organiza el trabajo en soluciones y proyectos.

2. Aprenderá el uso de herramientas de Visual Studio 2008 y la optimización del espacio de trabajo.

3. Aprenderá a construir y depurar aplicaciones.

Módulo 1: Técnicas de desarrollo usando Visual Studio 2008 3

Soluciones y proyectos

Si se utiliza Visual Studio, todo nuestro trabajo se organizará en soluciones y proyectos.

Una solución es el nivel más alto o global de organización en Visual Studio, y consiste en una colección de proyectos, administrados en una sola estructura.

Las soluciones almacenan información respecto a los proyectos que agrupan, las dependencias entre estos, así como el orden de construcción (compilación y generación de ensamblados) que deben tener entre sí.

Las soluciones tienen la extensión sln, y tienen algunas limitantes: la primera es que sólo se puede tener una solución abierta en una instancia de Visual Studio; la segunda es que una solución no puede contener a otra solución.

Los proyectos son colecciones de archivos fuente, que juntos son compilados como un archivo de salida .NET (ensamblado / assembly).

Cada proyecto puede componerse por interfaces de usuario (Windows Forms, Web Forms, Mobile), archivos de código (vb, cs), referencias a clases de .NET Framework o a bibliotecas creadas


por el usuario, archivos XML, HTML, y en fin, todo lo necesario para generar un ensamblado.

Visual Studio posee más de 90 diferentes tipos de proyectos. La ventaja de utilizarlos es que seleccionando el tipo de proyecto adecuado, Visual Studio se encarga de crear los archivos mínimos para el tipo de aplicación seleccionada, y además establece de forma automática las referencias a clases de .NET Framework usualmente requeridas.

Es importante mencionar que algunos proyectos muy especiales no generarán ensamblados, por ejemplo proyectos de setup, pero son los menos.

Un proyecto puede formar parte de varias soluciones, por lo que es posible organizar por módulos una aplicación, y al mismo tiempo se puede tener una solución maestra que englobe a todos los proyectos. Subdividir es una buena práctica, ya que al momento de estar desarrollando y solicitar la compilación de los programas (Rebuild), se compilarán todos los proyectos de la solución.

Esto puede convertirse en un problema en el caso de aplicaciones grandes: en primera instancia, porque pueden ser muchos los proyectos a compilar, lo que tomará mucho tiempo; en segunda instancia, porque en los proyectos grandes intervienen varios programadores, y es posible que tenga que estar lidiando con proyectos que ya funcionaban pero que ahora están presentando errores, mismos que se tendrán que corregir antes de que usted pueda ver su programa compilado.

Las soluciones deben planearse cuidadosamente con todo el equipo de desarrolladores.

Que una solución integre a todos los proyectos de otra solución, no quiere decir que una solución está dentro de otra. Eso permite que cada persona pueda crear las soluciones que requiera, sin impactar el trabajo de otros y sin perjudicar la integración de software, que se da por la unión de proyectos.

Es importante notar que en una misma solución pueden convivir proyectos que utilizan diferentes lenguajes .NET, pero un proyecto sólo puede tener código fuente de un solo lenguaje.


Trabajo colaborativo recomendado en .NET

Se conoce como desarrollos colaborativos a las iniciativas de desarrollo que son tan grandes que el trabajo debe distribuirse en varios equipos de desarrollo.

Piense en proyectos de desarrollo de software tan grande y complejo como Microsoft Excel. Es impensable que un solo equipo de desarrolladores esté a cargo de todas y cada una de las funciones del software. Seguramente un equipo de desarrolladores se ocupa de la interfaz gráfica, otro se ocupa de Solver, otro de las capacidades de graficación, etcétera.

Imagine que alguien quiere compilar la parte que está desarrollando, y que ello implicará compilar todos los programas de todos los equipos de trabajo. Eso sería inadmisible en términos de tiempo y procesamiento.

Partimos del supuesto que mantener las cosas simples es lo mejor. Trabajar con el mínimo de elementos, suficientes y necesarios para obtener los resultados que buscamos nos mantendrá más enfocados en el trabajo.

Cuando se trabaja en ambientes colaborativos se recomiendan las siguientes prácticas relacionadas con los proyectos y las soluciones.


1. Se debe dividir la aplicación en módulos, e incluso sub-módulos. Cada módulo y sub-módulo es una unidad de labores de desarrollo, que contará con un responsable. De esa forma sólo se trabaja con los archivos del módulo; la compilación y depuración sólo se realizará sobre lo que estamos trabajando, y no sobre lo que están trabajando otros.

2. Se recomienda que el trabajo de desarrollo de módulos y sub-módulos se haga en un equipo local, y nunca en un ambiente de producción.

3. Se debe tener una solución por cada módulo, y una solución por cada sub-módulo, si aplica.

4. Cada solución tiene un responsable.

5. Los desarrollos de los sub-módulos sólo se agregan al módulo en caso de estar probados.

6. Todas las librerías de uso común deben ser administradas por un responsable, aún y cuando no sea quien las desarrolla. Debe haber una solución para el manejo de las librerías de uso común.

7. Sólo el responsable de la solución que contiene las librerías de uso común puede autorizar las modificaciones a las librerías; al autorizar una modificación deberá comunicar de la actualización a todos los equipos de trabajo.

8. Se debe tener una solución que integre todos los recursos y programas que componen la aplicación, pero no se trabaja sobre ella. En esta solución sólo se integran los recursos que ya han sido probados a nivel módulo.

9. La solución que integra toda la aplicación es la que se compilará finalmente para generar el entregable.


Creando aplicaciones en Visual Studio

El procedimiento más sencillo para la creación de una solución es ingresando a Visual Studio. Aparecerá la página principal de la herramienta, denominada Start Page (página de inicio), desde la cual se pueden abrir proyectos nuevos o existentes, así como consultar información de Visual Studio y la plataforma .NET.


En Start Page se selecciona la opción de menú File – New – Project (o presionar CTRL-MAYÚS-N). Aparecerá la ventana New Project, que nos permite seleccionar el lenguaje que deseamos utilizar, así como el tipo de proyecto que deseamos construir.

Al proporcionar los datos del proyecto que se desea agregar, automáticamente se tendrá una solución del mismo nombre. La desventaja de esta modalidad es que en aplicaciones grandes,


nunca un proyecto y una solución se llaman igual, ya que la solución es un concepto global, mientras que un proyecto es específico.

Cuando la creación de un proyecto motiva la creación automática de una solución homónima, Visual Studio entiende que la solución se compone de un solo proyecto, a lo que se llama proyecto autónomo (stand-alone project); en este tipo de proyecto no se da mucha relevancia al concepto de solución dentro del entorno integrado de desarrollo.

Es indispensable saber qué lenguaje .NET es el que desea utilizar (Project Types), y decidido esto, es necesario saber qué tipo de aplicación se desea (Templates). Las plantillas o templates permiten predeterminar los recursos iniciales de la aplicación.

Visual Studio preguntará dónde se desea guardar la aplicación (Location), y con qué nombre (Name). Los archivos fuente que usted genere se encontrarán en el directorio que usted especifique. Se generará un archivo que mantendrá la referencia de todos los archivos involucrados en la solución, y tendrá la extensión sln. Es posible que la solución tenga un nombre distinto al del proyecto, por lo que se podrá colocar un nombre específico a la solución (Solution Name).


Elementos de sintaxis de Visual Basic

Visual Basic es el heredero de la tradicional sintaxis del lenguaje Visual Basic 6.0. Para no comenzar a desarrollar programas sin un conocimiento básico de la sintaxis del lenguaje, enumeramos algunas características esenciales.

1. Visual Basic es no sensitivo a mayúsculas y minúsculas (non case sensitive).

2. Las líneas de código terminan al encontrarse un salto de línea (CR/LF).

3. El continuador de línea es un guión bajo ( _ ); el continuador de línea no debe interrumpir expresiones, antes de él debe haber un espacio en blanco, y después de él no debe escribirse nada.

4. Un bloque de código es el conjunto de líneas que deben ser tratadas como unidad de ejecución. Los bloques de código generalmente se delimitan por estructuras con inicio y fin (Module – End Module, Sub – End Sub, etc.).

5. Todo bloque de código que se inicie debe cerrarse.

6. El último bloque de código en abrirse debe ser el primero en cerrarse.


7. Las bibliotecas a utilizarse en un programa se declaran al inicio del mismo, utilizando la palabra reservada Imports.

8. Se utilizan paréntesis para delimitar expresiones que deban resolverse, o para delimitar argumentos.

9. Las variables que se utilicen en un programa deben estar definidas de manera explícita.

10. Aunque no es relevante para el compilador, evite la codificación de todo mayúsculas o todo minúsculas. Procure iniciar las palabras reservadas con mayúsculas.

Este es un ejemplo típico de un programa en Visual Basic.

1 2 3 4 5 6 7 8 9 10

Imports System Imports System.Console Module MiPrograma Sub Main() Write("Pulse INTRO") ReadLine() WriteLine("Hola mundo") End Sub End Module


Ejercicios

Los ejercicios que es necesario realizar para que el conocimiento de este módulo quede bien comprendido, son los siguientes:

1. Lab.01: Creando una aplicación en Visual Studio 2008.


Lab.01: Creando una aplicación en Visual

Studio 2008.

En el presente ejercicio conoceremos la forma de lanzar a ejecución Visual Studio 2008, y la forma en que se crea una aplicación en dicha herramienta.

Abriendo Visual Studio

1. Desde el Botón de Inicio de Windows, seleccione Todos los programas - Microsoft Visual Studio 2008 - Microsoft Visual Studio 2008.

1.1. Los elementos que aparecen en Visual Studio son los siguientes.

1.1.1. Barra de menús. Permite seleccionar tareas que deseamos

que la herramienta ejecute. La Barra de menús contiene todas las tareas que es posible desarrollar con la herramienta.


1.1.2. Barra de herramientas. Al igual que la barra de menús,

permite seleccionar tareas que deseamos que la herramienta ejecute, sólo que de manera más rápida. La Barra de herramientas contiene sólo las tareas más comunes.

1.1.3. Document Window (Área de trabajo). Es el área en donde

podremos trabajar nuestros proyectos. Esta área es muy dinámica, pues puede comportarse como herramienta de diseño, como editor de código, entre otras.

1.1.4. Herramientas. Son diferentes ventanas que proporciona

Visual Studio para trabajar con los proyectos. Aparecen generalmente de forma colapsada a manera de pestañas en los extremos de Document Window, pero pueden activarse si se coloca el puntero del ratón sobre las pestañas. También es posible especificar que estén siempre visibles. De las más importantes, están las siguientes.

1.1.4.1. Solution Explorer. Permite visualizar todos

los archivos que componen nuestro proyecto, y nos permite agregar, eliminar y organizar los elementos que lo componen, a nivel sistema operativo.

1.1.4.2. Toolbox. Ventana en donde se pueden

seleccionar diferentes elementos gráficos y objetos programáticos, para incluirlos en un proyecto.

1.1.4.3. Properties. Herramienta que permite

modificar las propiedades de cualquier elemento de nuestra aplicación.

1.1.5. Al iniciar la ejecución de Visual Studio, el Área de trabajo contendrá la página de inicio de la herramienta, llamada Start Page, que es el punto de inicio para crear o abrir desarrollos en Visual Studio, y obtener información reciente de .NET.

Creando una solución

2. Seleccione la opción File – New Project (CTRL-MAYÚS-N). Con ello aparecerá la ventana de New Project.


3. Para crear una solución, siga estos pasos.

3.1. En Project Type seleccione Other Project Types, y ahí, seleccione Visual Studio Solutions.

3.2. En Templates seleccionamos Blank Solution. Al seleccionar el tipo de proyecto, Visual Studio se encargará de proporcionar de forma automática todos los elementos típicos de una solución, dejándola lista para que le sean agregados proyectos.

3.3. En Name coloque el nombre de la solución, que es Ejercicios; en Location mantenga la dirección que ahí aparezca. El proyecto se almacenará físicamente en el directorio \Mis Documentos\Visual Studio 2008\Projects, que denominaremos Directorio de proyectos.

3.4. Haga clic en Ok, con lo cual se generará dentro del Directorio de proyectos un directorio llamado igual que la solución (…\Ejercicios). Dentro de ese directorio se encuentra el archivo principal del la solución (.sln).

3.5. Pase el puntero del ratón sobre la pestaña que dice Solution Explorer, en el lado derecho de Document Window. Al hacer esto, la herramienta se pondrá visible. Compruebe que se ha generado la solución Ejercicios, y que aún no tiene proyectos (0 projects).

3.6. Si tiene dudas de este ejercicio, vea el clip 3502.01.01.vmw.


Agregando proyectos a una solución

4. Para agregar un proyecto a una solución, siga estos pasos.

4.1. Actualmente, la herramienta Solution Explorer está en modo Auto-Hide, lo que quiere decir que sólo se mostrará si se está trabajando con la herramienta, y aparecerá si se pasa el puntero del ratón sobre la pestaña que aparece en las laterales de Document Window. Lo que queremos es que esté siempre visible, así que procedemos a desactivar el Auto-Hide.

4.1.1. Hacemos que Solution Explorer aparezca, pasando el puntero del ratón sobre la pestaña asociada a la herramienta. Cuando aparezca, hacemos clic en el ícono de Auto Hide, que aparece en forma de una tachuela en la parte superior derecha de la ventana.

4.1.2. La tachuela cambia de forma horizontal a vertical, y a partir de ese momento la herramienta estará permanentemente en el área de trabajo.

4.1.3. Saga del área que ocupa Solution Explorer, y compruebe que la herramienta no se oculta ya.

4.2. En Solution Explorer, seleccione el nodo correspondiente a la solución, haciendo clic en el nodo.

4.3. En la Barra de menú seleccione File – New Project. Aparecerá la ventana New Project, que nos permitirá agregar un proyecto a la solución.


4.4. Queremos crear una aplicación de consola que esté codificada en Visual Basic. Como ese tipo de aplicaciones utiliza Windows Application Services para su ejecución, se trata de una aplicación Windows, aunque no tenga una interfaz gráfica.

4.4.1. En Project Types seleccione Visual Basic – Windows.

4.4.2. En Templates, seleccione Console Application.

4.5. En Name coloque el nombre del proyecto, que debe ser HolaMundoCon.

4.6. En Solution, seleccione Add to Solution, para que el proyecto se agregue a la solución que ya hemos creado.

4.7. En Location mantenga la dirección que ahí aparezca.

4.8. Haga clic en Ok, y dentro del Directorio de la solución se generará el Directorio del proyecto (…\HolaMundoCon\). Dentro del Directorio del proyecto se encontrará el archivo de código fuente del programa de consola (.VB) y el archivo del proyecto (.VBPROJ) que concentrará las referencias de los archivos físicos involucrados en el proyecto. Se generan también directorios de trabajo: en \Bin se colocarán los ensamblados que se generen cuando se realice la compilación del proyecto, en \My Project se almacenarán archivos de configuración y especificaciones útiles para la compilación del proyecto, y en \obj se colocarán archivos temporales involucrados en el proceso de compilación y depuración.

4.9. Al haber especificado como Template una Console Application, Visual Studio genera de forma automática los archivos y referencias comunes para una aplicación de consola. El componente principal será un programa de código fuente llamado Module1.vb, que es módulo en Visual Basic.

5. Document Window es el espacio principal de trabajo en Visual Studio, en donde la mayoría de las herramientas se ubicarán en tiempo de diseño. En Document Window aparecerá Text Editor, que es el editor de texto plano en donde se podrá modificar el código de Module1.vb.

6. En este momento Solution Explorer debe mostrar todos los elementos físicos que componen la solución, y en Document Window se tendrá a Text Editor modificando el código de Module1.vb.

7. Es importante notar que, como la solución sólo tiene un proyecto, Visual Studio asume que se trata de un Stand-Alone Project, y por lo cual no muestra información de la solución en Solution Explorer. Al momento en que se agreguen más proyectos a la misma solución, sólo entonces e mostrará la información correspondiente a la solución.


8. En caso de dudas respecto a esta práctica, revise el clip 3502.01.02.wmv.

Herramientas de Text Editor

9. Text Editor tiene los siguientes elementos.


10. Text Editor es una herramienta fascinante de edición de código, dadas las muchas herramientas que ofrece, dentro de las cuales se encuentran las siguientes.

a. Barra de selección de documentos. En la parte superior de

Text Editor aparecerá una barra que mostrará las pestañas (Tabs) que permitirán seleccionar el documento con el que deseamos estar trabajando.

b. Tabs. Llamadas también pestañas de selección, identifican y

permiten seleccionar los documentos abiertos con los que se puede trabajar. A los documentos que se encuentran abiertos y en la barra de selección de documentos, se les llama documentos activos.

c. Selector de documentos activos. Dado que se pueden tener

una cantidad de documentos activos que hagan insuficiente el espacio en la barra de selección de documentos para mostrar las pestañas de selección, hacer clic en el Selector de documentos activos (flecha ) permite ver los documentos activos en forma de menú, y seleccionarlos.

d. Cerrado de documentos. Si se desea quitar un documento de

los documentos activos, simplemente se debe seleccionar el documento a cerrar, y hacer clic en el icono de cerrado de documentos.

e. Delimitadores de branching. Es la capacidad de Text Editor de

mostrar de forma visible los alcances de los bloques principales de código (Branching). Como se puede observar, al inicio de un procedimiento, módulo o clase, en las líneas delimitadoras de branching aparecen símbolos (-) y (+); estos pequeños iconos permiten visualizar y ocultar el código delimitado, con lo que podemos hacer más clara nuestra codificación, mostrando sólo aquellas partes del código que realmente nos interesa observar.

f. Complementación automática de código. Es la capacidad de

Text Editor de agregar de forma automática líneas de código que por regla de lenguaje debe escribirse. Esto simplifica el proceso de codificación, además que evita errores por omisión de código.

g. Coloring. Es la capacidad de Text Editor de diferenciar por

colores los elementos del código. Generalmente las palabras reservadas estarán en azul, identificadores y operadores en negro, y comentarios en verde. Esto es útil sobre todo cuando no estamos seguros de estar escribiendo correctamente las palabras reservadas. Si no se ponen de color azul, es que no están siendo bien escritas.


h. Divisores de procedimientos. Son las delimitaciones

horizontales que separan los procedimientos incluidas en el código.

i. Divisor de paneles de edición. Si se arrastra el icono Divisor de

paneles de edición, podrá dividirse el espacio de edición de Text Editor en dos mitades. En cada una de las mitades podrá desplazarse, ver y editar diferentes partes del código. Esto es especialmente útil en programas muy extensos, en donde desea estar comparando porciones de código que es imposible mantener juntas en una misma pantalla.

j. Selector de elementos. Se trata de un combo que muestra los

diferentes módulos y elementos globales de una aplicación. En caso de que el programa posea muchos elementos globales, este combo permite ir directamente a la parte de código que nos interesa, sin tener que estar navegando entre las líneas de código para buscar.

k. Selector de miembros. Trabaja de la misma forma que Selector

de elementos, sólo que a un nivel más bajo. Permite seleccionar un miembro de un elemento global.

l. Intellisense. Capacidad a través de la cual Text Editor propone

los objetos y miembros más comunes, conforme se escribe el código.

Intellisense y detección dinámica de errores

11. Dentro del procedimiento Main() introduzca la siguiente línea.

Console.WriteLine(“Presione INTRO”)

Esto se deberá escribir en varios tiempos. Primero escriba «Console.» Al llegar al punto, aparecerá un menú dinámico que propone los elementos del lenguaje que concuerdan con el código que comenzamos a escribir, de tal forma que nosotros iniciamos la escritura, pero puede ser que Visual Studio sea el que la termine, simplificando el proceso de codificación, además de evitar errores de sintaxis. A esta funcionalidad se le llama intellisense.

Intellisense tiene en la parte baja dos pestañas: Common y All. Dado que los elementos de un objeto pueden ser muchos, Visual Studio nos permite ver los más comunes, o bien todos. Por omisión mostrará los más comunes, lo cual es muy práctico. Del menú de elementos que


aparecen, es posible seleccionar utilizando el puntero del ratón, utilizando las flechas de dirección, o bien por concordancia con lo escrito. Sólo en caso de que lo que busque no se encuentre en Common, recurra a All.

Siga escribiendo, hasta que haya escrito «Console.WriteL» . La información que hemos escrito permite una concordancia exacta con un elemento del menú, mismo que se selecciona.

Para ahorrarnos la escritura, y dado que ya está seleccionado el código que pretendemos escribir, basta con escribir el caracter que seguiría, en


caso de escribir nosotros el código. En este caso sería un paréntesis “(“. Escriba un paréntesis derecho, y vea cómo Intellisense complementa el código de forma automática, desapareciendo.

Se recomienda ampliamente el uso de Intellisense, dado que se ha demostrado que reduce en gran medida los errores de sintaxis.

Siga escribiendo la línea de código, y vea cómo aparece una ayuda interactiva de llenado de los elementos. En este caso, la ayuda nos indica que si escribimos «WriteLine()», lo que obtendríamos sería un terminador de línea. La ayuda interactiva nos dice que hay 18 formas de utilizar WriteLine, dado el polimorfismo con que el objeto fue programado. Utilizando los iconos de la ayuda interactiva, busque la alternativa 14 de 18, para que vea la forma en que se utiliza WriteLine con un String.


A este momento ya debió de haber escrito la línea de ejemplo por completo.

11. Modifique la línea, de tal forma que escriba «Console» con doble “s”, a fin de causar un error. Vea cómo al introducir una línea que presenta errores de sintaxis, Visual Studio le señala la falta muy al estilo de Word, subrayando el error en color azul. Si se coloca sobre la parte del código que presenta el error, podrá darse cuenta que Visual Studio le informa el mensaje del error que se está provocando. Esto ayuda a reducir el tiempo de desarrollo, dado que no hace falta compilar y probar para saber que algo fallará.

12. Corrija la línea para que ya no genere errores.

13. En caso de dudas respecto a esta práctica, revise el clip 3502.01.03.wmv.

Modificando código usando Text Editor

14. Como todo programa Hola Mundo, se espera que el usuario interactúe con el programa, y que éste envíe el mensaje «Hola Mundo». Para hacer esto, nuestro programa enviará un mensaje, esperará el uso del teclado, y enviará finalmente el mensaje «Hola Mundo». Modifique el procedimiento Main(). El código deberá quedar de la siguiente forma.


Codificación de HolaMundoCon

1 2 3 4 5 6 7 8 9

Module Module1 Sub Main() Console.Write("Presione INTRO") Console.ReadLine() Console.WriteLine("Hola mundo.") End Sub End Module

15. Presione F5, para probar el programa.

16. Ha creado una aplicación en .NET usando Visual Studio 2008.

FIN DEL EJERCICIO

1

Elementos del lenguaje

Contenido:

Objetivos ........................................................................................... 3 Variables ........................................................................................... 4 Identificadores ................................................................................. 6 Tipos de datos .................................................................................. 9 Conversión de datos ...................................................................... 14 Conversión implícita (Casting) ....................................................... 14 Conversión explícita ....................................................................... 15 Conversión por método.................................................................. 16 Acceso a datos Value Type y Reference Type............................... 17 Capacidades de los tipos valor y referencia ................................. 17 Naturaleza de tipo de los datos .................................................... 18 ByVal y ByRef .................................................................................. 18 Strong Typing .................................................................................. 20 Declaración de variables ............................................................... 22 Constantes ..................................................................................... 24 Literales .......................................................................................... 25 Valores por omisión ....................................................................... 25 Origen de las variables: Clases y Estructuras............................... 26 Alcance de las variables ................................................................ 28 Shadowing ...................................................................................... 30 Accesibilidad de las variables ....................................................... 31 Arreglos ........................................................................................... 34 Arreglos unidimensionales ............................................................ 36 Arreglos multidimensionales ......................................................... 38 Arreglos escalonados ..................................................................... 41 Ejercicios ......................................................................................... 44 Lab.01: Demostrando las capacidades de las

variables ByVal y ByRef ...................................................... 45 Lab.02: Demostrando la declaración de variables,

constantes y la realización de conversiones ..................... 48 Lab.03: Demostrando el alcance de las variables y la

forma en que preservan valores ........................................ 50 Lab.04: Comprobación de arreglos unidimensionales,

multidimensionales y escalonados .................................... 54 Operadores aritméticos ................................................................. 58 Operadores de asignación ............................................................. 60 Expresión ........................................................................................ 60 Operadores de asignación incluyente ........................................... 62 Operadores comparativos ............................................................. 64


Consideraciones relativas al código ASCII .................................... 66 Option compare .............................................................................. 68 Operadores Is, IsNot y TypeOf ....................................................... 70 Operador Like ................................................................................. 72 Operadores lógicos ........................................................................ 75 Operadores lógicos de circuito corto ............................................ 79 Prioridad entre operadores ........................................................... 81 Uso de paréntesis para otorgar preferencia de

ejecución ............................................................................. 83 Ejercicios ......................................................................................... 84 Lab.05: Utilización general de operadores en Visual

Basic .................................................................................... 85 Lab.06: Uso de operadores de asignación incluyente

y operadores de circuito corto ............................................ 87 Estatuto If Then Else ...................................................................... 90 Select Case ..................................................................................... 94 For Next .......................................................................................... 96 While 98 Do Loop ........................................................................................ 100 Reglas para el anidado de estructuras ...................................... 102 Ejercicios ...................................................................................... 104 Lab.07: Uso de estructuras de decisión .................................... 105 Lab.08: Uso de For Next ............................................................. 108 Lab.09: Identificando errores en estructuras

anidadas ........................................................................... 111 Procedimientos ........................................................................... 113 Forma de agregar procedimientos a un programa ................... 113 Forma de mandar llamar a ejecución un

procedimiento .................................................................. 114 Argumentos ................................................................................. 115 Valores de retorno ....................................................................... 116 Codificación de procedimientos ................................................. 117 Argumentos opcionales y valores por omisión .......................... 122 Ejercicios ...................................................................................... 124 Lab.10: Procedimiento que no utiliza argumentos ................... 125 Lab.11: Procedimiento que declara argumentos pero

no retorna valores ............................................................ 128 Lab.12: Procedimiento que declara argumentos y

retorna valores ................................................................. 130

Módulo 2: Elementos del Lenguaje 3

Objetivos

Los objetivos del presente módulo son los siguientes:

1. Aprenderá el manejo de variables y arreglos en Visual Basic 2. Aprenderá el uso de operadores en Visual Basic 3. Aprenderá el manejo de estructuras de decisión y control en Visual Basic 4. Aprenderá el la forma en que se programan procedimientos y funciones en

Visual Basic


Variables

Una variable de memoria es la referencia lógica a una posición física de memoria RAM.

Por medio de las variables podemos almacenar valores en la memoria, asignarles un nombre determinado, y luego disponer del valor almacenado cuando lo necesitemos.

Estos valores almacenados en memoria estarán disponibles mientras no liberemos la memoria, ya sea por medio de programación o como resultado de haber cerrado la sesión de programa donde fueron definidas. Por supuesto, apagar la máquina provoca cerrar todos los programas, y por tanto, perder los valores almacenados en las variables definidas por éstos.

Las variables tienen siempre las siguientes características:

Identificador (identifier). Es el atributo que permite distinguir a una variable de otra.

Tipo de dato (datatype). Es el tipo de valor que podrá almacenar la variable, mismo que determina el tratamiento interno que tendrá el valor, la cantidad en bytes que consumirá en memoria, entre otras cosas.


Alcance (scope). Es el atributo que define la cantidad de código en que una variable puede ser utilizada, sin utilizar calificador; es el estado de existencia y la persistencia del valor de la variable, en tiempo de ejecución.

Accesibilidad (accessibility). Es el permiso que se proporciona al código para leer la variable o para escribir en la variable.

Tiempo de vida ( lifetime). Es el periodo de tiempo de ejecución en el cual la variable está disponible.


Identificadores

Se le llama identificador (identifier) al nombre lógico de un elemento de programación, por medio del cual podrá ser referido.

Las variables, al igual que los procedimientos, las clases, las estructuras, etcétera, poseen un identificador, a través de los cuales son utilizables de manera programática.

Reglas de composición de los identificadores . Los identificadores deben cumplir con las siguientes reglas:

Deben iniciar con un caracter alfabético o con una línea baja ( _ ).

Sólo pueden contener caracteres alfabéticos, dígitos decimales, o línea baja.

Si inician con línea baja, al menos deben contener un dígito decimal o un caracter alfabético.

No pueden contener espacios intermedios.

Reglas no escritas de composición de los identificadores. Existen otras reglas no requeridas por el lenguaje, pero que le pueden ser de mucha ayuda:


Se sugiere que un identificador sea ilustrativo, es decir, que proporcione clara idea de su contenido: si lo que desea almacenar en memoria es la edad de una persona, su variable puede llamarse Edad o X; ambos identificadores son válidos, sin embargo, le será de más utilidad Edad, pues le proporciona una mejor idea del valor contenido en la variable. Estará de acuerdo con nosotros que X puede ser cualquier cosa. Sí: Edad; No: X.

Se sugieren nombres cortos, ya que una variable puede ser utilizada en muchas ocasiones dentro de un programa, y entre más larga sea, más complejo el programa. Sí: Nombre; No: NombreDelClienteQueAdquiereProducto.

Se recomienda no utilizar línea baja en el nombre; si puede evitar dicho caracter, evítelo; recuerde que la línea baja es el continuador de línea del lenguaje, y puede crearse confusión innecesaria. Sí: VentasMensuales; No: Ventas_Mensuales.

Se recomienda el manejo de letra capital para el nombre de variables; coloque una letra mayúscula cada vez que inicie una palabra en su identificador (Pascal casing). Sí: VentasMensuales; No: ventasmensuales.

Evite el uso de conjunciones. Sí: VentasMensuales; No: VentasDelMes.

Evite el uso de abreviaciones. Sí: VentasMensuales; No: VtsM.

Dentro de las recomendaciones para el nombrado de elementos que requieren ser identificados en Visual Basic, se tienen diferentes estilos de manejo de mayúsculas y minúsculas, que forman convencionalismos internacionalmente reconocidos. Aunque el lenguaje le permitirá que coloque los identificadores como le plazca, es mejor seguir las reglas que todos los desarrolladores del mundo parecen estar siguiendo.

Pascal casing. El estilo Pascal casing se caracteriza por colocar en mayúscula la primer letra de cada palabra de un identificador, incluyendo la primera. Este es el tipo más utilizado en Visual Basic Ejemplo: VentasMensuales.

Se recomienda utilizar Pascal casing:

Al nombrar clases.

Al nombrar enumeraciones (constantes predefinidas del lenguaje).

Al nombrar eventos.


Al nombrar interfaces.

Al nombrar espacios de nombres.

Al nombrar métodos y propiedades.

Camel casing . El estilo Camel casing se caracteriza por colocar en mayúscula la primer letra de cada palabra de un identificador, excepto la primera. Este estilo es muy usual para los programadores en C# o Java. Ejemplo: ventasMensuales.

Se recomienda utilizar Camel casing:

Al nombrar parámetros; si el parámetro se compone de una sola palabra, toda la palabra va en minúscula.

Información de alcance privado, tales como campos y variables.

Notación húngara (Hungarian notation) . La Notación húngara se caracteriza por colocar un prefijo a las variables, dando a entender su tipo o función. Este estilo está cada vez más en desuso, por lo cual sugerimos evitarlo al máximo. Ejemplo: intVentasMensuales, strNombre, que nos da a entender que se trata de un dato Integer.

Se recomienda usar Hungarian notation:

Nunca

NNOOTTAA

Evitar la notación húngara es la recomendación de Microsoft. En realidad, la notación húngara sigue siendo utilizada mucho por la comunidad de desarrollo, e incluso en el sitio de Microsoft encontramos muchos ejemplos con dicha notación. Utilizar la notación húngara será a fin de cuentas una decisión del equipo de desarrollo, y no afecta la funcionalidad de las aplicaciones.

En este apartado hacemos recomendaciones solamente; lo más importante no es el estilo en sí, sino que todos los miembros de un equipo de desarrollo lo compartan y utilicen de manera consistente.


Tipos de datos

Las variables pueden almacenar cualquier tipo de valor, desde una secuencia de caracteres, hasta un número o una fecha. Dependiendo del tipo de valor que estemos hablando, será posible hacer tal o cual cosa con el contenido de la variable.

Esta situación nos lleva a la necesidad de definir qué tipo de valor almacenará la variable, para entonces poder saber qué es posible hacer con ella.

El tipo de dato (Datatype) es el tipo de valor que podrá almacenar la variable, mismo que determinará el tratamiento interno que tendrá el valor, la cantidad en bytes que consumirá en memoria, y las operaciones que se podrán realizar con el mismo.

Se le llama dominio al conjunto de valores válidos para un dato. Por ejemplo, el dominio de un dato que almacenará un número de mes, será números enteros, del 1 al 12. Cuando el dominio está relacionado con el tipo de dato, se le llama dominio de tipo; por ejemplo, en el caso del tipo de dato Byte, el dominio será de números enteros del 0 al 255.


Todo en Visual Basic es un objeto, y todo objeto tiene un determinado tipo, lo que se conoce como type. Se tienen dos clases de types en el lenguaje.

Types que forman parte del lenguaje, llamados types intrínsecos.

Types de usuario, llamados también user-defined types, que son clases, estructuras, interfaces, y otros elementos que no forman parte de .NET Framework.

Cada type tiene un nombre de type, que es el identificador a través del cual se invoca la funcionalidad desde el código fuente en un determinado lenguaje; el nombre del type puede ser más corto en un lenguaje que en .NET Framework. Por ejemplo, para Visual Basic la referencia Integer es equivalente a referir el type System.Int32 de .NET Framework, que es más complejo. Todos los lenguajes tienen acceso a la misma biblioteca de clases. La variación es que cada lenguaje tendrá su implementación para llegar a System.Int32 (Visual Basic, Integer; C#, int; C++, int o long; JScript, int).

Además de nombre, los types también poseen un tamaño de type, que representa el consumo en bytes del type. Esto es importante dado que la memoria RAM es siempre limitada.

Los types intrínsecos pueden ser clases, estructuras e interfases preconstruidas en .NET Framework, que nos ayudan a estandarizar el manejo de valores de datos, o bien producir comportamientos. En ese sentido, Integer es un type que representa un valor, mientras que WriteLine es un type, en el sentido que es un método de una clase de BCL, que no debe ser instanciada para funcionar.


Visual Basic soporta los siguientes tipos de datos intrínsecos:

Tipo de dato Estructura o Clase.NET Framework a la que se hace referencia

Consumo en bytes

Rango de Valores (Dominio de tipo)

Boolean System.Boolean (estructura)

1 byte True o False

Byte System.Byte (estructura)

1 byte De 0 a 255 (sin signo)

Char System.Char (estructura)

2 bytes Caracteres UNICODE

Date System.DateTime (estructura)

8 bytes De Enero 1, 0001 a Diciembre 31, 9999

Decimal System.Decimal (estructura)

12 bytes (a) +/-79,228,162,514,264,337,593,543,950,335 sin punto decimal; (b) +/-7.9228162514264337593543950335 con 28 posiciones después del punto decimal; (c) el mayor número menor a cero representable es: +/-0.0000000000000000000000000001

Double

System.Double (estructura)

8 bytes (a) -1.79769313486231E+308 a -4.94065645841247E-324 para valores negativos; (b) 4.94065645841247E-324 a 1.79769313486231E+308 para valores positivos

Integer System.Int32 (estructura)

4 bytes De -2,147,483,648 a 2,147,483,647

Long

System.Int64 (estructura)

8 bytes De -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807

Short System.Int16 (estructura)

2 bytes De -32,768 a 32,767

Single

System.Single (estructura)

4 bytes (a) -3.402823E+38 a -1.401298E-45 para números negativos; (b) 1.401298E-45 a 3.402823E+38 para valores positivos

String

System.String (clase)

Depende de la plataforma

De 0 a aproximadamente 2 billones de caracteres Unicode

Se consideran tipos de dato numérico los siguientes: Byte, Double, Integer, Long, Short y Single. Se consideran tipos de dato no numérico los siguientes: Boolean, Date, Decimal, Object y String. Aunque Decimal almacena números, el manejo que hace del punto flotante hace su manejo más complejo. En el caso de Object, es una definición no determinada de tipo, que puede asumir cualquier valor.


Algunas recomendaciones que hacemos son las siguientes:

Al definir variables, se recomienda utilizar los tipos de datos más adecuados, cuidando que las operaciones que se realizarán con los valores no vayan a provocar un conflicto de tipos. Si va a realizar operaciones de alta precisión, un tipo de datos Integer no le servirá, por ejemplo.

Se recomienda que utilice los tipos de datos que menor consumo de memoria tengan. Si va a almacenar la edad de una persona, puede escoger entre Integer o Byte; escoja Byte, pues consume menos memoria.

Se recomienda el uso de tipos de datos numéricos, pues son los que más eficientemente se manejan por la computadora.

En términos de tiempo de manejo que requieren los tipos de dato para ser manejados, el tipo de dato más eficiente, indiscutiblemente, es Integer, mientras que el menos eficiente será Object.

Visual Basic realiza lo que se llama conversión de tipo cast, es decir, conversión de tipos de datos en tiempo de ejecución, que se realiza entre tipos de datos compatibles. Prefiera hacer las conversiones usted mismo, en lugar de dejar que el lenguaje las haga; aunque es más cómodo dejar hacer al lenguaje, usted pierde el control de su programa; en caso de que se presenten problemas, será más difícil determinar en donde se encuentran.

Tenga visión a futuro con los datos, a fin de que no exceda los dominios de tipo. Por ejemplo, la lógica nos dice que la suma de dos números enteros será un número entero; matemáticamente es cierto, pero desde la perspectiva de los tipos de datos, la suma de dos Integer no siempre es un Integer. Si suma 2,000,000,000 más 2,000,000,000, excederá el límite del dominio de tipo; en ese caso, la suma de dos Integer puede ser Long. En ocasiones los problemas originados por esta situación (numeric overflow), se presentan después de haber utilizado la aplicación durante mucho tiempo.


Conversión de datos

En muchas ocasiones requerirá realizar conversiones de tipos de datos, principalmente de datos String a otros tipos.

Se conoce como conversión de datos al hecho de cambiar el tipo de dato de un valor por otro. Se tienen tres formas de conversión de datos en Visual Basic.

Los tipos de conversión en Visual Basic son los siguientes.

Conversión implícita (Casting)

La conversión implícita, conocida como casting, se presenta cuando el CLR es capaz de realizar la conversión en tiempo de ejecución, sin que el programa lo especifique. Este tipo de conversión es común en los tipos de datos numéricos.

Hay un fenómeno que se conoce como narrowing, cuando la conversión se realiza de un tipo con mayor dominio a uno de menor dominio (Integer pasando a Byte, por ejemplo); por otro lado, se conoce como widening cuando la conversión se realiza de un tipo de menor dominio a uno de mayor (Byte pasando a Integer, por ejemplo). En el caso de narrowing, hay que prestar mucha


atención en no proporcionar datos que exceden el dominio de tipo, por ejemplo, tratar de pasar 100000I (Integer) a 100000S (Short), dado que los datos pueden truncarse, e incluso provocar excepciones.

Conversión explícita

Se presenta cuando mediante código se aplican funciones específicas que realizan la conversión. Principalmente se utiliza para convertir tipos String/Char a otros tipos.

La conversión explícita puede hacerse mediante funciones específicas y funciones genéricas. Las principales funciones específicas utilizadas son las siguientes.

Función Consecuencia

CBool(Expresión) Convierte Expresión a Boolean.

CByte(Expresión) Convierte Expresión a Byte.

CChar(Expresión) Convierte Expresión a Char.

CDate(Expresión) Convierte Expresión a Date.

CDbl(Expresión) Convierte Expresión a Double.

CDec(Expresión) Convierte Expresión a Decimal.

CInt(Expresión) Convierte Expresión a Integer.

CLng(Expresión) Convierte Expresión a Long.

CObj(Expresión) Convierte Expresión a Object.

CShort(Expresión) Convierte Expresión a Short.

CStr(Expresión) Convierte Expresión a String.

La principal función de conversión genérica es CType, cuya sintaxis es la siguiente.

CType(Expresión, NombreTipoDato)

Donde Expresión es la expresión a convertir, y NombreTipoDato es el nombre del tipo de dato al que se desea convertir la expresión.

Ejemplo.

CType(“4”, Integer)


Conversión por método

Algunos tipos de datos, por ejemplo la mayoría de los numéricos, tienen implícito un método que permite hacer una conversión de datos. El más común de estos métodos es el método ToString, que permite convertir a la representación String un valor dado.

Ejemplo.

Dim Edad As Integer = 30

Dim EdadTexto As String = Edad.ToString()

En este caso, se declara una variable llamada Edad, de tipo Integer, a la cual se le asigna el valor de 30. Después se declara una variable llamada EdadTexto que tomará la representación String de la variable Edad, es decir “30”.


Acceso a datos Value Type y Reference

Type

Visual Basic, como todo lenguaje de programación, permite el uso de la memoria de la máquina a través de variables de memoria; el acceso a los datos almacenados en memoria a través del uso de variables puede llevarse a cabo a través de dos tipos de acceso: tipos de valor (value type) y tipos de referencia (reference type).

Dependiendo de la forma en que se tenga acceso a los valores almacenados el consumo de memoria puede variar.

Capacidades de los tipos valor y referencia

Dependiendo el tipo de acceso a los datos, las capacidades de almacenamiento y economía difieren.

Con los tipos de valor (value type):

Las variables almacenan un dato de un determinado tipo.

Cada variable tiene su propio alojamiento en memoria.

Cada variable contiene su propia copia del dato.


Las operaciones realizadas con una variable no afectan a ninguna otra.

La asignación de valor a una variable crea una copia de datos. (No se sustituye el valor anterior).

Con el tipo referencia (reference type):

Las variables hacen referencia a un objeto (es decir, emanan de una clase).

Las variables mantienen una referencia apuntando a la posición en memoria en donde se encuentran los datos.

Las variables son intermediarias entre un programa y la memoria.

Naturaleza de tipo de los datos

Los tipos de datos tienen una naturaleza intrínseca respecto a un tipo de acceso.

Son value type:

Todos los tipos de datos que almacenan números: Byte, Decimal, Double, Integer, Long, Short, Single.

Los tipos de datos Boolean, Char, y Date.

Todas las estructuras, incluyendo aquellas que se conforman de elementos que son reference type.

Son reference type:

El tipo de dato String.

Todos los arreglos de memoria (Arrays), aun y cuando sus elementos sean Value Type.

Lo que sea instancia de una clase.

ByVal y ByRef

Cuando los datos son pasados como argumentos a funciones y procedimientos, es posible especificar el tipo de acceso que se desea tener.

Para realizar eso se utilizan las palabras reservadas ByVal y ByRef; si se utiliza ByVal, se le estará especificando al procedimiento o función, que utilice su propia versión del dato, y que mantenga intacto el valor original del mismo. Si se utiliza ByRef, se le estará especificando al procedimiento o función que utilice la misma


posición de memoria que el dato original, por lo que las modificaciones realizadas al argumento afectan el dato original.

Es importante considerar que el uso de ByVal y ByRef es respetado siempre y cuando la naturaleza del dato no se imponga.

Cuando sus procedimientos o funciones sean de uso genérico para varios objetos o datos, se recomienda ampliamente utilizar ByVal a fin de que se realicen operaciones de la manera más segura posible.


Strong Typing

Antes de Visual Basic, el lenguaje había sido muy permisivo con los programadores; obviaba muchas cosas y permitía a los programadores no ser formales con la técnica, lo que a largo plazo siempre causaba problemas.

Si no se declaraban las variables, Visual Basic lo hacía por nosotros; si no se especificaban los tipos de datos, Visual Basic lo hacía por nosotros; si no se planeaban las conversiones, Visual Basic las realizaba de manera implícita.

Eso provocaba que los errores de fondo fueran difíciles de encontrar, ya que el universo de cosas que podían estar equivocadas excedía nuestro conocimiento, ya que no todo estaba bajo nuestro control. Resultaba patético estar buscando un error de lógica o de algoritmo, pasar horas revisando un programa, para descubrir luego que el verdadero problema era "un error de dedo", que Visual Basic "arreglaba" por nosotros sin que nos diéramos cuenta.

Para evitar esas penosas situaciones, existen dos estatutos que se agregan antes de cualquier cosa en el código y que aseguran que la codificación sigue una técnica formal, de tipo strong typing, es


decir, donde todos los datos están asociados de manera explícita y no ambigua a un tipo determinado.

Option Explicit [On/Off]

La instrucción Option Explicit, cuando está activado (On), obliga a que declaremos todas las variables que utilizamos en nuestro programa. Si tratamos de utilizar una variable no declarada, se provocará un error. Option Explicit nos permite generar programas de tipo de datos asegurados (type safe), en el sentido de que todas las variables deben declararse, sobre tipos de datos reconocidos.

Option Strict [On/Off]

El estatuto Option Strict, cuando está activado (On), obliga a que las conversiones de datos se realicen de manera explícita. Las conversiones implícitas (casting) no están disponibles incluso para las conversiones amplias. Option Strict nos permite generar programas de tipo de datos reforzados (strong type), en el sentido de que todas las conversiones deben ser explícitas.

Si usted especifica Option Explicit y Option Strict, es muy probable que su código sea bastante formal, y no se encontrará con errores extraños en tiempo de ejecución. Los valores predeterminados de Option Explicit y Option Strict es Off.

Una excelente práctica de desarrollo es hacer que sus programas sean Strong type, con eso reducirá el porcentaje de errores que pudieron evitarse con un poco de formalidad al declarar y utilizar variables.


Declaración de variables

Para poder utilizar una variable, es necesario declararla; declarar una variable es el proceso mediante el cual se establece un identificador, que será reconocido en tiempo de ejecución, para almacenar uno o más valores de un determinado tipo.

No se pueden utilizar variables que no hayan sido declaradas previamente.

La declaración de una variable se lleva a cabo a través de lainstrucción de declaración: Dim.

La sintaxis más sencilla de Dim es la siguiente:

Dim Identificador [As TipoDato] [ = ValorInicial]

Donde Identificador es el nombre que se desea asignar a la variable, y TipoDato es el tipo de dato que corresponde al valor que almacenaremos en la variable. En .NET es posible asignar un valor al momento de la declaración (ValorInicial).


NNOOTTAA

La expresión "almacenar valores en las variables de memoria" es una

expresión equivocada. Los valores no "se almacenan" en las variables; en

realidad se almacenan en posiciones físicas de memoria RAM, y las

variables sólo son el medio a través del cual tenemos acceso a dichas

posiciones de memoria. Cuando digamos que almacenamos valores en

las variables, nos referimos a que almacenamos valores en una posición

física de memoria, que es referida por el identificador de la variable.

La especificación del tipo de dato a través de la palabra reservada As es opcional; si se omite la especificación de tipo de dato, la variable se declara automáticamente bajo el tipo Object. Esta declaración automática garantiza que no se utilice una variable que no ha sido declarada, sin embargo, es lo más ineficiente, ya que todo el tiempo CLR tendrá que invertir tiempo en determinar qué tipo de valor es el que está almacenado en la variable.

A continuación se muestran ejemplos de declaración de variables:

1 2 3 4 5 6

Dim Edad Dim Edad As Integer Dim Edad As System.Int32 Dim Edad As Integer = 50 Dim Nombre, Apellido As String Dim Nombre, Apellido As String, Edad As Integer

La línea 1 declara una variable Object. La línea 2 declara una variable Integer. La 3 es exactamente igual a la línea 2, ya que Integer es la referencia a System.Int32. La línea 4, además de declarar la variable, le asigna un valor de inicio. La línea 5 demuestra que se pueden declarar varias variables de un mismo tipo, separando los identificadores por comas. La línea 6 demuestra que Dim soporta la declaración de dos o más variables de un mismo tipo, y de dos o más tipos.


Constantes

Se conoce como constantes a las variables que sólo cambiarán su valor una vez en su tiempo de vida. Para definirlos se utiliza la siguiente sintaxis.

Const Identificador [As TipoDato] = ValorInicial

Donde Identificador es el identificador de la constante, TipoDato es el tipo de dato que tendrá la constante, y ValorInicial es el valor que tendrá la constante durante todo su tiempo de vida.

Ejemplo de uso:

Const PI As Single = 3.1416


Literales

Si se menciona un número 4, no tenemos suficiente información para saber si el número es Byte, Integer, Double, Decimal, dado que 4 puede ser de cualquiera de esos tipos. Lo mismo ocurriría con “A”, dado que no sabríamos si se trata de un dato String o Char.

Se tienen literales que permiten definir un valor, liberándolo de las ambigüedades de tipo que pudiera tener.

Valores por omisión

Cada variable, en caso de que no se le asigne un valor, tendrá un valor por omisión. A continuación se muestra una relación de los valores por omisión para los tipos de datos.

Tipo de dato Valor por omisión

Tipos de datos numéricos 0

Boolean False

Date 01/01/0001 12:00 A.M.

Decimal 0

Object Nothing

String “”


Origen de las variables: Clases y

Estructuras

Decíamos que en Visual Basic las variables son instancias de una clase o una estructura.

Variables basadas en clase (intermediación requerida). Sabemos que una clase es la definición formal de un tipo de objeto. Un objeto es la instancia de una clase; éste puede contener información y comportamiento. En el caso de los datos almacenados en memoria a través de un objeto, éstos pueden estar disponibles al usuario mediante referencias. Uno hace referencia al objeto, y el objeto hace referencia a una posición de memoria en donde se encuentra el dato; esa intermediación que realiza el objeto para llegar al dato consume recursos de almacenamiento temporal en la computadora (lo que se conoce como heap allocation).

Este tipo de variables son más demandantes de recursos, pero ofrecen mayor funcionalidad.


Variables basadas en estructura (acceso directo, sin intermediación). Una estructura (structure) es muy similar a una clase, en el sentido que puede almacenar datos y métodos; la diferencia con respecto a una variable basada en una clase es que la variable basada en estructura contiene de manera directa los datos definidos en la estructura; esto provoca que no sea necesaria una intermediación entre la variable y el dato, por lo que no se consumen recursos adicionales de la computadora, en el área de almacenamiento temporal.

En la tabla que muestra los tipos de datos disponibles en Visual Basic se hace referencia a la estructura o a la clase en la que se basan.

El hecho de que las variables tengan su origen en una estructura o clase les proporciona una funcionalidad extendida y extensible, que hace de las variables un elemento del lenguaje con vida propia.


Alcance de las variables

El alcance (scope) de las variables determina en qué partes del código podrá ser utilizada una variable sin utilizar un calificador.

Para entender el alcance debemos entender antes el concepto de bloque de código. Un bloque de código (code block) es el conjunto de líneas de código que constituyen una unidad de ejecución. Generalmente se encuentran delimitados por una línea de inicio y una línea de conclusión, a lo que se conoce como branching; todas las instrucciones que culminen con End son delimitadores de bloque de código (Module-End Module, Sub-End Sub, If-End If, etcétera). Existen otras instrucciones, como For-Next y Do-Loop, que aunque no concluyen con End, también contienen bloques de código. Los bloques pueden ser condicionales y no condicionales. Son bloques condicionales cuando su ejecución depende de el valor obtenido al resolver una expresión lógica (If-End If, Do-Loop, por ejemplo), mientras que son bloques no condicionales aquellos que


no dependen de una evaluación para ejecutarse (Module-End Module, Namespace-End Namespace, por ejemplo).

Un aspecto importante a tomar en cuenta es que un bloque de código puede formar parte de otro bloque de código.

Se tienen los siguientes alcances:

Alcance de bloque (Block scope). El alcance de bloque se presenta cuando la variable sólo está disponible en el bloque de código en el que está declarada. El alcance de bloque es el más estrecho, en el sentido de que la variable tiene la menor vigencia posible. Cómo se define: declarando la variable dentro de un bloque de código.

Este tipo de alcance aplica para los siguientes estatutos.

Do-Loop

For [Each]-Next

If-End If

Select-End Select

SyncLock-End SyncLock

Try-End Try

While-End While

With-End With

Alcance de procedimiento (Procedure scope). El alcance de procedimiento se presenta cuando la variable está sólo disponible para el procedimiento en el que está declarada. Cuando las variables sólo pueden ser utilizadas dentro del procedimiento que las declara, reciben el nombre de variables locales. Cómo se define: declarando la variable dentro de un procedimiento, pero no dentro de un bloque; se recomienda declarar al inicio del procedimiento, antes de cualquier bloque de código.

Alcance de módulo (Module scope). El alcance de módulo se presenta cuando la variable está disponible para todos los procedimientos de un determinado módulo, clase o estructura en la que está declarada. Cómo se define: declarando la variable dentro del módulo, clase o estructura, antes de declarar cualquier procedimiento.

Alcance de espacio de nombres (Namespace scope). El alcance de espacio de nombres se presenta cuando la variable está disponible para todos los módulos, clases o estructuras contenidas en un espacio de nombres. Este alcance es el de


mayor amplitud. Cómo se define: declarando una variable a nivel módulo, con accesibilidad Friend o Public (que verá más adelante).

Shadowing

Existe la posibilidad de que en un mismo programa existan dos variables con el mismo nombre. Puede resultar contradictorio, ya que por un lado sostenemos que cada variable debe tener un identificador único, mientras que por otro decimos que puede haber dos variables con el mismo nombre.

Ya con el conocimiento que hemos adquirido, podemos decir que dos variables no pueden compartir el mismo identificador si tienen el mismo alcance. En resumen, pueden existir variables homónimas si se declaran con diferente alcance; en ese sentido, podemos declarar una variable X a nivel módulo, y declarar una variable X dentro de un procedimiento, lo cual no causará problemas al momento de compilar, pero si se podrá generar un procesamiento particular en tiempo de ejecución.

El hecho de que dos variables tengan el mismo identificador no causa problema para Visual Basic, siempre y cuando tengan alcances distintos; el programa utilizará para el procesamiento de datos aquella variable con alcance más estrecho; a este comportamiento se le da el nombre de shadowing.

Los valores de variables con el mismo nombre y distinto alcance serán mantenidos en tiempo de ejecución, a fin de utilizar el valor de menor alcance según se requiera en el programa.


Accesibilidad de las variables

La accesibilidad (accesibility) de una variable es el permiso que se proporciona al código para leer la variable o para escribir en la variable. El concepto de accesibilidad está muy ligado al concepto de alcance, ya que entre los dos constituyen la disponibilidad real de una variable para su uso a través de código.

Las diferentes opciones que se tienen de accesibilidad son:

Public. Conocidas como variables públicas. Proporciona acceso público a la variable; no hay restricciones de uso de la variable cuando se define como pública. Sólo se puede definir a nivel módulo, espacio de nombres, o archivo físico; nunca a nivel procedimiento.

Protected. Conocidas como variables protegidas. Proporcionan acceso protegido a la variable, es decir, sólo pueden ser utilizadas por la clase en que se declaró la variable, o en aquellas clases derivadas de ésta. Sólo se puede definir a nivel clase, nunca a nivel procedimiento.

Friend. Proporcionan acceso que asume confianza hacia el usuario (de ahí lo “amistoso”); pueden ser utilizadas por el


programa que la declara, y por todos aquellos que se encuentren en el mismo ensamblado. Sólo se puede definir a nivel módulo, espacio de nombres, o archivo físico; nunca a nivel procedimiento.

Protected Friend. Proporciona la unión de restricciones de Protected y de Friend.

Private. Conocidas como variables privadas. Proporciona acceso privado a una variable. Sólo están disponibles para el alcance en el que fueron declaradas. Sólo se puede definir a nivel módulo, espacio de nombres, o archivo físico; nunca a nivel procedimiento.

Static. Conocidas como variables estáticas. Permite incrementar la persistencia del valor de las variables, manteniendo el último valor que haya asumido, aún después de la terminación del procedimiento que la declaró. Sólo se puede definir a nivel procedimiento. No se pueden declarar variables estáticas en los procedimientos de una estructura; sólo aplican para los procedimientos de clases. Static es muy similar a una variable Public; se diferencian en el lugar en donde se declaran. En cierta forma, las variables Static serían como variables públicas declaradas en los procedimientos.

Shared . Conocidas como variables compartidas. Indica que la variable es compartida, lo que significa que no está asociada con la instancia de una clase o estructura determinada. Se puede acceder a una variable compartida a través de un calificador (anteponer al nombre de la variable el nombre de la clase en donde se declaró inicialmente, más un punto separador). Sólo se puede definir a nivel módulo, espacio de nombres, o archivo físico; nunca a nivel procedimiento. Las variables compartidas (shared variables) identifican una sola unidad de almacenamiento, sin importar cuántas instancias de la clase que la declara hayan sido creadas; cuando una variable no es definida como compartida, se dice que es una variable de instancia (instance variable), y cada instancia mantendrá la referencia de su propio valor. Este tipo de variables son especialmente útiles para trasladar valores de un formulario a otro, en aplicaciones de formularios múltiples, ya que no basta con que las variables sean públicas.

ReadOnly. Especifica que se trata de una variable de sólo lectura.


Si no se especifica alguna opción de accesibilidad, las variables serán variables de instancia y privadas (instance variable, private).

En caso de que se desee asignar alguna opción de accesibilidad, la especificación pasa a ser el estatuto de declaración, y puede sustituir a Dim.

Ejemplo.

Static Dim Edad As Integer

Es lo mismo que:

Static Edad As Integer

NNOOTTAA

En el caso de la accesibilidad es importante tener en cuenta la

accesibilidad del objeto contenedor de la variable (objeto que contiene a

otro objeto).

Puede proporcionar permiso a nivel procedimiento, pero si no se tiene

permiso para disponer del módulo, clase o estructura que contiene el

procedimiento mencionado, no podrá llegar nunca a él.


Arreglos

Se conoce como arreglos (arrays), también llamados matrices en algunos casos, a un conjunto de posiciones en memoria que son referidas por un mismo identificador.

La forma de acceder a un dato almacenado en una posición de memoria dentro de un arreglo es a través de un subíndice, que es la posición secuencial de cada elemento dentro de la colección. Los subíndices, como en todos los lenguajes de .NET, son de base cero, es decir, que inician de cero en adelante.

En Visual Basic, los arreglos tienen un tratamiento de colecciones, por lo cual los subíndices siempre se especifican entre paréntesis. Las colecciones son conjuntos de objetos lógicamente relacionados, diferenciados por un subíndice.

En su calidad de colecciones, pueden ser explorados con la instrucción For Each, cuya sintaxis es la siguiente.


For Each Elemento [As TipoDato] In Colección

BloqueCódigo

[Exit For]

Next

Donde Elemento es la variable de trabajo en donde se almacenará el elemento (TipoDato), que de no especificarse asumirá el mismo tipo de dato que tengan los elementos de la colección. Colección es la colección de objetos que podrán ser leídos de forma secuencial utilizando For Each. BloqueCodigo es el bloque de código que se ejecutará de forma iterativa para cada elemento de la colección explorado. Al encontrar Next el proceso iterativo comienza nuevamente; es posible interrumpir el ciclo en cualquier momento, utilizando Exit For.


Arreglos unidimensionales

Los arreglos unidimensionales se conocen simplemente como arreglos, y requieren de un sólo subíndice para tener acceso a un elemento del arreglo. La forma de declarar un arreglo en Visual Basic es la siguiente.

Dim Arreglo(MáximoSubíndice) As TipoDato

Donde Arreglo es el identificador del arreglo; su nombrado sigue las mismas reglas que las variables. MáximoSubíndice es el número mayor de subíndice del arreglo, y TipoDato es el tipo de dato de los elementos del arreglo.

Ejemplo.

Dim VentaMensual(11) As Integer


En este caso se tiene un arreglo de 12 posiciones (0 a 11), donde los elementos son de tipo Integer.

En caso de que no se especifique un número determinado de elementos, el arreglo será de un número indeterminado de elementos.

Dim VentaMensual() As Integer

A este tipo de arreglos se les llama arreglos unidimensionales, pues únicamente es necesario especificar un subíndice para tener acceso a una posición en memoria del arreglo.

También es posible asignar valores al momento de declarar un arreglo. En ese caso, no se deberá especificar número de elementos, ya que el número de elementos se calculará automáticamente considerando el número de valores que se especifiquen entre llaves ({ }), separados por comas (,). La sintaxis sería la siguiente.

Dim Arreglo() As TipoDato = {SerieValores}

Donde Arreglo es el nombre del arreglo, TipoDato es el tipo de dato de los elementos, y SerieValores es la serie de valores que asumirán los elementos; los valores deberán estar separados por comas.

Ejemplo.

Dim Numeros() As Integer = {10,20,40,100}

En este caso, Numeros(1) tendrá el valor de 20.


Arreglos multidimensionales

Se conoce como arreglos multidimensionales, a un conjunto de posiciones en memoria que son referidas por un solo identificador, a través de dos o más subíndices.

Al número de subíndices que es necesario especificar para tener acceso a una posición de memoria de un arreglo se le llama dimensionalidad (dimensionality), o rango (rank); Visual Basic acepta hasta 32 dimensiones.

A los arreglos de dos dimensiones (dimensionalidad 2), que son los multidimensionales más utilizados, se les da el nombre de arreglos rectangulares. La sintaxis para definirlos es la siguiente.

Dim Arreglo(MS1,MS2,...,MSn) As TipoDato

Donde Arreglo es el identificador del arreglo; su nombrado sigue las mismas reglas que las variables. MS1 es el número mayor de subíndice para la dimensión 1, MS2 es el número mayor de subíndice para la dimensión 2, y así hasta definir todas las


dimensiones. TipoDato es el tipo de dato de los elementos del arreglo.

Ejemplo.

Dim VentaTrim(2,3) As Integer

En este caso se tiene un arreglo de 12 posiciones (de 0 a 2, 3 posiciones; de 0 a 3, 4 posiciones; 3 posiciones x 4 posiciones=12), donde los elementos son de tipo Integer.

En caso de que no se especifique un número determinado de elementos, el arreglo será de un número indeterminado de elementos.

Dim VentaTrim(,) As Integer

A este tipo de arreglos se les llama arreglos multidimensionales, pues sólo es necesario especificar un subíndice para tener acceso a una posición en memoria del arreglo.

También es posible asignar valores al momento de declarar un arreglo. En ese caso, no se deberá especificar número de elementos, ya que el número de elementos se calculará automáticamente considerando el número de valores que se especifiquen entre llaves ({ }), separados por comas (,). Cada llave constituye la serie de valores para una dimensión. La sintaxis sería la siguiente.

Dim Arreglo(,) As TipoDato = {{SerieValores1},{SerieValores2}}

Donde Arreglo es el nombre del arreglo, TipoDato es el tipo de dato de los elementos, y SerieValores1 y SerieValores2 es la serie de valores que asumirán los elementos; los valores deberán estar separados por comas.

Ejemplo.

Dim VentaTrim(,) As Integer = {{1000,20000,10000,5000}, _

{2000,30000,15000,2000}}


En este caso, VentaTrim(1,2) tendrá el valor de 15000.


Arreglos escalonados

Se conoce como arreglos escalonados (jagged arrays) a un arreglo que almacena arreglos. La sintaxis para su definición sería la siguiente.

Dim Arreglo()() As TipoDato

Donde Arreglo es el identificador del arreglo; su nombrado sigue las mismas reglas que las variables. Dependiendo el número de arreglos que se desee incluir, se deberán agregar pares de paréntesis con posterioridad al nombre de variable. TipoDato es el tipo de dato que tienen los elementos en los arreglos.

Ejemplo.

Dim Numeros()() As Byte


En este caso se tiene un arreglo que almacenará dos arreglos, donde los elementos son de tipo Byte.

También es posible asignar valores al momento de declarar un arreglo. En ese caso, los valores son definiciones de arreglos.

Dim Arreglo()()As TipoDato = {Arreglo1,Arreglo2}

Donde Arreglo es el nombre del arreglo, TipoDato es el tipo de dato de los elementos, y Arreglo1 y Arreglo2 son arreglos con elementos que son TipoDato; los arreglos deberán estar separados por comas.

Ejemplo.

Dim Numeros()() As Byte = { Byte(){10,15,12,11}, _

Byte() {40,50,60} }

En este caso, Numeros(0)(3) tendrá el valor de 11. Estaríamos extrayendo, del arreglo 0, el elemento 3. El primer subíndice proporcionado indica el número de arreglo del que se trata, mientras que el segundo subíndice indica el o los subíndices del elemento que queremos extraer. Un arreglo escalonado puede contener arreglos unidimensionales o multidimensionales.

Los arreglos escalonados no son lo mismo que los arreglos multidimensionales; estos últimos pueden llegar a consumir cantidades muy grandes de memoria. Por ejemplo, si se quiere almacenar en un arreglo el número de identificación de 1000


empleados y 5 números de categorías de empleados, un arreglo multidimensional ocuparía 1000 x 5 posiciones de memoria, es decir, 5000; un arreglo escalonado, por el contrario, requeriría sólo 1000 + 5, es decir, 1005. Si el arreglo fuera de datos Long (8

bytes), la diferencia en consumo de memoria sería de 31,960, que bien podría economizar.

Una cosa importante a tomar en cuenta es que los arreglos escalonados no forman parte de CLS, por lo que sólo trabajarán adecuadamente en implementaciones Microsoft, y no en otras plataformas que implementen considerando CLS como base.


Ejercicios


1. Lab.01: Demostrando las capacidades de las variables ByVal y ByRef 2. Lab.02: Demostrando la declaración de variables, constantes y la realización de

conversiones 3. Lab.03: Demostrando el alcance de las variables y la forma en que preservan

valores 4. Lab.04: Comprobación de arreglos unidimensionales, multidimensionales y

escalonados


Lab.01: Demostrando las capacidades de las

variables ByVal y ByRef

En el presente ejercicio conoceremos la forma de agregar un proyecto a una solución existente, y además se comprobará el manejo del alcance de las variables.

1. Abra la solución ejercicios.

2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique ValRef. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.

3. Vea cómo en Solution Explorer se agrega el nuevo proyecto a la solución, y además se coloca como Start up Project, es decir, el que se ejecutará al lanzar la depuración con F5.

4. Edite el programa de tal forma que aparezca como sigue.


Codificación de ValRef - Module1.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

Option Explicit On Option Strict On Module Module1 Sub Main() Dim Texto As String = "Texto Original" Console.WriteLine(Texto) Valor(Texto) Console.WriteLine(Texto) Referencia(Texto) Console.WriteLine(Texto) Console.Write("Pulse INTRO para continuar") Console.ReadLine() End Sub Sub Valor(ByVal Texto As String) Texto = "Texto Valor" Console.WriteLine("<" & Texto & ">") End Sub Sub Referencia(ByRef Texto As String) Texto = "Texto Referencia" Console.WriteLine("<" & Texto & ">") End Sub End Module

Ejecución guiada de ValRef – Module1.vb

5. Construya la solución (CTRL-MAYÚS-B). Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) y guarde todos los cambios que ha realizado en la solución (CTRL-MAYÚS-S). Inicie la depuración para comprobar el comportamiento de su programa (F5).

6. Este programa es type safe, dado que todas las variables deberán declararse antes de ser utilizadas (Option Explicit) y las conversiones tienen que hacerse de forma explícita (Option Strict).

7. El programa declara una variable de memoria, llamada Texto, que se verá sometida a modificaciones en su contenido (línea 7); de inicio, se le asigna un valor de Texto original, mismo que es mostrado en la consola (línea 8).

La variable será proporcionada como argumento a dos procedimientos, uno de los cuales tratará el dato como valor (líneas 17 a la 20), y otro como referencia (líneas 22 a la 25).

8. Usando el dato como tipo valor. En la línea 9 se proporciona la variable como argumento de un procedimiento llamado Valor; dicho procedimiento recibe el valor y le da tratamiento como tipo valor. En


la línea 18 se modifica el valor de Texto, por Texto Valor, y se muestran los efectos del cambio en la línea 19.

Después de ejecutar Valor(), se muestra el contenido de la variable Texto (línea 10); nos podemos dar cuenta que, aunque se modificó el valor de la variable en el procedimiento, el valor original no se modificó en lo absoluto. Esto se debe a que el dato fue manejado como tipo valor, lo que provoca que el argumento genere su propia copia del dato, dejando al dato original intacto.

9. Usando el dato como tipo referencia. En la línea 11 se proporciona la variable como argumento de un procedimiento llamado Referencia; dicho procedimiento recibe el valor y le da tratamiento como tipo referencia. En la línea 23 se modifica el valor de Texto, por Texto Referencia, y se muestran los efectos del cambio en la línea 24.

Después de ejecutar Referencia, se muestra el contenido de la variable Texto (línea 12); nos podemos dar cuenta que el valor original se modificó. Esto se debe a que el dato fue manejado como tipo referencia, lo que provoca que el argumento no genere su propia copia del dato, sino que utilice para el manejo de información la misma posición de memoria que el valor original.

Si todo ocurrió como se esperaba, la salida será la siguiente:

Texto Original <Texto Valor> Texto Original <Texto Referencia> Texto Referencia Pulse INTRO para continuar

FIN DEL EJERCICIO


Lab.02: Demostrando la declaración de

variables, constantes y la realización de

conversiones

Se comprobará la declaración y uso de variables en un proceso.


2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique AreaRectangulo. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.


Codificación de AreaRectangulo - Module1.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

Module Module1 Sub Main() Const Titulo As String = "--- Rectángulo ---" Dim Base As Integer Dim Altura As Single = 0 Dim Resultado As Single, Entrada As String Console.WriteLine(Titulo) Console.Write("Base: ") Entrada = Console.ReadLine() Base = CInt(Entrada) Console.Write("Altura: ") Entrada = Console.ReadLine() Altura = CType(Entrada, Single) Resultado = (Base * Altura) Console.WriteLine("Resultado: " & Resultado.ToString()) End Sub End Module

Ejecución guiada de AreaRectangulo – Module1.vb


5. La línea 4 declara una constante, a la cual se le asigna como valor el mensaje que ha de aparecer como encabezado del programa (línea 9); en la línea 5 se muestra una declaración de variable, en su forma más


sencilla; en la línea 6 se comprueba que es posible asignar un valor inicial al momento de la declaración; en la línea 7 se comprueba la posibilidad de declarar múltiples variables de múltiples tipos en una misma línea; esta última práctica no se recomienda, por cuestiones de claridad en el código.

6. En la línea 9 se muestra el título del programa en la consola. En la línea 10 se muestra el mensaje que pregunta la base del rectángulo, y en la línea 11 se asigna a la variable Entrada el valor que el usuario ingresa desde la consola.

7. Como el dato se recibe en formato String desde la consola, la línea 12 se encarga de convertir el dato String en Integer, utilizando para ello la función específica CInt; el resultado es asignando a la variable Base. La misma mecánica se seguirá para preguntar y convertir la altura del rectángulo, con la diferencia que se utilizará para la conversión la función genérica CType.

8. La línea 17 calcula el área del rectángulo, asignando el valor a la variable Resultado. Como resultado es de tipo Single, posee de forma intrínseca el método ToString, que es utilizado en la línea 18 para mostrar los resultados.

9. Todas las conversiones que realizamos en este programa pudieron haberse obviado, dado que el programa no es type safe. En caso de no haber nosotros resuelto las conversiones de manera explícita, CLR hubiera realizado el casting.

10. Proporcione un valor de 10 para la base y un 15 para la altura, y vea los resultados.


Entrada

--- Rectángulo --- Base: 10 Altura: 15 Resultado: 150

FIN DEL EJERCICIO


Lab.03: Demostrando el alcance de las

variables y la forma en que preservan

valores



2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique Alcance. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.


Codificación de Alcance - Module1.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

Option Explicit On Option Strict On Module Module1 Dim Texto1 As String = "Alcance módulo" Sub Main() Console.WriteLine(Texto1) Dim Texto2 As String = "Alcance procedimiento" If Texto2 <> "" Then Console.WriteLine(Texto2) Dim Texto3 As String = "Alcance block" Console.WriteLine(Texto3) End If Procedimiento1() Procedimiento1() Procedimiento1() Procedimiento2() Console.WriteLine(" ") Console.Write("Pulse INTRO para continuar") Console.ReadLine() End Sub Sub Procedimiento1() Static Texto4 As String Texto4 = "Valor + " & Texto4 Dim Texto5 As String = "Texto 5" Console.WriteLine("--Procedimiento 1 ----") Console.WriteLine("Texto 1: " & Texto1) Console.WriteLine("Texto 4: " & Texto4) Console.WriteLine("----------------------") End Sub


34 35 36 37 38 39 40 41 42 43 44

Sub Procedimiento2() Console.WriteLine("--Procedimiento 2 ----") If Texto1 <> "" Then Dim Texto1 As String = "Shadow" Console.WriteLine("Texto 1: " & Texto1) End If Console.WriteLine("Texto 1: " & Texto1) Console.WriteLine("----------------------") End Sub End Module

Ejecución guiada de Alcance – Module1.vb


5. Este programa es type safe, dado que todas las variables deberán declararse antes de ser utilizadas (Option Explicit) y las conversiones tienen que hacerse de forma explícita (Option Strict). Líneas 1 y 2.

6. Se declaran variables con diferente alcance en las líneas 5, 9, y 12. En la línea 5 se declara la variable Texto1; esta variable tiene un alcance a nivel módulo, debido a que se declara dentro del módulo, fuera de cualquier procedimiento.

Esta variable podrá ser utilizada por todos los procedimientos del módulo, es decir, Main(), Procedimiento1(), y Procedimiento2(); esto se comprueba en la líneas 8 y 29, pues se despliega en la consola una variable no definida en esos procedimientos.

En la línea 9 se declara la variable Texto2, que tiene un alcance a nivel procedimiento, por estar declarada dentro de un procedimiento específico, pero fuera de un bloque de código; por esa razón se trata de una variable local. Esta variable estará disponible sólo para Main(), pero no para otros procedimientos.

En la línea 12 se declara la variable Texto3, que tiene un alcance a nivel bloque de código, y estará disponible desde que se declara (línea 12) hasta que se encuentre el estatuto que marca el final del bloque de código, en este caso End If, en la línea 14.

Si se trata de utilizar la variable Texto3 después de la línea 14, pensando que es una variable local (de alcance a nivel procedimiento), nuestro programa generará error, ya que la variable sólo existe declarada para el bloque en que se declara.


7. Comprobando la variable estática. En la línea 15 se manda ejecutar Procedimiento1(); en dicho procedimiento se define una variable estática llamada Texto4 (línea 25). Esta variable tendrá un tiempo de vida que excede el tiempo de vida del procedimiento que la declara, ya que por ser estática, mantendrá los valores en memoria aun concluida la ejecución del procedimiento.

En la línea 26 se asigna a Texto4 la constante String Valor + que se concatenará con el valor que tenga la misma Texto4; en virtud de que la variable es estática, el valor que va adoptando se comporta como un acumulador, que nunca pierde el valor que tenía, obtenido de procesamientos anteriores.

Las líneas 16 y 17 mandan ejecutar Procedimiento1(), a fin de que se compruebe que efectivamente la variable mantiene su valor al correr de las múltiples ejecuciones del procedimiento.

8. Comprobando Shadowing. Ya vimos que en la línea 5 Texto1 se definió con un alcance a nivel módulo, y al momento de declarar la variable se le asignó el valor Alcance módulo. En Procedimiento2(), se vuelve a definir la variable Texto1 (línea 37), y se le asigna al momento de declaración el valor Shadow.

9. a) ¿Qué alcance tiene la variable Texto1, declarada en la línea 37?

b) ¿Qué valor posee Texto1, cuando es desplegada en la consola en la línea 38?

c) ¿ Qué valor posee Texto1, cuando es desplegada en la consola en la línea 40?

Como podrá darse cuenta, el programa no genera conflicto con la doble declaración de la variable; simplemente utiliza aquella que tenga menor alcance.



Alcance módulo Alcance procedimiento Alcance block --Procedimiento 1 ---- Texto 1: Alcance módulo Texto 4: Valor + ---------------------- --Procedimiento 1 ---- Texto 1: Alcance módulo Texto 4: Valor + Valor + ---------------------- --Procedimiento 1 ---- Texto 1: Alcance módulo Texto 4: Valor + Valor + Valor + ---------------------- --Procedimiento 2 ---- Texto 1: Shadow Texto 1: Alcance módulo ---------------------- Pulse INTRO para continuar

10. Modifique la línea 21, sustituyendo el estatuto de declaración Static por Dim. Ejecute el programa nuevamente, y explique qué sucede:

FIN DEL EJERCICIO


Lab.04: Comprobación de arreglos

unidimensionales, multidimensionales y

escalonados



2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique Arreglos. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.


Codificación de Arreglos - Module1.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

Option Explicit On Option Strict On Module Module1 Sub Main() Dim i As Integer Console.WriteLine("Arreglo unidimensional 1:") Dim Uni1() As Integer = {22, 49, 20, 40} For Each i In Uni1 Console.WriteLine(i) Next Console.WriteLine("Arreglo unidimensional 2:") Dim Uni2() As Integer = {55, 66, 77} For Each i In Uni2 Console.WriteLine(i) Next Console.WriteLine("Arreglo multidimensional:") Dim Multi(,) As Integer = {{92, 49}, {44, 20}, {10, 48}} Console.WriteLine( _ String.Format("Fila 0: {0},{1} ", Multi(0, 0), Multi(0, 1))) Console.WriteLine( _ String.Format("Fila 1: {0},{1} ", Multi(1, 0), Multi(1, 1))) Console.WriteLine( _ String.Format("Fila 2: {0},{1} ", Multi(2, 0), Multi(2, 1))) Console.WriteLine("Arreglo escalonado:") Console.WriteLine("Arreglo 1, posición 2") Dim Esca()() As Integer = {Uni1, Uni2} Console.WriteLine(Esca(1)(2)) Console.Write("Presione INTRO") Console.ReadLine() End Sub End Module


Ejecución guiada de Arreglos – Module1.vb


5. En la línea 10 se declara un arreglo unidimensional, llamado Uni1, y al mismo tiempo que se declara se le asignan valores a las posiciones de memoria del arreglo. Se trata de un arreglo de 4 posiciones de memoria, por lo que sus subíndices irán de 0 a 3.

22

49

20

40

En la línea 11 se inicia una estructura For Each que permitirá hacer una lectura de los valores almacenados en el arreglo. La estructura utilizará la variable i que es de tipo Integer, para trabajar cada uno de los elementos del arreglo Uni1. La estructura For Each comenzará una lectura secuencial de todos los elementos, desde el subíndice 0 hasta el 3; i asumirá el valor del elemento que se esté leyendo en el momento, por lo que trabajar con i es como estar trabajando con el elemento del arreglo. La línea 12 provoca que se vea en la consola el contenido de cada una de las posiciones en memoria.

La línea 16 declara un arreglo unidimensional de tres posiciones, llamado Uni2, que será utilizado junto con Uni1 más adelante. El proceso para el mostrado de contenido se repite con Uni2. Sus valores son los siguientes.

55

66

77


6. En la línea 22 se declara un arreglo multidemensional, llamado Multi, constituido por dos dimensiones. Se asignan valores al momento de la declaración, que nos indican que el arreglo será de dos columnas y tres filas. Vea cómo el número de series de valores determina el número de filas, mientras que el número de elementos de cada serie de valores determina el número de columnas.

92 49

44 20

10 48

Las líneas de la 23 a la 28 se encargan de mostrar los valores que componen cada fila. Para ello nos apoyamos de la función String.Format, que hace una sustitución directa de parámetros; vea cómo funciona.

String.Format(“Primer valor {0} segundo valor {1}”, 10, 20)

Generaría como resultado:

“Primer valor 10 segundo valor 20”

Los parámetros se incluyen con base 0, y deberá proporcionarse una serie de valores separados por comas después del String que queremos construir. El primer valor de la serie toma el la primera posición ({0}), el segundo la segunda ({1}), y así.

Los subíndices en los arreglos indican la fila y la columna, considerando una base cero.

7. La línea 32 define un arreglo escalonado, llamado Esca, que almacena los arreglos Uni1 y Uni2.

22 55

49 66

20 77


40

La línea 33 muestra, del segundo arreglo almacenado (subíndice 1), el tercer elemento almacenado (subíndice 2). Entre los primeros paréntesis irá el subíndice del arreglo escalonado, es decir, permite seleccionar al arreglo a inspeccionar. En los siguientes paréntesis se coloca el subíndice (o subíndices) del arreglo seleccionado.

A diferencia de un arreglo multidimensional, en donde todas las filas tienen igual número de columnas, en un arreglo escalonado la forma y dimensiones dependen de los arreglos almacenados.


Arreglo unidimensional 1: 22 49 20 40 Arreglo unidimensional 2: 55 66 77 Arreglo multidimensional: Fila 0: 92,49 Fila 1: 44,20 Fila 2: 10,48 Arreglo escalonado: Arreglo 1, posición 2 77 Presione INTRO

8. Vea el siguiente ejemplo, y coloque las referencias que hacen falta. a. Utilizando Uni1. 49 = Uni1(1) b. Utilizando Uni2. 55 = _________________________ c. Utilizando Multi. 10 = _________________________ d. Utilizando Esca. 66 = _________________________

FIN DEL EJERCICIO


Operadores aritméticos

¿Quién no conoce los operadores aritméticos? Por formar parte de la educación básica difícilmente podríamos agregar algo que no sepa con respecto a ellos; quizá la novedad puede ser que expliquemos cómo utiliza los operadores aritméticos el Visual Basic. No obstante lo obvio, para no ser omisos definiremos a los operadores aritméticos como los símbolos que producen, a partir de dos expresiones numéricas conocidas, una nueva expresión numérica, como resultado de la aplicación de un cálculo aritmético entre aquellas. El lenguaje dispone de los siguientes operadores aritméticos básicos.

+ Suma

(concatenación) Suma expresiones numéricas. Concatena expresiones de tipo String.

- Resta Representa la diferencia entre dos números o especifica la condición negativa de uno.

* Multiplicación Multiplica dos números.

/ División Divide un número entre otro.


\ División entera Divide un número entre otro, dando un resultado necesariamente entero.

Mod Módulo Divide un número entre otro, dando como resultado el residuo.

^ Exponenciación Sirve para elevar un número a una determinada potencia; un número puede ser negativo si el exponente es un entero.

La forma en que se resuelven este tipo de operadores es la siguiente.

Resultado = Expresión1 Operador Expresión2

Expresión1 y Expresión2 serán siempre datos numéricos. Resultado será siempre numérico. Operador es el operador aritmético utilizado.

Se debe tomar en cuenta que Resultado puede no ser del mismo tipo que las expresiones, por ejemplo, la suma de dos Integer, 2,000,000,000 y 2,000,000,000, no será Integer, y la división de un Integer 3, entre 2, no dará un número Integer.

NNOOTTAA

En el caso de los datos de tipo String, es posible utilizar el operador de

suma, que se encarga de concatenar o unir las expresiones.

Para evitar la ambigüedad del operador “+”, Visual Basic soporta el uso del

símbolo “&” para concatenación de expresiones String. Realmente la

concatenación no se considera una operación aritmética.


Operadores de asignación

Los operadores de asignación son los que permiten asignar un valor a una variable o propiedad. El ejemplo clásico de este tipo de operadores es el signo de igual (=).

Variable = Valor

Donde Variable es una variable o propiedad que puede recibir valores, y Valor, una expresión válida para el tipo de dato de Variable.

Expresión

Aunque puede resultar obvio explicarlo, una expresión es un valor, existente o derivado; es valor existente si corresponde a una literal válida para un determinado tipo de dato, o una variable que la contenga; es valor derivado, cuando es el resultado de someter varios valores existentes, sean éstos variables o literales, a la acción de operadores.


Vea los ejemplos siguientes de expresiones.

4 Existente. Valor numérico 4

“A” Existente. Valor String A

4 + 5 Derivado. Valor numérico 9

3 = 2 Derivado. Valor lógico False, pues 3 y 2 no

son iguales

“A” & “B” Derivado. Valor de concatenación String AB

Vea estos otros ejemplos, si definimos la siguiente variable.

Dim Edad As Integer = 20

Expresiones que podemos utilizar.

Edad La variable misma

str(Edad) La transformación de la variable

“Edad:” & Str(Edad) La transformación de la variable y

otras literales


Operadores de asignación incluyente

Son operadores de asignación incluyente, aquellos que consideran el valor que posee la variable o propiedad a la que se le asigna el valor como primera expresión de una operación, asignando el resultado de la operación a la variable misma.

Los operadores de asignación incluyente existen para los siguientes operadores: ^, *, /, \, +, -, &, y la forma de representarlos es el operador, seguido inmediatamente por un signo de igual. Veamos las siguientes asignaciones equivalentes.

x = x +1 Es lo mismo que x += 1

x = x-1 Es lo mismo que x -= 1

x = x * 4 Es lo mismo que x *= 4

x = x ^ 2 Es lo mismo que x ^= 2


Vea los siguientes ejemplos.

Si Var1 vale Y Var2 vale La operación Hace que Var1

valga

10 3 var1 ^= var2 1000

10 3 var1 *= var2 30

12 3 var1 /= var2 4

10 3 var1 \= var2 3

10 3 var1 += var2 13

“ABC” “DEF” var1 &= var2 “ABCDEF”

10 3 var1 -= var2 7


Operadores comparativos

Los operadores comparativos son los que permiten comparar expresiones, una en relación a la otra, proporcionando un valor de falso (False), verdadero (True), o nulo (Null), dependiendo si la comparación es una verdad o no.

Hasta el momento no hemos tratado los valores nulos; los valores nulos son la ausencia de valor alguno, y su utilidad es para aplicaciones específicas en donde la afectación de un valor es importante.


La tabla que sigue describe los operadores comparativos que Visual Basic maneja.

Operador Verdadero si

Falso si Nulo si

< (Menor que)

expresión1 < expresión2

expresión1 >= expresión2

expresión1 o expresión2 = Null

<= (Menor o igual que)

expresión1 <= expresión2

expresión1 > expresión2


> (Mayor que)

expresión1 > expresión2

expresión1 <= expresión2


>= (Mayor o igual que)

expresión1 >= expresión2

expresión1 < expresión2


= (Igual a)

expresión1 = expresión2

expresión1 <> expresión2


<> (Distinto de)

expresión1 <> expresión2

expresión1 = expresión2



Resultado = Expresión1 Operador Expresión2

Expresión1 y Expresión2 pueden ser cualquier tipo de expresiones comparables entre sí. Resultado será siempre lógico (True, False), o nulo (Null). Operador es el operador utilizado para la comparación.

Algunos ejemplos del uso de estos operadores son.

“A” = “B” Retorna False

1 > 0.5 Retorna True

2 >= 2 Retorna True

“S” < “s” Retorna True

Tome en cuenta que las letras mayúsculas, para efectos de comparación, tienen un valor en código ASCII menor a las minúsculas, y por tanto, son menores. Adicionalmente, la “A” es menor que la “Z”.


Consideraciones relativas al código ASCII

El juego de caracteres de 7 bits denominado ASCII (American Standard Code Information Interchange / Código Americano Estándar para Intercambio de Información), es ampliamente utilizado para representar letras y símbolos de un teclado estándar de EE.UU. El juego de caracteres ASCII es igual que los primeros 128 caracteres (0–127) del juego de caracteres ANSI, utilizado por las máquinas antiguas.

Es importante que conozca algunas referencias del código ASCII que pueden serle de utilidad.

Código ASCII Representa

8 BackSpace (RETROCESO)

13 Enter (INTRO)

32 SpaceBar (BARRA ESPACIADORA)

64 “@”

92 “\”

Código ASCII Representa

48 al 57 “0” al “9”

65 al 90 “A” a la “Z”

97 al 122 “a” a la “z”

225, 233, 237, “á”, “é”, “í”,

243, 250, 241 “ó”, “ú”, “ñ”

Algunas personas, sobre todo aquellas que no tienen su teclado configurado adecuadamente, saben que presionando la tecla ALT, y sin soltar dicha tecla, se escribe con el teclado numérico un código ASCII, éste aparecerá. Para ello es necesario que el teclado numérico esté activado (teniendo el BLOQ NUM / NUM LOCK Activado).

De tal forma que:

Alt + 64 Equivale a teclear “@”

Visual Basic, por otro lado, tiene funciones que permiten obtener la representación simbólica de un código ASCII, así como de obtener el código ASCII a partir de una representación simbólica. Las funciones que lo permiten son Chr( ) y Asc( ), respectivamente.


Sintaxis.

Chr(CódigoASCII )

Asc(“Caracter”)

Ejemplos.

Chr( 64 ) “@”

Asc( “@” ) 64


Option compare

Uno de los conceptos importantes respecto a la comparación de datos, específicamente de los datos de tipo cadena (String), es su sensibilidad al reconocimiento de mayúsculas y minúsculas.

Se dice que un esquema de comparación es case-sensitive, cuando una comparación es sensible a la diferencia entre mayúsculas y minúsculas (“A” ≠ “a”); se dice que un esquema de comparación es non case-sensitive, cuando una comparación no es sensible a la diferencia entre mayúsculas y minúsculas (“A” = “a”).

En el caso de Visual Basic, podemos especificar de qué manera queremos que nuestros programas se comporten respecto a las comparaciones. Para ello, utilizamos el estatuto Option Compare.

Su sintaxis es la siguiente.

Option Compare [Text | Binary]

Si se especifica Option Compare Text, las comparaciones se realizarán bajo el esquema non case-sensitive; si se especifica Option Compare Binary, las comparaciones se realizarán bajo el esquema case-sensitive.


Option Compare debe especificarse al inicio de los programas, antes de cualquier línea de código. Si se omite la especificación, el esquema de comparación será case-sensitive (Binary).


Operadores Is, IsNot y TypeOf

Además de los operadores comparativos comunes, Visual Basic posee dos operadores comparativos especiales: Is y Like.

El operador Is es un operador que informa si una variable hace referencia a la misma posición de memoria que otra.

La forma en que se resuelve este operador es la siguiente.

Resultado = Expresión1 Is Expresión2

Expresión1 y Expresión2 deben ser variables de tipo reference type. Resultado será siempre lógico (True, False).

Is retornará verdadero (True) si las variables comparadas refieren a la misma posición de memoria, y retornará falso (False) si refieren a posiciones distintas de memoria.

En ocasiones lo que se desea saber es si un objeto no referencia la misma posición que otro. Anteriormente, la tarea se debía realizar combinando los operadores Not e Is, de la siguiente forma.

If Not Objeto1 Is Objeto2 Then WriteLine(“Diferentes”)


Dado que esta expresión es poco natural en su lectura, Visual Basic incluye el operador IsNot, que retorna True en caso de que dos objetos no refieran a la misma posición de memoria.

La línea de código quedaría como sigue.

If Objeto1 IsNot Objeto2 Then WriteLine(“Diferentes”)

En ocasiones la comparación no se realiza entre un objeto y otro, sino entre un objeto y un type. Visual Basic incluye un operador denominado TypeOf... Is, que retorna verdadero en caso de que un objeto sea de un determinado type. Por ejemplo, si deseamos saber si la variable X es de tipo Integer, tendríamos que especificar lo siguiente.

If (TypeOf X Is Integer) Then WriteLine(“X es Integer”)


Operador Like

El operador Like compara dos expresiones String, no en términos de igualdad, sino en términos de cumplimiento de un patrón determinado.

Este operador es especialmente útil si tiene que verificar si una cadena de caracteres compuesta obedece a un formato predefinido. Imagine un código de producto que siempre sea tres letras, un guión, y cuatro números; en ese caso, tiene dos opciones: utilizar Like o desarrollar una rutina que analice caracter por caracter la expresión y sus posiciones. Sobra decir que utilizar Like es mucho más efectivo.

La forma en que se resuelve este operador es la siguiente.

Resultado = Expresión1 Like Expresión2

Expresión1 debe ser expresiones String. Expresión2 es un patrón String que se pretende reconocer como existente en Expresión1. Resultado será siempre lógico (True, False).


Like retornará verdadero (True) si el patrón a buscar es reconocido dentro del dato String base de la comparación, y falso (False) en caso de que no se reconozca.

El patrón a buscar, llamado patrón nominado, es una literal conformada por caracteres especiales que representan el contenido de caracteres a buscar; a continuación una tabla que muestra dichos caracteres y su significado.

Caracter de patrón Significado

? Cualquier caracter

* Varios caracteres o ninguno

# Cualquier dígito (0-9)

[lista] Cualquier caracter en la lista

[!lista] Cualquier caracter que no esté en la lista

Vea los siguientes ejemplos.

“F” Like “F” Retorna True

“24/10/2002” Like “##/##/####” Retorna True

“ABC” Like “AB*” Retorna True

“MP3” Like “[A-Z][A-Z]#” Retorna True

“MPG” Like “[A-Z][A-Z]#” Retorna False

“MP3” Like “[A-Z][A-Z]?” Retorna True

“MPG” Like “[A-Z][A-Z]?” Retorna True

“AMERICA” Like “A*A” Retorna True

“HP2992” Like “[!H]*” Retorna False

“DP2992” Like “[!H]*” Retorna True

“[email protected]” Like “*@*” Retorna True

Recomendamos que utilice los patrones para determinar la validez de formatos mixtos de datos, por ejemplo claves de cuatro letras y tres números.


Si lo que va a evaluar son formatos más estándar, como números o fechas, recomendamos otras funciones más sofisticadas, como IsNumeric() o IsDate().


Operadores lógicos

Los operadores lógicos son aquellos que sirven para unir o negar condiciones, produciendo un valor lógico. Los operadores lógicos básicos son.

Not. niega el resultado de una condición. Revierte el valor; si la condición que afecta es True producirá False, y viceversa.

And. cuando de entre dos condiciones, las dos deben ser True para que en su conjunto la expresión sea True. (Todas las condiciones True, retronará True).

Or. cuando de entre dos condiciones, al menos una debe ser True para que en su conjunto la expresión sea True. (Al menos una condición True, retronará True).

Xor. cuando entre dos condiciones, al menos una cumple por True, pero no las dos.


Resultado = [Expresión1] Operador Expresión2


Expresión1 y Expresión2 son expresiones de tipo lógico. En el caso de Not, Expresión1 no se debe poner, ya que el operador actúa sobre una sola expresión. Resultado será siempre lógico (True, False).

Cuando una expresión lógica se compone por una sola comparación, se dice que es una expresión lógica simple, debido a que sólo se resolverá en un tiempo; si involucra dos o más comparaciones, o la utilización de un operador lógico, se dice que es una expresión lógica compuesta, debido a que la expresión lógica deberá resolverse en dos o más tiempos (se resuelve la comparación, y luego se resuelve dentro del contexto en que se encuentra). Una expresión lógica compuesta siempre se compone de expresiones lógicas simples, afectadas por operadores lógicos que las obligan a resolverse como una sola expresión lógica.

Ejemplos.

Not True Es False, porque es lo contrario a True.

Not False Es True, porque es lo contrario a False.

Not “A” = “B” Es True, porque “A” = “B” es False, pero negado es True.

“A” = “B” And 1 > 0.5

Es False, porque no todas las condiciones son True.

“A” = “B” Or 1 > 0.5

Es True, porque al menos una condición es True.

En caso de que tenga más de dos condiciones conjuntas, entra en operación lo que se conoce como preferencia, que consiste en determinar el orden en que las condiciones u operaciones se han de resolver.

Ejemplo.

“A” = “B” OR 1 > 0.5 AND 2 >= 2 AND “S” > “s”

Es False. Las condiciones se resuelven de izquierda a derecha. Vea la explicación basada en la figura 06.01.


Figura 06.01

Resolución de una expresión con múltiples condiciones

Primero se resuelven las condiciones de comparación.

Ya que se resolvieron las condiciones de comparación, se sigue el orden de izquierda a derecha; la primera condición de tipo lógico se resuelve; el resultado de ésta forma parte de la siguiente condición, y así hasta terminar.

La expresión inicia siendo una expresión lógica compuesta, formada por cuatro expresiones lógicas simples, que con la ayuda de tres operadores lógicos, se ven obligadas a resolverse como una sola expresión lógica que termina con un valor False.

Las condiciones se resuelven como si tuvieran paréntesis imaginarios.

( ( (“A” = “B” Or 1 > 0.5) And 2 >= 2) And “S” > “s”)

En donde las condiciones encerradas en los paréntesis de mayor profundidad se resuelven primero.

Si usted agrega de manera explícita paréntesis en las condiciones, les asignará preferencia. Por ejemplo, cambiemos un poco el orden del ejemplo anterior y veamos qué sucede.

“S” > “s” Or 2 >= 2 And 1 > 0.5 And “A” = “B”

De acuerdo a lo que vimos, se resolvería la primera condición con la segunda (False Or True, se resuelve a True), el resultado se resolvería con la tercera (True And True, retorna True), y el


resultado se resolvería con la cuarta (True And False, retorna False).

El resultado de lo último que se resolvió fue False.

¿Cómo cambiaríamos la condición, mediante el uso de paréntesis, para que el resultado fuera verdadero? A continuación una solución.

(“S” < “s” OR ( 2 >= 2 AND 1 > 0.5 And “A” = “B”))

De esta forma forzamos que en primera instancia se resuelva el paréntesis de mayor profundidad, que contiene la segunda, tercera y cuarta expresión (True And True And False, retrona False), el resultado se resuelve con la primera condición, por ser el paréntesis de mayor profundidad que sigue (True Or False, resuelve True).

Considere como regla que siempre que abra paréntesis los tiene que cerrar.

Una inadecuada colocación de condiciones puede arrojar resultados erróneos; le recomendamos que aunque de forma predefinida existe una preferencia, usted determine claramente qué preferencia desea, utilizando paréntesis cuando tenga más de una condición por resolver.


Operadores lógicos de circuito corto

En programación es común que para que algo suceda, debe cumplirse más de una condición. Uno de los problemas que tenía la anterior versión de Visual Basic, es que no era lo suficientemente inteligente para saber que ya no tenía caso resolver ciertas condiciones, en el caso de And y Or.

Sabemos que en el caso de And, si una expresión lógica es False todo es False; si en una comparación nos encontramos que la primera expresión lógica es False, ¿qué caso tiene resolver la segunda expresión?

Se denominan operadores lógicos de circuito corto (short- circuiting), aquellos que son lo suficientemente inteligentes como para determinar la necesidad de continuar evaluando condiciones posteriores a las primeras.

Básicamente son dos.

AndAlso. procesa comparaciones lógicas de circuito corto, de tipo And; produce False a la primera expresión False que se encuentra, y concluye con la resolución de expresiones.

OrElse. procesa comparaciones lógicas de circuito corto, de tipo Or; produce True a la primera expresión True que se encuentra, y concluye con la resolución de expresiones.


Tabla de comportamiento de operadores lógicos

La siguiente tabla muestra el comportamiento de los operadores lógicos.

Operador Si Expresión1 es Y Expresión2 es Resultado

And True True True And True False False And False True False And False False False

Or True True True Or True False True Or False True True Or False False False

Xor True True False Xor True False True Xor False True True Xor False False False AndAlso True True True AndAlso True False False AndAlso False Ni siquiera se

evalúa

False

AndAlso False Ni siquiera se evalúa

False

OrElse True Ni siquiera se evalúa

True

OrElse True Ni siquiera se evalúa

True

OrElse False True True OrElse False False False


Prioridad entre operadores

Cuando hay varias expresiones dentro de una expresión que las engloba, cada parte de la misma se evalúa y se resuelve en un orden predeterminado, donde ciertos operadores han de resolverse antes que otros, a lo que se llama prioridad de los operadores. Esto es importante, ya que algunos operadores requieren resolver expresiones derivadas antes de poder ser resueltas.

Por ejemplo.

(2+5) > (3+1)

No podemos resolver la expresión que implica el operador comparativo (>), si antes no resolvemos las expresiones que involucran el operador de suma (+). El procesador no resuelve operaciones a nivel abstracto.

Cuando hay expresiones que contienen operadores de más de una categoría (aritméticos, de comparación y lógicos), se resuelven en este orden.


1. Las expresiones que tienen operadores aritméticos.

2. Las expresiones que tienen operadores de comparación.

3. Las expresiones que involucran operadores lógicos.

Esto tiene sentido si tomamos en cuenta que la materia prima para los operadores aritméticos son generalmente expresiones numéricas o expresiones String, y con ellos se genera una nueva expresión numérica o expresión String.

Los operadores de comparación, por su parte, tienen como materia prima dos expresiones numéricas o expresiones String, y con ellos se determina un valor lógico.

Por último, los operadores lógicos permiten generar una expresión lógica de dos expresiones lógicas.

Los operadores de comparación tienen la misma prioridad, es decir, se evalúan de izquierda a derecha, en el orden en que aparecen. Los operadores se evalúan en el siguiente orden de prioridad.

Aritméticos

Exponenciación (^)

Negatividad de expresión (–)

Multiplicación y división (*, /)

División de enteros (\)

Módulo aritmético (Mod)

Adición y substracción (+, –)

Comparación

Igualdad (=)

Desigualdad (<>)

Menor que (<)

Mayor que (>)

Menor o igual que (<=)

Mayor o igual que (>=)


Lógicos

Not

And

Or

Xor

Cuando hay multiplicación y división en la misma expresión, cada operación se evalúa a medida que aparece, de izquierda a derecha. Del mismo modo, cuando se presentan adiciones y substracciones en una misma expresión, cada operación se evalúa tal como aparecen de izquierda a derecha.

Uso de paréntesis para otorgar preferencia de ejecución

Es posible usar paréntesis para saltar el orden de preferencia y forzar que algunas partes de una expresión se evalúen antes que otras. Las operaciones entre paréntesis se realizarán antes que aquellas que se encuentren fuera. Sin embargo, dentro de los paréntesis, la prioridad de los operadores se mantiene según las reglas.

Cuando utilizamos los paréntesis para determinar un orden determinado en que se han de resolver las expresiones, hablamos que se está especificando la preferencia de ejecución explícita. Cuando dejamos que el lenguaje proporcione el orden de izquierda a derecha, atendiendo a la prioridad de los operadores, hablamos de la preferencia de ejecución automática. Los programadores profesionales acostumbran el uso de la preferencia de ejecución explícita, ya que es más fácil de analizar al momento de depurar los programas, y deja una idea clara de la forma en que queremos que las cosas se resuelvan.

El operador de concatenación de cadenas (&) no es realmente un operador aritmético, pero en orden de prioridad se encuentra a continuación de todos los operadores aritméticos y antes que todos los operadores de comparación.

No olvide que por más larga que parezca una expresión, todos los operadores actúan sobre dos expresiones, y de dos en dos, hasta dejar una sola expresión final, que podrá ser asignada a una variable o propiedad, o utilizada por algún estatuto o función.


Ejercicios


1. Lab.05: Utilización general de operadores en Visual Basic 2. Lab.06: Uso de operadores de asignación incluyente y operadores de circuito

corto


Lab.05: Utilización general de operadores en

Visual Basic

En el presente ejercicio conoceremos el uso de los operadores en Visual Basic, y la forma en que derivan resultados a partir de valores existentes.


2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique Operadores. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.


Codificación de Operadores - Module1.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Module Module1 Sub Main() Dim Numero1 As Integer = 5 Dim Numero2 As Single = 2 Dim Texto1 As String = "Visual " Dim Texto2 As String = "Basic.NET" Console.WriteLine(Numero1) Console.WriteLine(Numero2) Console.WriteLine(Numero1 + Numero2) Console.WriteLine(Numero1 - Numero2) Console.WriteLine(Numero1 * Numero2) Console.WriteLine(Numero1 / Numero2) Console.WriteLine(Numero1 \ Numero2) Console.WriteLine(Numero1 Mod Numero2) Console.WriteLine(Texto1 Is Texto2) Console.WriteLine(Texto1 IsNot Texto2) Console.WriteLine(Texto1 + Texto2) Console.WriteLine(Texto1.Trim() + Texto2.Trim()) Console.WriteLine(Texto1.Trim() + " " + Texto2.Trim()) Console.WriteLine("Pulse INTRO para continuar") Console.ReadLine() End Sub End Module


Ejecución guiada de Operadores – Module1.vb


5. Los resultados son simples resoluciones de operadores que no requieren explicaciones. Lo único novedoso es el uso de método Trim del objeto String, que se encarga de eliminar los espacios adicionales en el texto. Los resultados deben ser los siguientes.

5 2 7 3 10 2.5 2 1 False True Visual Basic.NET VisualBasic.NET Visual Basic.NET Pulse INTRO para continuar

FIN DEL EJERCICIO


Lab.06: Uso de operadores de asignación

incluyente y operadores de circuito corto

En este ejercicio se utilizará una aplicación de consola para comprobar los operadores de asignación incluyente, así como los operadores de circuito corto.

El programa solicita tres números del 1 al 10. A través de asignación incluyente se acumularán los valores capturados, y mediante los operadores de circuito corto se hará más eficiente un proceso, detectándose de entre los números capturados alguno que sea primo. Recuerde que un número primo es aquel que sólo se divide entre 1 y entre sí mismo; en el rango de nuestro ejemplo, sólo se tienen el 1, 2, 3, y 7.

En este ejercicio se utilizará una aplicación de consola para comprobar la declaración y uso de variables en un proceso.


2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique Primos. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.


Codificación de Primos - Module1.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

Option Explicit On Option Strict On Module Module1 Sub Main() Dim N1 As Integer Dim N2 As Integer Dim N3 As Integer Dim Total As Integer = 0 Console.WriteLine("-- Suma de 3 números ---------------") Console.WriteLine("-- Sólo capture enteros del 1 al 10") Console.Write("Número 1 de 3:") N1 = CInt(Console.ReadLine()) Console.Write("Número 2 de 3:") N2 = CInt(Console.ReadLine()) Console.Write("Número 3 de 3:") N3 = CInt(Console.ReadLine()) Total += N1 Total += N2 Total += N3


25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

If ((N1 = 1 OrElse N1 = 2 OrElse N1 = 3 OrElse N1 = 7) OrElse _ (N2 = 1 OrElse N2 = 2 OrElse N2 = 3 OrElse N2 = 7) OrElse _ (N3 = 1 OrElse N3 = 2 OrElse N3 = 3 OrElse N3 = 7)) Then Console.WriteLine("Al menos uno de los números es primo") Else Console.WriteLine("Ninguno de los números es primo") End If Console.WriteLine("Total:" & CType(Total, String)) Console.WriteLine("Pulse INTRO para continuar") Console.ReadLine() End Sub End Module

Ejecución guiada de Primos – Module1.vb


5. El programa declara las variables de trabajo de la línea 5 a la 8.

6. Es importante que vea cómo estamos haciendo la conversión de datos, tanto al momento de recibir los valores de consola, como al mostrarlos, dado que nuestro programa es type safe.

7. Capture como datos de entrada los números 4, 6, 8.

La línea 22 ejecuta una asignación incluyente basada en suma; Total += N1, es igual que haber escrito Total = Total + N1. En este caso, N1

vale cero porque no se le especificó valor al momento de ser declarada. Después de la línea 22, Total vale 0 + 4, es decir 4; después de la línea 23, vale 4 + 6, es decir 10, y después de la línea 24, vale 10 + 8, es decir 18.

Las líneas 26, 27 y 28 realmente son una sola línea de código. Se estará evaluando si N1 es alguno de los números primos posibles del 1 al 10. Si N1 es igual a 1, o igual a 2, o igual a 3, o si es igual a 7, la primera expresión es True. La misma comparación se realiza con N2 y con N3.

Internamente, con los números que se proporcionaron, se resolverían de la siguiente manera:

if ((False OrElse False OrElse False OrElse False) OrElse _

(False OrElse False OrElse False OrElse False) OrElse _

(False OrElse False OrElse False OrElse False))


Que sería lo mismo que:

if (False)

Por tanto, el programa tendría una salida falsa, reportando que ninguno de los números tecleados es primo.


-- Suma de 3 números --------------- -- Sólo capture enteros del 1 al 10 Número 1 de 3:4 Número 2 de 3:6 Número 3 de 3:8 Ninguno de los números es primo Total:18 Pulse INTRO para continuar

8. Ahora ejecute el ensamblado, capturando los números 3, 6, 8.

Si N1 es igual a 1, o igual a 2, o igual a 3, o si es igual a 7, la primera expresión es True. La misma comparación se realiza con N2 y con N3.

Internamente, con los números que se proporcionaron, se resolverían de la siguiente manera:

If ((False OrElse False OrElse True OrElse False) OrElse _

(False OrElse False OrElse False OrElse False) OrElse _

(False OrElse False OrElse False OrElse False))

Que sería lo mismo que:

If (True)

Si se fija, la forma en que se resuelve la condición es mucho más simple. Esto es gracias a los operadores de circuito corto. Al resolver la primer condición, esta se resuelve por True, debido a que con Or, ante la presencia de al menos un True, todo es True, ya no sigue evaluando más condiciones.


-- Suma de 3 números --------------- -- Sólo capture enteros del 1 al 10 Número 1 de 3:3 Número 2 de 3:6 Número 3 de 3:8 Al menos uno de los números es primo Total:17 Pulse INTRO para continuar

FIN DEL EJERCICIO


Estatuto If Then Else

Son estructuras de decisión aquellas estructuras del lenguaje que permiten decidir qué líneas de código se han de ejecutar, dependiendo de una condición determinada.

El estatuto condicional (If) ejecutará instrucciones dependiendo del valor de una condición que deriva en una expresión lógica (dato de tipo Boolean).

Como If tiene muchas variantes, examinaremos varias sintaxis que le aplican.

He aquí la más sencilla:

If ExpresiónLógica Then Instrucción

Donde If es el inicio de la estructura de decisión, ExpresiónLógica es la expresión de tipo Boolean que determina la ejecución de Instrucción, que en este caso sólo puede constar de una sola instrucción.


Ejemplo. If Precio < CreditoDisponible Then Cargo = “Aprobado”

Sólo en caso de que ExpresiónLógica derive en un valor de True, Instrucción será ejecutada; esta sintaxis de If controla sólo la ejecución en el sentido afirmativo de la condición.

Esta forma de If es muy útil para asignar valores a las variables, en caso de que una condición se cumpla.

Un bloque de código es un conjunto de líneas de código que tienen su propio alcance de ejecución, y que están siempre delimitadas. Si la ejecución de un bloque de código depende del cumplimiento de una condición, es necesario que se delimite la estructura de decisión; el bloque de código será entonces todo lo que se encuentre entre el estatuto If y el estatuto End If.

If ExpresiónLógica Then Instrucciones

End If

Donde If es el inicio de la estructura de decisión, End If es el fin de la estructura de decisión, y todas las Instrucciones que se encuentran en el inicio y el fin, constituyen el bloque de código que es controlado por la condicional. ExpresiónLógica es la expresión de tipo Boolean que determina la ejecución de Instrucciones, que en este caso puede constar de una sola instrucción o de muchas.

Sólo en caso de que ExpresiónLógica derive en un valor de True, Instrucciones será ejecutada; esta sintaxis de If controla sólo la ejecución en el sentido afirmativo de la condición.


Ejemplo. If Precio < CreditoDisponible Then Cargo = “Aprobado” CreditoDisponible -= Precio End If

If es un estatuto de bloque, por lo que si inicia un bloque tendrá que concluirlo. Un error muy común es que se abren estructuras de decisión, pero no se cierran; es de mucha utilidad darle organización al código, proporcionando diferente alineación tabulada a las líneas inicio y fin de la estructura de decisión, y al bloque de código controlado por dicha estructura. Vea nuestros ejemplos: If y End If nunca se encuentran con el mismo margen izquierdo que el bloque de código que controlan; no trate de ser original al respecto, pues con ello sólo logrará que la gente se de cuenta que es un programador novato y poco organizado.

Es posible que If controle al mismo tiempo la ejecución en el sentido afirmativo y en el sentido negativo, a través de la especificación Else. Vea la sintaxis.

If ExpresiónLógica Then InstruccionesAfirmativo Else

InstruccionesNegativo End If

Donde If es el inicio de la estructura de decisión, End If es el fin de la estructura de decisión, y todas las Instrucciones que se encuentran entre el inicio y el fin, constituyen el bloque de código controlado por la condicional, pero está dividido en dos bloques de código diferentes, uno que se ejecutará sólo si ExpresiónLógica es True (InstruccionesAfirmativo), y otro que sólo se ejecutará si ExpresiónLógica es False (InstruccionesNegativo).


Ejemplo. If Precio < CreditoDisponible Then Cargo = “Aprobado” CreditoDisponible -= Precio Else Cargo = “Denegado” End If

ExpresiónLógica es la expresión de tipo Boolean que determina ejecución de InstruccionesAfirmativo o InstruccionesNegativo.

Esta sintaxis de If controla la ejecución en el sentido afirmativo de la condición, o en el sentido negativo; como podrá intuir, siempre se ejecutará algo.


Select Case

Select Case es una estructura de decisión que permite ejecutar procesos mutuamente excluyentes, en función a comparaciones realizadas sobre un mismo valor de referencia.

Su sintaxis se encuentra a continuación:

Select Case ExpresiónAEvaluar Case {Condición | Else} Instrucciones End Select

Donde ExpresiónAEvaluar es una expresión de cualquier tipo, que será tomada como referencia. Condición sirve para especificar una condición relacionada con ExpresiónAEvaluar, que en caso de presentarse, motiva la ejecución de Instrucciones.

Se va construyendo un árbol de decisión basado en una ExpresiónAEvaluar. Se pueden agregar tantas sentencias Case como se deseen, e incluso las estructuras Select Case se pueden anidar.

Si al momento de evaluar Condición, un determinado valor de ExpresiónAEvaluar cumple en dos casos, se ejecutará para la


primera que se encuentre. Case Else aplica cuando el valor de ExpresiónAEvaluar no cumpla para ninguno de los casos anteriores, dentro de la estructura.

Para ver cómo funciona este estatuto, imagínese la siguiente situación hipotética: Una compañía tiene 35 categorías de empleados; cada categoría tiene un ingreso determinado, en donde las categorías de número más alto son las de mayor ingreso por salario, existiendo una relación directamente proporcional entre categoría y sueldo.

Se acaba de autorizar un aumento de sueldo general en la compañía, bajo las siguientes políticas: el personal de alto nivel (categoría superior a 19) no tendrá aumento; las categorías 18, 17 y 14 recibirán el 15% de aumento; de la categoría 8 a la 13, recibirán el 10% de aumento, a excepción de la categoría 10, que es la categoría más rezagada con respecto al salario, pues recibirá el 25%. Al resto del personal, se le dará un 5% de aumento.

¿Cómo se codificaría una estructura Select Case que atendiera esta necesidad? Veamos.

Select Case Categoria Case Is > 19 Aumento = 0 Case 18, 17, 14 Aumento = 0.15 Case 10 Aumento = 0.25 Case 8 To 13 Aumento = 0.1 Case Else Aumento = 0.5 End Select

Vea cómo se especificaron las condiciones y aplique la sintaxis en aquellos casos que lo requiera.

Es importante que se de cuenta que todas las condiciones giran con relación a la ExpresiónAEvaluar (en nuestro ejemplo, Categoria), ya que si no hace uso de dicha expresión, no son consideradas. Usted puede agregar como instrucción la línea con una condición Case que se resuelva True, pero que no involucre a Categoria; en ese caso, el código dependiente de dicho Case nunca se ejecutará.


For Next

Son estructuras de control, llamadas también bucles, aquellos elementos del lenguaje que permiten la ejecución de una o más líneas de código de manera repetida.

Mediante las estructuras de control se puede repetir la ejecución de líneas de código.

Un determinado número de veces

Hasta que una condición sea verdadera (True)

Mientras que una condición es falsa (False)

Una vez por cada elemento de una colección

Se analizarán los elementos del lenguaje que nos permiten codificar cada una de estas variantes.

For Next repite la ejecución de un bloque de código un número determinado y conocido de veces. For Next se apoya en una variable que recibe el nombre de contador, que se incrementa o reduce de valor, en intervalos también regulares y conocidos.

Su sintaxis es la siguiente.


For Variable = ValorInicial To ValorMáximo [Step Incremento] Instrucciones Next [Variable]

Donde Variable es una variable de memoria de tipo entero, que permitirá controlar las repeticiones del proceso. ValorInicial es el valor inicial a partir del cual el incremento o decremento se llevará a cabo. ValorMáximo es el valor al cual el contador podrá llegar. Incremento es la constante entera que marcará la cantidad de incremento o decremento que sufrirá Variable en cada repetición del proceso.

Ejemplos.

' Cuenta del 1 al 10 For i = 1 To 10 Console.WriteLine(i) Next i ' Serie del 5 For i = 0 To 50 Step 5 Console.WriteLine(i) Next i ' Decremento del 10 al 1 For i = 10 To 1 Step –1 Console.WriteLine(i) Next i

Si se omite la especificación Step, se asume Incremento con valor de 1 positivo. Si Incremento es negativo, hablamos de un decremento, en términos reales.

Una instrucción que puede ser útil en el caso de utilizar For Next es Exit For, que interrumpe la ejecución del For como si ya hubiese cumplido todas las repeticiones exigidas.


While

While ejecuta un bloque de código un tiempo infinito de veces, mientras una condición al inicio del bloque se cumpla por verdadero (True).

La sintaxis es la siguiente.

While ExpresiónLógica Instrucciones End While

Ejemplo. Dim Prueba As Byte = 0 While Prueba < 255 Console.WriteLine(Prueba) Prueba += 1 End While

Donde ExpresiónLógica es un valor de tipo Boolean (True/False), casi siempre una comparación, que de ser verdadera al inicio del ciclo de ejecución, provoca la ejecución de Instrucciones.

Como recordará, los tipos de datos Byte sólo pueden almacenar valores desde 0 a 255; en nuestro ejemplo, While ejecutará un


incremento de 1 para la variable Prueba, mientras sea menor a 255. Si dejáramos que el ciclo fuera más allá de 255, el programa generaría error, pues es imposible que una variable de tipo Byte asuma un valor fuera de su rango.

Al igual que For Next, While tiene una sentencia para interrumpir en cualquier momento el proceso: Exit While.

Una de las formas más útiles de While es el ciclo infinito, en donde ninguna operación o variable dentro del proceso influye en la condición que gobierna la estructura. Simple y llanamente, se proporciona el valor de True como ExpresiónLógica, y no hay forma que deje de ejecutarse el ciclo.

While True Instrucciones End While

Ejemplo.

While True Console.WriteLine("Qué número estoy pensando") If Console.ReadLine() = 8 Then Console.WriteLine("Efectivamente: 8") Exit While End If End While

En este caso, es indispensable que provea a su programa de algún momento en el proceso para ejecutar Exit While, ya que de otra manera, nunca concluirá la ejecución del programa.

En el ejemplo que pusimos, mientras no teclee un 8, el programa seguirá pidiendo números.

NNOOTTAA

Puede ser que su programa tenga un detalle que impida ejecutar Exit

While en un ciclo infinito; recuerde que siempre puede detener la

ejecución de un proceso presionando la combinación de teclas CTRL-

INTER o ESC.


Do Loop

Do Loop ejecuta un bloque de código un tiempo infinito de veces, hasta que una condición se cumpla por verdadero (True). Esta instrucción brinda más flexibilidad que While, en el sentido que se puede controlar la evaluación de las condiciones al inicio o al final de la estructura. Usando Do Loop se pueden hacer estructuras que se ejecutan al menos una vez, de una forma más sencilla que utilizando While.

La sintaxis es la siguiente.

„ Evaluación al inicio Do {While/Until} ExpresiónLógica Instrucciones Loop „ Evaluación al final Do Instrucciones Loop {While/Until} ExpresiónLógica

Donde ExpresiónLógica es un valor de tipo Boolean (True/False), casi siempre una comparación. Instrucciones son las instrucciones que se están gobernando en el bucle.


Si se utiliza Do con While (mientras), el ciclo se repite hasta que ExpresiónLógica sea falsa.

Si se utiliza Do con Until (hasta), el ciclo se repite hasta que la condición sea verdadera. Sólo se puede implementar While o Until, pero no ambas. También tiene que decidir si la evaluación de las condiciones es al inicio o al final de la estructura, pero no ambas.

Ejemplos. i = 0 Do While i <= LimiteMaximo WriteLine(i) i += 1 Loop i = 0 Do Until i > LimiteMaximo WriteLine(i) i += 1 Loop i = 0 Do WriteLine(i) i += 1 Loop While i <= LimiteMaximo i = 0 Do WriteLine(i) i += 1 Loop Until i > LimiteMaximo

Do tiene una sentencia para interrumpir en cualquier momento el proceso: Exit Do.


Reglas para el anidado de estructuras

Las estructuras, sean de decisión o de control, pueden contener a otras estructuras. A una estructura que contiene a otras estructuras se le llama estructura envolvente; la estructura que está dentro de otra se llama estructura anidada. Todas las estructuras que se han visto en el módulo, sin importar su tipo, pueden anidarse o ser envolventes, es decir, resolverse una dentro de otra.

Las únicas reglas que debe tomar en cuenta son:

Las estructuras tienen un inicio y un fin; asegúrese de cerrar todas las estructuras que abra.

Se recomienda programar de tal manera que las estructuras que se abran se cierren lo más pronto posible.

La última estructura en abrirse debe ser la primera en cerrarse.

En el caso de estructuras, las variables de tipo entero se resuelven de manera más rápida que cualquier otro tipo de dato.


Los problemas más comunes relacionados con las estructuras anidadas (y su solución) son:

No terminar lo que se inicia.

Problema Solución If Condición Then Instrucciones

If Condición Then Instrucciones End If

No iniciar lo que se termina.

Problema Solución Instrucciones Next Variable

For Variable = 0 to 10 Instrucciones Next Variable

Utilizar las mismas variables que controlan el proceso.

Problema Solución For Variable = 0 to 10 For Variable = 0 to 5 Instrucciones Next Variable Next Variable

For Variable = 0 to 10 For Variable_1 = 0 to 5 Instrucciones Next Variable_1 Next Variable

No terminar primero la última estructura que se inició.

Problema Solución For Variable = 0 to 10 If Condición Then Instrucciones Next Variable End If

For Variable = 0 to 10 If Condición Then Instrucciones End If Next Variable


Ejercicios


1. Lab.07: Uso de estructuras de decisión 2. Lab.08: Uso de For Next 3. Lab.09: Identificando errores en estructuras anidadas


Lab.07: Uso de estructuras de decisión

En este ejercicio se utilizará una aplicación de consola para comprobar las estructuras de decisión. Se parte del supuesto que usted le indique al programa cuánto cuesta un producto que desea comprar, así como el tipo de membrecía que tiene en la tienda donde lo desea comprar. A cada tipo de membrecía le aplica un determinado descuento, que será informado por el programa.


2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique Descuento. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.


Codificación de Descuento - Module1.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

Option Explicit On Option Strict On Imports System.Console Module Module1 Sub Main() Dim Precio As Double Dim FactorDesc As Decimal Write ("Precio del producto:") Precio = CDbl(ReadLine()) If Precio = 0 Then WriteLine("Nada que calcular") Else WriteLine("Membresía:") WriteLine("1.- Diamante") WriteLine("2.- Premium") WriteLine("3.- Clásica") Write("¿Qué membresía tiene?:") FactorDesc = CDec(ReadLine()) Select Case FactorDesc Case Is = 1 FactorDesc = 0.2D Case Is = 2 FactorDesc = 0.16D Case Is = 3 FactorDesc = 0.1D Case Else FactorDesc = 0 End Select Write("Precio para usted:") WriteLine(Precio - (Precio * FactorDesc)) End If


38 39 40 41 42 43 44

Write("Presione INTRO para continuar") ReadLine() End Sub End Module

Ejecución guiada de Descuento – Module1.vb


5. Las líneas 1 y 2 hacen de este programa un programa type safe. En las líneas 10 y 11 se declaran las variables de trabajo.

6. Cuando el programa solicite el precio (líneas 13 y 14), proporcione el valor 0. Vea en el código cómo se utiliza CDbl(), para hacer de lo capturado un dato Double, y evitar errores, dado que el programa es type safe y no permite conversiones tipo cast (línea 14).

En la línea 16 vemos la primera estructura de decisión del programa, que controla la ejecución del programa en el sentido afirmativo y en el sentido negativo.

En el sentido afirmativo, se ejecutará el bloque de código que va de la línea posterior al inicio de la estructura (línea 9), hasta la línea anterior al Else o End If (línea 17), que dan por concluido el bloque.

En el sentido negativo, se ejecutará el bloque de código que va de la línea posterior al Else (línea 19), hasta la línea anterior al End If (línea36), que da por concluido el bloque.

Como se proporcionó el valor de cero, la condición que gobierna la ejecución del If se cumple en el sentido afirmativo (Precio = 0 es True), y al encontrar el Else, pasa a ejecutar la línea 30; vea que el bloque en el sentido negativo es ignorado completamente.

Si todo ocurrió como se esperaba, la salida será la siguiente.

Precio del producto: 00 Nada que calcular Presione INTRO para continuar

7. Ejecute la aplicación nuevamente. Cuando le solicite el precio, proporcione el valor 2000. Cuando le solicite el tipo de membresía, proporcione el valor 2.


Como se proporcionó el valor 2000, la condición que gobierna la ejecución del If se cumple en el sentido negativo (Precio = 0 es False), y se procede a ejecutar el bloque en el sentido negativo.

En la línea 24 se recibe el valor 2, que es asignado a FactorDesc; en la línea 25 se especifica FactorDesc como valor de referencia para las comparaciones de Select Case, que se encuentran en las líneas 26, 28 y 30, y en caso de que no se cumpla ninguna de las anteriores, se ejecuta la línea 32.

Como el valor de FactorDesc es 2 (Is = 2), se procede a ejecutar el bloque de código correspondiente al cumplimiento de esa condición; en otras palabras, ejecuta la línea 29; vea cómo se agrega la literal D al valor, para indicarle al programa que el valor es Decimal, ya que de lo contrario podría asumirse otro tipo de dato, y ante la imposibilidad de conversiones cast se generaría un error. Podríamos haber resuelto también el problema utilizando la función CDec(). Concluida la ejecución del bloque de código correspondiente a la condición que se cumplió, se envía el control del programa a la línea posterior a la terminación de la estructura (End Select), es decir, ejecuta la línea 35 y hacia adelante, que despliegan el precio después de aplicar el factor de descuento que corresponde al tipo de membresía que seleccionamos.

Si todo ocurrió como se esperaba, la salida será la siguiente.

Precio del producto: 22000000 Membresía: 1.- Diamante 2.- Premium 3.- Clásica ¿Qué membresía tiene?: 22 Precio para usted: 1680 Presione INTRO para continuar

Si hubiéramos especificado un tipo de membresía que no fuera 1, 2, o 3, el programa hubiera ejecutado la línea 32, que corresponde a la condición Case Else, es decir, cuando ninguna de las otras condiciones se cumplió.

8. Guarde todos los cambios en su solución.

FIN DEL EJERCICIO


Lab.08: Uso de For Next

En este ejercicio se utilizará una aplicación de consola para comprobar el funcionamiento de For Next.


2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique Repite. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.


Codificación de Repite - Module1.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

Option Explicit On Option Strict On Imports System.Console Module Module1 Sub Main() Dim LimiteMaximo As Integer = 4 Dim LimiteMinimo As Integer = 0 Dim i As Integer WriteLine("Mostrando con For Next incremental") For i = LimiteMinimo To LimiteMaximo WriteLine(i) Next i WriteLine("Muestra usando For Next invertido") For i = LimiteMaximo To LimiteMinimo Step -1 WriteLine(i) Next i WriteLine("Mostrando con While") i = 0 While i <= LimiteMaximo WriteLine(i) i += 1 End While WriteLine("Muestra usando Do Loop inicial While") i = 0 Do While i <= LimiteMaximo WriteLine(i) i += 1 Loop WriteLine("Muestra usando Do Loop inicial Until") i = 0 Do Until i > LimiteMaximo WriteLine(i) i += 1 Loop


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

WriteLine("Muestra usando Do Loop final While") i = 0 Do WriteLine(i) i += 1 Loop While i <= LimiteMaximo WriteLine("Muestra usando Do Loop final Until") i = 0 Do WriteLine(i) i += 1 Loop Until i > LimiteMaximo Write("Presione INTRO para continuar") ReadLine() End Sub End Module

Ejecución guiada de Repite – Module1.vb


5. En las líneas 10 a la 12 se declaran variables de trabajo que nos ayudarán a visualizar de una mejor forma el funcionamiento de los bucles. Todas las estructuras hacen lo mismo, con las siguientes particularidades:

a. For Next se encarga de incrementar un contador de forma automática.

b. Todas las demás estructuras deben apoyarse en un contador implementado manualmente (i +=1), que en caso de olvidarse puede provocar un ciclo infinito.

c. Las estructuras Until se ejecutan hasta que se cumple por primera vez la condición.

d. Las estructuras While se ejecutan mientras la condición sigue siendo verdadera.


Si todo transcurrió bien, la pantalla mostrará lo siguiente:

Mostrando con For Next incremental 0 1 2 3 4 Muestra usando For Next invertido 4 3 2 1 0 Mostrando con While 0 1 2 3 4 Muestra usando Do Loop inicial While 0 1 2 3 4 Muestra usando Do Loop inicial Until 0 1 2 3 4 Muestra usando Do Loop final While 0 1 2 3 4 Muestra usando Do Loop final Until 0 1 2 3 4 Presione INTRO para continuar

6. Modifique las asignaciones de las líneas 25, 32, 39, 46 y 53. En lugar de asignar 0, asigne 10. Se proporciona ese valor porque no es válido para las condicionales While y Until del programa. Compruebe cómo las estructuras con evaluación al final se ejecutan al menos una vez.

Si todo transcurrió bien, la pantalla mostrará lo siguiente:

Mostrando con For Next incremental 0 1 2 3 4 Muestra usando For Next invertido 4 3 2 1 0 Mostrando con While Muestra usando Do Loop inicial While Muestra usando Do Loop inicial Until Muestra usando Do Loop final While 10 Muestra usando Do Loop final Until 10 Presione INTRO para continuar

FIN DEL EJERCICIO


Lab.09: Identificando errores en estructuras

anidadas

En este ejercicio analizará el código que se proporciona, y explicará cuáles son los errores que se presentan (si los hay). Si no hay problemas, indíquelo en su respuesta.

1)

If Edad > 18 Then If Registro = True Then Autorizacion = True End If

2)

If Edad > 18 Then If Registro = True Then Autorizacion = True End If


3)

For i = 1 to 10 x *= i If x > 30 Then Console.WriteLine(“Límite de treinta o más”) Exit For Next i End If

FIN DEL EJERCICIO


Procedimientos

Los procedimientos son bloques de código nominados que pueden ser mandados llamar a ejecución.

Cuando se tiene una tarea grande de programación se puede decidir utilizar procedimientos para dividirla en otras tareas más pequeñas; la realización de todas las pequeñas tareas particulares implican la ejecución de la tarea general que conforman.

Los procedimientos tienen como objetivo principal crear bloques de código que realizan una labor independiente, a fin de que puedan ser reutilizados. Por sí mismos, los procedimientos no constituyen un programa formal, sino que operan a manera de soporte con respecto a un programa que los manda ejecutar.

Forma de agregar procedimientos a un programa

La forma de agregar un procedimiento a un programa, es incluir un bloque de código delimitado por la orden Sub y End Sub; la sintaxis es la siguiente:

Sub NombreProcedimiento( ) Instrucciones

End Sub


Donde NombreProcedimiento es el nombre que identifica al procedimiento; Instrucciones es el bloque de código que será llamado a ejecución a través de NombreProcedimiento. Es posible que se anteponga al Sub la accesibilidad, como Public, Friend, etcétera (para mayor información, vea el módulo 8), que determinarán la capacidad que tendrá el procedimiento para ser reutilizado.

Sub y End Sub son las líneas que delimitan el bloque de código del procedimiento. La línea Sub es la llamada línea de encabezado del

procedimiento, porque en ella se declara el nombre del procedimiento, los valores que utilizará para trabajar, así como los valores que retornará, en su caso.

Es importante mencionar que los procedimientos y las funciones no pueden anidarse, es decir, que no se puede definir un procedimiento dentro de otro procedimiento; si se desea esa funcionalidad, puede mandarse llamar a ejecución un procedimiento o función desde otro procedimiento o función, sin problemas.

NNOOTTAA

Es importante hacer notar que para que el procedimiento sea reconocido

por el compilador, éste debe estar declarado dentro de un elemento

contenedor, como por ejemplo Module o Class.

Forma de mandar llamar a ejecución un procedimiento

La forma de mandar llamar a ejecutar un procedimiento es muy sencilla, pues sólo se coloca el nombre del procedimiento, seguido de paréntesis. Vea la sintaxis:

NombreProcedimiento()

Donde NombreProcedimiento es el nombre del procedimiento que será llamado a ejecutar.

EVOLUCIÓN Anteriormente los procedimientos se mandaban llamar a

ejecución a través de la orden Call, y el uso de paréntesis era

opcional. Eso ya no es posible en .NET; Call ya no existe, y es

necesario colocar los paréntesis después del nombre del

procedimiento, en todos los casos.


Argumentos

Los argumentos, también llamados parámetros, son aquellas expresiones o referencias a objetos que se le proporcionan a un procedimiento para que realice su tarea con base en ellos. Los argumentos siempre se declaran dentro de los paréntesis en la línea de encabezado del procedimiento.

Se conocen como argumentos implícitos aquellos que son declarados por Visual Basic.NET de manera automática; en la declaración de este tipo de argumentos el programador no participa más que como espectador y usuario.


Valores de retorno

Los valores de retorno son aquellos valores que un procedimiento puede proporcionar como resultado de su ejecución.

Aquellos procedimientos que retornan valores son conocidos como funciones.

En el momento en que un procedimiento se codifica, se le especifican tanto los argumentos que aceptará, como los valores de retorno que tendrá.


Codificación de procedimientos

A continuación veremos cómo se codifican los procedimientos y funciones.

Si el procedimiento no declara argumentos ni retorna valores, la cosa es muy sencilla:

Sub NombreProcedimiento() Instrucciones End Sub

Ejemplo:

SSuubb DDeesspplliieeggaa(()) Console.WriteLine(“Prueba de procedimientos”) EEnndd SSuubb

Ejemplo de ejecución:

Despliega()


Si el procedimiento utiliza argumentos, estos deberán declararse entre los paréntesis que aparecen después del nombre del procedimiento; pueden declararse tantos argumentos como se deseen, separándose por comas. Cada uno de ellos deberá especificar si se trata de una expresión (ByVal) o una referencia (ByRef) a un objeto, seguido por el nombre del argumento, y la correspondiente declaración de tipo:

Sub NombreProcedimiento(Argumento1 [, Argumento2, ...]) Instrucciones que pueden utilizar los Argumentos End Sub

Donde cada Argumento es una declaración con la siguiente sintaxis:

[ByVal | ByRef] NombreArgumento As [Tipo]

Ejemplo:

SSuubb DDeesspplliieeggaa((BByyVVaall MMeennssaajjee AAss SSttrriinngg)) Console.WriteLine(Mensaje) EEnndd SSuubb


Despliega(“Programa de prueba de procedimientos”)


Si el procedimiento retorna valores, se trata de una función; a diferencia de los procedimientos, en lugar de Sub, debe utilizarse la palabra reservada Function. Para retornar el valor de una función, se utiliza la orden Return, seguida del valor que se desea retornar.

Function NombreFuncion() As Tipo Instrucciones que producen el valor a retornar

Return ValorTipo End Function

Ejemplo:

FFuunnccttiioonn DDiiaaDDeeHHooyy(()) AAss SSttrriinngg Return “Hoy es “ & Now.ToString() EEnndd FFuunnccttiioonn


Console.WriteLine(DiaDeHoy())


El máximo grado de complejidad para un procedimiento es la función que acepta argumentos y retorna valores.

Function NombreFuncion(Argumento1 [, Argumento2, ...]) As Tipo

Instrucciones que producen el valor a retornar,

y pueden utilizar los argumentos

Return ValorTipo End Function

Ejemplo:

FFuunnccttiioonn DDiiaa((BByyVVaall FFeecchhaaDDaaddaa AAss DDaattee)) AAss SSttrriinngg Return “La fecha proporcionada es “ & _ FechaDada.ToString() EEnndd FFuunnccttiioonn


Console.WriteLine(Dia(Now))

Los argumentos de una función determinada no necesariamente deben proporcionarse en el orden en que son declarados al momento de su codificación; si se desea pasar los argumentos en un orden distinto al que tienen por definición, es necesario utilizar los nombres específicos dados a los argumentos.

Vea el siguiente ejemplo, que muestra cómo nominar los argumentos al momento de utilizar la función:


Console.WriteLine(Dia(FechaDada:=Now))

NNOOTTAA

Es importante saber que los procedimientos y funciones no se pueden

anidar; dentro de un procedimiento o función no se puede declarar otro

procedimiento o función.


Argumentos opcionales y valores por

omisión

Es posible que los argumentos no sean obligatorios en todos los casos, y también es posible que queramos que, en caso de omitir el valor de un argumento, éste asuma un valor por omisión.

Para manejar esas situaciones, se hace el uso de Optional, así como de la asignación al momento de declarar los argumentos.

Suponga que tiene una función, llamada CalcVenta(), que admite dos argumentos PrecioUnitario y Cantidad, y que a partir de ahí calcula el monto total de una venta (PrecioUnitario * Cantidad).


Si nuestra función estuviera definida de la siguiente forma, sería necesario proporcionar los dos argumentos siempre, o de lo contrario generaríamos una excepción:

FFuunnccttiioonn CCaallccVVeennttaa((BByyVVaall PPrreecciiooUUnniittaarriioo AAss IInntteeggeerr,, __ BByyVVaall CCaannttiiddaadd AAss IInntteeggeerr)) AAss DDoouubbllee Return PrecioUnitario * Cantidad EEnndd FFuunnccttiioonn

Si sabemos que cuando no se especifica la cantidad, quiere decir que es 1, podríamos hacer lo siguiente:

FFuunnccttiioonn CCaallccVVeennttaa((BByyVVaall PPrreecciiooUUnniittaarriioo AAss IInntteeggeerr,, __ OOppttiioonnaall BByyVVaall CCaannttiiddaadd AAss IInntteeggeerr == 11)) AAss DDoouubbllee Return PrecioUnitario * Cantidad EEnndd FFuunnccttiioonn

Podríamos ejecutar la función de la siguiente forma:

Console.WriteLine(Precio(10))

El segundo argumento, aunque se omitió, se asumiría con valor de 1, y la operación no generaría excepción.

¿Qué pasaría si los dos argumentos fueran opcionales, y deseamos omitir el primero y dar valor al segundo?

Console.WriteLine(Precio(10))

Con la línea anterior, Visual Basic.NET entendería que el argumento que se está proporcionando es el primero, y no el segundo; para especificar que el valor que proporcionamos corresponde al segundo argumento, podemos hacer uso de los separadores de argumentos (comas):

Console.WriteLine( Precio ( , 10) )

O bien, proporcionar los argumentos utilizando su nombre:

Console.WriteLine( Precio ( CANT:=10 ) )


Ejercicios


1. Lab.10: Procedimiento que no utiliza argumentos 2. Lab.11: Procedimiento que declara argumentos pero no retorna valores 3. Lab.12: Procedimiento que declara argumentos y retorna valores


Lab.10: Procedimiento que no utiliza

argumentos

En este ejercicio demostrará la forma en que se declaran los procedimientos que no requieren argumentos, y la forma en que se mandan llamar a ejecución.

Para éste y otros ejemplos del módulo, proponemos el siguiente ejemplo hipotético:

Una tienda con venta a crédito tiene una promoción, en donde usted compra hoy y la tienda no le comienza a cobrar sino transcurridos 90 días. Su programa debe calcular la fecha en que el cliente debe pagar, contando 90 días a partir de la fecha actual.

Como la tienda cierra los domingos, si la fecha de pago (hoy + 90 días) es domingo, deberá ampliarse el plazo en un día, con el fin del que el pago pueda ser realizado el día lunes.

Tome en cuenta que: con Visual Basic.NET siempre podremos saber qué día es hoy, utilizando Now; podremos incrementar los días utilizando la función DateAdd, y validar el día de que se trata con la función DatePart.


2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique SinArgumentos. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.

Codificación de SinArgumentos.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Imports System Imports Microsoft.VisualBasic MMoodduullee SSiinnAArrgguummeennttooss Dim FechaPago As Date SSuubb MMaaiinn(()) Console.WriteLine("Hoy:" & Now.ToShortDateString) DeterminaFechaPago() Console.WriteLine("Fecha de pago:" & _ FechaPago.ToShortDateString) EsperaIntro() EEnndd SSuubb SSuubb DDeetteerrmmiinnaaFFeecchhaaPPaaggoo(()) FechaPago = DateAdd(DateInterval.Day, 90, Now) If DatePart(DateInterval.Weekday, FechaPago) = 1 Then FechaPago = DateAdd(DateInterval.Day, 1, FechaPago) End If EEnndd SSuubb SSuubb EEssppeerraaIInnttrroo(()) Console.WriteLine("Pulse INTRO para continuar") Console.ReadLine() EEnndd SSuubb EEnndd MMoodduullee


Ejecución guiada de SinArgumentos.vb

3. Ejecute el programa presionando F5.

La línea 9 se encarga de desplegar la fecha del sistema.

Para que el programa trabaje como debe ser, es necesario que almacene en algún lado la fecha calculada; para ello, se declara una variable llamada FechaPago en la línea 6. El alcance con el que está declarada la variable (disponible en todo el módulo) será suficiente para que su valor pueda ser utilizado dentro y fuera de nuestro procedimiento.

La línea 10 manda llamar a ejecución el procedimiento DeterminaFechaPago(), que calculará la fecha en que el cliente comenzará a pagar. La ejecución del programa se traslada automáticamente hasta encontrar una línea de encabezado de procedimiento que declare a un bloque de código bajo el nombre de “FechaPago” (línea 15), y por tanto se procede a ejecutar el bloque de código compuesto por las líneas 16 a la 19, es decir, una después del Sub, y una antes del End Sub.

La línea 16 asigna a la variable FechaPago el resultado de sumarle a la fecha del sistema la cantidad de 90 días; las líneas 17, 18, y 19 se encargan de validar que si el día calculado es domingo (internamente, el día de la semana número 1), se agregará un día más, a fin de que el día de pago sea un día hábil (lunes).

El programa se encuentra el fin del procedimiento, y por tal motivo regresa el control de la ejecución del programa a la línea siguiente a aquella que mando llamar a ejecución el procedimiento (línea 11). La línea 11 se encarga de desplegar, en formato de fecha corta, el valor que haya sido calculado, y que se encuentra en FechaPago.

La línea 13 se encarga de llamar a ejecución un procedimiento llamado EsperaIntro(), que se encarga de mostrar el mensaje que ya hemos utilizado en otros ejercicios «Pulse INTRO para continuar», y esperar a que el usuario haga precisamente eso.

Los procedimientos sin argumentos, como el de este ejemplo, tienen un rasgo característico: toda la comunicación de valores con el resto del programa, sean datos de entrada o de salida, son manejados a través de variables de memoria con alcance suficiente como para estar disponibles dentro de los procedimientos en cuestión.

Como no declaran argumentos ni valores de retorno son simples. Su aparente simplicidad es una limitación, ya que todos los programas que deseen hacer uso del procedimiento deberán declarar las variables que el procedimiento utiliza, con el mismo tipo y el mismo nombre que con el que fueron declaradas originalmente.

Para poder reutilizar este procedimiento, el programa que lo pretenda mandar llamar a ejecución deberá declarar necesariamente una variable que se llame FechaPago, de tipo Date.


Si todo ocurrió como se esperaba, la salida será la siguiente (la fecha del sistema es el 1 de enero del 2003, por decir alguna):

Hoy:01/01/2003 Fecha de pago:01/04/2003 Pulse INTRO para continuar

FIN DEL EJERCICIO


Lab.11: Procedimiento que declara

argumentos pero no retorna valores

En este ejercicio se demostrará la forma en que se declaran los procedimientos que requieren argumentos, y la forma en que se mandan llamar a ejecución.

Utilizaremos el mismo caso hipotético del ejercicio anterior, con una pequeña variante: el cómputo de los 90 días no es a partir de la fecha de hoy, sino de una fecha cualquiera, que nosotros le proporcionaremos al programa.


2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique ConArgumentos. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.

Codificación de ConArgumentos.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Imports System Imports Microsoft.VisualBasic MMoodduullee CCoonnAArrgguummeennttooss Dim FechaPago As Date SSuubb MMaaiinn(()) Console.WriteLine("Hoy:" & Now.ToShortDateString) DeterminaFechaPago(Now) Console.WriteLine("Fecha de pago:" & _ FechaPago.ToShortDateString) EsperaIntro() EEnndd SSuubb SSuubb DDeetteerrmmiinnaaFFeecchhaaPPaaggoo((BByyVVaall FFeecchhaaBBaassee AAss DDaattee)) FechaPago = DateAdd(DateInterval.Day, 90, FechaBase) If DatePart(DateInterval.Weekday, FechaPago) = 1 Then FechaPago = DateAdd(DateInterval.Day, 1, FechaBase) End If EEnndd SSuubb SSuubb EEssppeerraaIInnttrroo(()) Console.WriteLine("Pulse INTRO para continuar") Console.ReadLine() EEnndd SSuubb EEnndd MMoodduullee

Ejecución guiada de ConArgumentos.vb



Para que el programa trabaje como debe ser, es necesario que almacene en algún lado la fecha calculada; para ello, se declara una variable llamada FechaPago en la línea 6. El alcance con el que está declarada la variable (disponible en todo el módulo) será suficiente


para que su valor pueda ser utilizado dentro y fuera de nuestro procedimiento.

La línea 10 manda llamar a ejecución el procedimiento DeterminaFechaPago(), proporcionando como argumento el valor de la fecha del sistema (Now); pudo haber sido cualquier fecha, y el programa calcularía la fecha de pago a partir de la misma. La ejecución del programa se traslada automáticamente hasta encontrar una línea de encabezado de procedimiento que declare a un bloque de código bajo el nombre de «FechaPago» (línea 15). En la declaración del procedimiento, se especifica que dicho procedimiento espera que el programa que lo manda llamar a ejecución le proporcione un valor (ByVal) de tipo fecha (Date).

Se procede a ejecutar el bloque de código compuesto por las líneas 16 a la 19, es decir, una después del Sub, y una antes del End Sub.

La línea 16 asigna a la variable FechaPago el resultado de sumarle a la fecha que proporcionamos al procedimiento la cantidad de 90 días; las líneas 17, 18, y 19 se encargan de validar que si el día calculado es domingo (internamente, el día de la semana número 1), se agregará un día más, a fin de que el día de pago sea un día hábil (lunes).

El programa se encuentra el fin del procedimiento, y por tal motivo regresa el control de la ejecución del programa a la línea siguiente a aquella que mando llamar a ejecución el procedimiento (línea 11). La línea 11 se encarga de desplegar, en formato de fecha corta, el valor que haya sido calculado, y que se encuentra en FechaPago.


Este programa sigue teniendo muchas de las deficiencias propias del procedimiento que no utiliza argumentos y no retorna valores. Sólo le encontramos una ventaja: el procedimiento puede trabajar con cualquier fecha que se le proporcione, y no necesariamente con una que previamente se haya asignado a la variable FechaPago; eso le da un poco de independencia al procedimiento. La limitante se sigue dando en los datos de salida, pero ya no en los de entrada.



FIN DEL EJERCICIO


Lab.12: Procedimiento que declara

argumentos y retorna valores

En este ejercicio se demostrará la forma en que se declaran los procedimientos que requieren argumentos y retornan valores, y la forma en que se mandan llamar a ejecución.

Utilizaremos el mismo caso hipotético del ejercicio anterior, con una pequeña variante: se prohíbe utilizar la variable FechaPago, que veníamos utilizando como apoyo para la salida del procedimiento.


2. Agregue un proyecto (CTRL-SHIFT-N), especificando como Project Type el Visual Basic – Windows, y como Template seleccione Console Application. En Name especifique ConArgumentosFun. Sea cuidadoso de seleccionar en Solution la opción Add to Solution, a efecto de que se agregue a la solución llamada Ejercicios.

Codificación de ConArgumentosFun.vb

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Imports System Imports Microsoft.VisualBasic MMoodduullee CCoonnAArrgguummeennttoossFFuunn SSuubb MMaaiinn(()) Console.WriteLine("Hoy:" & Now.ToShortDateString) Console.WriteLine("Fecha de pago:" & DeterminaFechaPago(Now)) EsperaIntro() End Sub Function DeterminaFechaPago(ByVal FechaBase As Date) As String FechaBase = DateAdd(DateInterval.Day, 90, FechaBase) If DatePart(DateInterval.Weekday, FechaBase) = 1 Then FechaBase = DateAdd(DateInterval.Day, 1, FechaBase) End If Return FechaBase.ToShortDateString End Function Sub EsperaIntro() Console.WriteLine("Pulse INTRO para continuar") Console.ReadLine() EEnndd SSuubb

EEnndd MMoodduullee


Ejecución guiada de ConArgumentosFun.vb



La línea 8 manda llamar a ejecución la función DeterminaFechaPago(), proporcionando como argumento el valor de la fecha del sistema; pudo haber sido cualquier fecha, y el programa calcularía la fecha de pago a partir de la misma.

La función es utilizada como si fuera una expresión String debido a que para el sistema no representa una función, sino lo que retorna: una expresión String.

La ejecución del programa se traslada automáticamente hasta encontrar una línea de encabezado de procedimiento que declare a un bloque de código bajo el nombre de «FechaPago» (línea 11). En la declaración del procedimiento, se especifica que dicho procedimiento espera que el programa que lo manda llamar a ejecución le proporcione un valor (ByVal) de tipo fecha (Date), y que con base en ello retornará un valor String.

Se procede a ejecutar el bloque de código compuesto por las líneas 12 a la 16, es decir, una después del Function, y una antes del End Function.

La línea 12 asigna al argumento FechaBase el resultado de sumarle a la fecha que proporcionamos al procedimiento la cantidad de 90 días; las líneas 13, 14, y 15 se encargan de validar que si el día calculado es domingo (internamente, el día de la semana número 1), se agregará un día más, a fin de que el día de pago sea un día hábil (lunes).

El programa se encuentra el fin del procedimiento, representado por la acción de que la función retornó el valor. La misma línea 8 considera el valor retronado por la función para desplegar la fecha calculada.

El control de la ejecución del programa continúa a la línea siguiente a aquella que mando llamar a ejecución el procedimiento (línea 9).


Esta función es totalmente flexible, ya que no depende de ninguna variable externa para funcionar, y para el compilador, la función es una expresión String. Esta función podría ser reutilizada prácticamente por cualquier programa, sólo hay que respetar los argumentos que requiere, y el tipo de valor que retorna.




FIN DEL EJERCICIO

Aprenda Custom Corseware.visual Basic 2008.Demo

Documents

Transcript of Aprenda Custom Corseware.visual Basic 2008.Demo