Aprenda Custom Corseware - Visual Basic 2008.demo

Aprenda Custom CourseWare
Cuando ningn material impreso se ajusta a tus necesidades especficas de conocimiento, nosotros podemos ayudarte. Puedes armar tu propio texto a partir de los mdulos que componen nuestros ms 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 increble.
Materiales en espaol. Materiales con apoyos didacticos (Presentaciones, Videos, Archivos complementarios, etc.) Estructura didctica de la serie de libros Aprenda Practicando: slo ejercicios pertinentes aplicables en el ejercicio profesional.
01-800-APRENDA | clientes@aprenda.mx
Microsoft Visual Basic Edicin 2008

Felipe Ramrez
Facultad de Contadura Pblica y Administracin Facultad de Ingeniera Mecnica y Elctrica Universidad Autnoma de Nuevo Len, Mxico.
Francisco Salazar
Facultad de Contadura Pblica y Administracin Universidad Autnoma de Nuevo Len, Mxico.
MXICO 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 relacin alguna, inferirse o atribuirse dicha relacin, respecto a organizaciones, productos, personas, o eventos de la realidad. El contenido del presente material tiene protegidos los derechos de autor de la manera ms amplia posible, por lo cual queda estrictamente prohibida su reproduccin parcial o total. Queda estrictamente prohibido su almacenamiento o introduccin a cualquier sistema de recuperacin de datos. Queda estrictamente prohibida su reproduccin o transmisin en cualquier medio conocido o por conocer, sin importar el propsito. La reproduccin slo podr realizarse previa autorizacin 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 aqul que PRODUZCA, REPRODUZCA, ALMACENE, DISTRIBUYA, TRANSPORTE O COMERCIALICE COPIAS DE LA OBRA SIN LA AUTORIZACIN DEL TITULAR DE LOS DERECHOS. Los nombres de organizaciones y productos comerciales que aparecen en el presente material son propiedad de sus respectivos dueos y titulares de derechos. DERECHOS RESERVADOS POR LOS RESPECTIVOS TITULARES Aprenda Practicando http://www.Aprenda.mx
Tcnicas 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 aplicacin en Visual Studio 2008. .................................................................... 13 Abriendo Visual Studio ............................................ 13 Creando una solucin .............................................. 14 Agregando proyectos a una solucin ...................... 16 Herramientas de Text Editor ................................... 18 Intellisense y deteccin dinmica de errores ........... 20 Modificando cdigo usando Text Editor ................. 23
2 Programacin en Visual Basic 2008 Edition
Objetivos
Los objetivos del presente mdulo 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 optimizacin del espacio de trabajo. 3. Aprender a construir y depurar aplicaciones.
Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008
Soluciones y proyectos
Si se utiliza Visual Studio, todo nuestro trabajo se organizar en soluciones y proyectos. Una solucin es el nivel ms alto o global de organizacin en Visual Studio, y consiste en una coleccin de proyectos, administrados en una sola estructura. Las soluciones almacenan informacin respecto a los proyectos que agrupan, las dependencias entre estos, as como el orden de construccin (compilacin y generacin de ensamblados) que deben tener entre s. Las soluciones tienen la extensin sln, y tienen algunas limitantes: la primera es que slo se puede tener una solucin abierta en una instancia de Visual Studio; la segunda es que una solucin no puede contener a otra solucin. 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 cdigo (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 ms 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 mnimos para el tipo de aplicacin seleccionada, y adems establece de forma automtica las referencias a clases de .NET Framework usualmente requeridas. Es importante mencionar que algunos proyectos muy especiales no generarn 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 mdulos una aplicacin, y al mismo tiempo se puede tener una solucin maestra que englobe a todos los proyectos. Subdividir es una buena prctica, ya que al momento de estar desarrollando y solicitar la compilacin de los programas (Rebuild), se compilarn todos los proyectos de la solucin. 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 estn presentando errores, mismos que se tendrn que corregir antes de que usted pueda ver su programa compilado. Las soluciones deben planearse cuidadosamente con todo el equipo de desarrolladores. Que una solucin integre a todos los proyectos de otra solucin, no quiere decir que una solucin 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 integracin de software, que se da por la unin de proyectos. Es importante notar que en una misma solucin pueden convivir proyectos que utilizan diferentes lenguajes .NET, pero un proyecto slo puede tener cdigo 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 grfica, otro se ocupa de Solver, otro de las capacidades de graficacin, etctera. 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 sera inadmisible en trminos de tiempo y procesamiento. Partimos del supuesto que mantener las cosas simples es lo mejor. Trabajar con el mnimo de elementos, suficientes y necesarios para obtener los resultados que buscamos nos mantendr ms enfocados en el trabajo. Cuando se trabaja en ambientes colaborativos se recomiendan las siguientes prcticas relacionadas con los proyectos y las soluciones.
1. Se debe dividir la aplicacin en mdulos, e incluso submdulos. Cada mdulo y sub-mdulo es una unidad de labores de desarrollo, que contar con un responsable. De esa forma slo se trabaja con los archivos del mdulo; la compilacin y depuracin slo se realizar sobre lo que estamos trabajando, y no sobre lo que estn trabajando otros. 2. Se recomienda que el trabajo de desarrollo de mdulos y submdulos se haga en un equipo local, y nunca en un ambiente de produccin. 3. Se debe tener una solucin por cada mdulo, y una solucin por cada sub-mdulo, si aplica. 4. Cada solucin tiene un responsable. 5. Los desarrollos de los sub-mdulos slo se agregan al mdulo en caso de estar probados. 6. Todas las libreras de uso comn deben ser administradas por un responsable, an y cuando no sea quien las desarrolla. Debe haber una solucin para el manejo de las libreras de uso comn. 7. Slo el responsable de la solucin que contiene las libreras de uso comn puede autorizar las modificaciones a las libreras; al autorizar una modificacin deber comunicar de la actualizacin a todos los equipos de trabajo. 8. Se debe tener una solucin que integre todos los recursos y programas que componen la aplicacin, pero no se trabaja sobre ella. En esta solucin slo se integran los recursos que ya han sido probados a nivel mdulo. 9. La solucin que integra toda la aplicacin es la que se compilar finalmente para generar el entregable.
Creando aplicaciones en Visual Studio
El procedimiento ms sencillo para la creacin de una solucin es ingresando a Visual Studio. Aparecer la pgina principal de la herramienta, denominada Start Page (pgina de inicio), desde la cual se pueden abrir proyectos nuevos o existentes, as como consultar informacin de Visual Studio y la plataforma .NET.
En Start Page se selecciona la opcin de men File New Project (o presionar CTRL-MAYS-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, automticamente se tendr una solucin del mismo nombre. La desventaja de esta modalidad es que en aplicaciones grandes,
nunca un proyecto y una solucin se llaman igual, ya que la solucin es un concepto global, mientras que un proyecto es especfico. Cuando la creacin de un proyecto motiva la creacin automtica de una solucin homnima, Visual Studio entiende que la solucin se compone de un solo proyecto, a lo que se llama proyecto autnomo (stand-alone project); en este tipo de proyecto no se da mucha relevancia al concepto de solucin 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 aplicacin se desea (Templates). Las plantillas o templates permiten predeterminar los recursos iniciales de la aplicacin. Visual Studio preguntar dnde se desea guardar la aplicacin (Location), y con qu nombre (Name). Los archivos fuente que usted genere se encontrarn en el directorio que usted especifique. Se generar un archivo que mantendr la referencia de todos los archivos involucrados en la solucin, y tendr la extensin sln. Es posible que la solucin tenga un nombre distinto al del proyecto, por lo que se podr colocar un nombre especfico a la solucin (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 bsico de la sintaxis del lenguaje, enumeramos algunas caractersticas esenciales. 1. Visual Basic es no sensitivo a maysculas y minsculas (non case sensitive). 2. Las lneas de cdigo terminan al encontrarse un salto de lnea (CR/LF). 3. El continuador de lnea es un guin bajo ( _ ); el continuador de lnea no debe interrumpir expresiones, antes de l debe haber un espacio en blanco, y despus de l no debe escribirse nada. 4. Un bloque de cdigo es el conjunto de lneas que deben ser tratadas como unidad de ejecucin. Los bloques de cdigo generalmente se delimitan por estructuras con inicio y fin (Module End Module, Sub End Sub, etc.). 5. Todo bloque de cdigo que se inicie debe cerrarse. 6. El ltimo bloque de cdigo en abrirse debe ser el primero en cerrarse.
11
7. Las bibliotecas a utilizarse en un programa se declaran al inicio del mismo, utilizando la palabra reservada Imports. 8. Se utilizan parntesis para delimitar expresiones que deban resolverse, o para delimitar argumentos. 9. Las variables que se utilicen en un programa deben estar definidas de manera explcita. 10. Aunque no es relevante para el compilador, evite la codificacin de todo maysculas o todo minsculas. Procure iniciar las palabras reservadas con maysculas. Este es un ejemplo tpico 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 mdulo quede bien comprendido, son los siguientes: 1. Lab.01: Creando una aplicacin en Visual Studio 2008.
13
Lab.01: Creando una aplicacin en Visual Studio 2008.

En el presente ejercicio conoceremos la forma de lanzar a ejecucin Visual Studio 2008, y la forma en que se crea una aplicacin en dicha herramienta.
Abriendo Visual Studio

1. Desde el Botn 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 mens. Permite seleccionar tareas que deseamos que la herramienta ejecute. La Barra de mens contiene todas las tareas que es posible desarrollar con la herramienta.
1.1.2.
Barra de herramientas. Al igual que la barra de mens, permite seleccionar tareas que deseamos que la herramienta ejecute, slo que de manera ms rpida. La Barra de herramientas contiene slo las tareas ms comunes. Document Window (rea de trabajo). Es el rea en donde podremos trabajar nuestros proyectos. Esta rea es muy dinmica, pues puede comportarse como herramienta de diseo, como editor de cdigo, entre otras. Herramientas. Son diferentes ventanas que proporciona Visual Studio para trabajar con los proyectos. Aparecen generalmente de forma colapsada a manera de pestaas en los extremos de Document Window, pero pueden activarse si se coloca el puntero del ratn sobre las pestaas. Tambin es posible especificar que estn siempre visibles. De las ms importantes, estn 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 grficos y objetos programticos, para incluirlos en un proyecto. 1.1.4.3. Properties. Herramienta que permite modificar las propiedades de cualquier elemento de nuestra aplicacin.
1.1.3.
1.1.4.
1.1.5.
Al iniciar la ejecucin de Visual Studio, el rea de trabajo contendr la pgina de inicio de la herramienta, llamada Start Page, que es el punto de inicio para crear o abrir desarrollos en Visual Studio, y obtener informacin reciente de .NET.
Creando una solucin

2. Seleccione la opcin File New Project (CTRL-MAYS-N). la ventana de New Project. Con ello aparecer
15
3. Para crear una solucin, 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 automtica todos los elementos tpicos de una solucin, dejndola lista para que le sean agregados proyectos. 3.3. En Name coloque el nombre de la solucin, que es Ejercicios; en Location mantenga la direccin que ah aparezca. El proyecto se almacenar fsicamente 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 solucin (\Ejercicios). Dentro de ese directorio se encuentra el archivo principal del la solucin (.sln). 3.5. Pase el puntero del ratn sobre la pestaa 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 solucin Ejercicios, y que an no tiene proyectos (0 projects). 3.6. Si tiene dudas de este ejercicio, vea el clip 3502.01.01.vmw.
Agregando proyectos a una solucin 4. Para agregar un proyecto a una solucin, siga estos pasos. 4.1. Actualmente, la herramienta Solution Explorer est en modo AutoHide, lo que quiere decir que slo se mostrar si se est trabajando con la herramienta, y aparecer si se pasa el puntero del ratn sobre la pestaa 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 ratn sobre la pestaa 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. La tachuela cambia de forma horizontal a vertical, y a partir de ese momento la herramienta estar permanentemente en el rea de trabajo. Saga del rea que ocupa Solution Explorer, y compruebe que la herramienta no se oculta ya.
4.1.2.
4.1.3.
4.2. En Solution Explorer, seleccione el nodo correspondiente a la solucin, 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 solucin.
17
4.4. Queremos crear una aplicacin de consola que est codificada en Visual Basic. Como ese tipo de aplicaciones utiliza Windows Application Services para su ejecucin, se trata de una aplicacin Windows, aunque no tenga una interfaz grfica. 4.4.1. 4.4.2. En Project Types seleccione Visual Basic Windows. 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 solucin que ya hemos creado. 4.7. En Location mantenga la direccin que ah aparezca. 4.8. Haga clic en Ok, y dentro del Directorio de la solucin se generar el Directorio del proyecto (\HolaMundoCon\). Dentro del Directorio del proyecto se encontrar el archivo de cdigo fuente del programa de consola (.VB) y el archivo del proyecto (.VBPROJ) que concentrar las referencias de los archivos fsicos involucrados en el proyecto. Se generan tambin directorios de trabajo: en \Bin se colocarn los ensamblados que se generen cuando se realice la compilacin del proyecto, en \My Project se almacenarn archivos de configuracin y especificaciones tiles para la compilacin del proyecto, y en \obj se colocarn archivos temporales involucrados en el proceso de compilacin y depuracin. 4.9. Al haber especificado como Template una Console Application, Visual Studio genera de forma automtica los archivos y referencias comunes para una aplicacin de consola. El componente principal ser un programa de cdigo fuente llamado Module1.vb, que es mdulo en Visual Basic. 5. Document Window es el espacio principal de trabajo en Visual Studio, en donde la mayora de las herramientas se ubicarn en tiempo de diseo. En Document Window aparecer Text Editor, que es el editor de texto plano en donde se podr modificar el cdigo de Module1.vb. 6. En este momento Solution Explorer debe mostrar todos los elementos fsicos que componen la solucin, y en Document Window se tendr a Text Editor modificando el cdigo de Module1.vb. 7. Es importante notar que, como la solucin slo tiene un proyecto, Visual Studio asume que se trata de un Stand-Alone Project, y por lo cual no muestra informacin de la solucin en Solution Explorer. Al momento en que se agreguen ms proyectos a la misma solucin, slo entonces e mostrar la informacin correspondiente a la solucin.
8. En caso de dudas respecto a esta prctica, revise el clip 3502.01.02.wmv.
Herramientas de Text Editor

9. Text Editor tiene los siguientes elementos.
19
10. Text Editor es una herramienta fascinante de edicin de cdigo, dadas las muchas herramientas que ofrece, dentro de las cuales se encuentran las siguientes. a. Barra de seleccin de documentos. En la parte superior de Text Editor aparecer una barra que mostrar las pestaas (Tabs) que permitirn seleccionar el documento con el que deseamos estar trabajando. b. Tabs. Llamadas tambin pestaas de seleccin, 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 seleccin 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 seleccin de documentos para mostrar las pestaas de seleccin, 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 cdigo (Branching). Como se puede observar, al inicio de un procedimiento, mdulo o clase, en las lneas delimitadoras de branching aparecen smbolos (-) y (+); estos pequeos iconos permiten visualizar y ocultar el cdigo delimitado, con lo que podemos hacer ms clara nuestra codificacin, mostrando slo aquellas partes del cdigo que realmente nos interesa observar. f. Complementacin automtica de cdigo. Es la capacidad de Text Editor de agregar de forma automtica lneas de cdigo que por regla de lenguaje debe escribirse. Esto simplifica el proceso de codificacin, adems que evita errores por omisin de cdigo. g. Coloring. Es la capacidad de Text Editor de diferenciar por colores los elementos del cdigo. Generalmente las palabras reservadas estarn 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 estn siendo bien escritas.
h. Divisores de procedimientos. Son las delimitaciones horizontales que separan los procedimientos incluidas en el cdigo. i. Divisor de paneles de edicin. Si se arrastra el icono Divisor de paneles de edicin, podr dividirse el espacio de edicin de Text Editor en dos mitades. En cada una de las mitades podr desplazarse, ver y editar diferentes partes del cdigo. Esto es especialmente til en programas muy extensos, en donde desea estar comparando porciones de cdigo que es imposible mantener juntas en una misma pantalla. Selector de elementos. Se trata de un combo que muestra los diferentes mdulos y elementos globales de una aplicacin. En caso de que el programa posea muchos elementos globales, este combo permite ir directamente a la parte de cdigo que nos interesa, sin tener que estar navegando entre las lneas de cdigo para buscar.
j.
k. Selector de miembros. Trabaja de la misma forma que Selector de elementos, slo que a un nivel ms bajo. Permite seleccionar un miembro de un elemento global. l. Intellisense. Capacidad a travs de la cual Text Editor propone los objetos y miembros ms comunes, conforme se escribe el cdigo.
Intellisense y deteccin dinmica de errores

11. Dentro del procedimiento Main() introduzca la siguiente lnea. Console.WriteLine(Presione INTRO) Esto se deber escribir en varios tiempos. Primero escriba Console. Al llegar al punto, aparecer un men dinmico que propone los elementos del lenguaje que concuerdan con el cdigo 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 codificacin, adems de evitar errores de sintaxis. A esta funcionalidad se le llama intellisense. Intellisense tiene en la parte baja dos pestaas: Common y All. Dado que los elementos de un objeto pueden ser muchos, Visual Studio nos permite ver los ms comunes, o bien todos. Por omisin mostrar los ms comunes, lo cual es muy prctico. Del men de elementos que
21
aparecen, es posible seleccionar utilizando el puntero del ratn, utilizando las flechas de direccin, o bien por concordancia con lo escrito. Slo en caso de que lo que busque no se encuentre en Common, recurra a All.
Siga escribiendo, hasta que haya escrito Console.WriteL . La informacin 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 cdigo que pretendemos escribir, basta con escribir el caracter que seguira, en
caso de escribir nosotros el cdigo. En este caso sera un parntesis (. Escriba un parntesis derecho, y vea cmo Intellisense complementa el cdigo de forma automtica, 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 lnea de cdigo, y vea cmo aparece una ayuda interactiva de llenado de los elementos. En este caso, la ayuda nos indica que si escribimos WriteLine(), lo que obtendramos sera un terminador de lnea. 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.
23
A este momento ya debi de haber escrito la lnea de ejemplo por completo. 11. Modifique la lnea, de tal forma que escriba Console con doble s, a fin de causar un error. Vea cmo al introducir una lnea que presenta errores de sintaxis, Visual Studio le seala la falta muy al estilo de Word, subrayando el error en color azul. Si se coloca sobre la parte del cdigo 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 lnea para que ya no genere errores. 13. En caso de dudas respecto a esta prctica, revise el clip 3502.01.03.wmv.
Modificando cdigo usando Text Editor

14. Como todo programa Hola Mundo, se espera que el usuario interacte con el programa, y que ste enve 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 cdigo deber quedar de la siguiente forma.
Codificacin 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 aplicacin en .NET usando Visual Studio 2008.
FIN DEL EJERCICIO
Elementos del lenguaje

Contenido:
Objetivos ........................................................................................... 3 Variables ........................................................................................... 4 Identificadores ................................................................................. 6 Tipos de datos .................................................................................. 9 Conversin de datos ......................................................................14 Conversin implcita (Casting) .......................................................14 Conversin explcita .......................................................................15 Conversin por mtodo..................................................................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 Declaracin de variables ...............................................................22 Constantes .....................................................................................24 Literales ..........................................................................................25 Valores por omisin .......................................................................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 declaracin de variables, constantes y la realizacin de conversiones .....................48 Lab.03: Demostrando el alcance de las variables y la forma en que preservan valores ........................................50 Lab.04: Comprobacin de arreglos unidimensionales, multidimensionales y escalonados ....................................54 Operadores aritmticos .................................................................58 Operadores de asignacin .............................................................60 Expresin ........................................................................................60 Operadores de asignacin incluyente ...........................................62 Operadores comparativos .............................................................64 1
Programacin en Visual Basic 2008 Edition Consideraciones relativas al cdigo ASCII ....................................66 Option compare ..............................................................................68 Operadores Is, IsNot y TypeOf .......................................................70 Operador Like .................................................................................72 Operadores lgicos ........................................................................75 Operadores lgicos de circuito corto ............................................79 Prioridad entre operadores ...........................................................81 Uso de parntesis para otorgar preferencia de ejecucin .............................................................................83 Ejercicios.........................................................................................84 Lab.05: Utilizacin general de operadores en Visual Basic ....................................................................................85 Lab.06: Uso de operadores de asignacin 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 decisin .................................... 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 ejecucin un procedimiento .................................................................. 114 Argumentos ................................................................................. 115 Valores de retorno ....................................................................... 116 Codificacin de procedimientos ................................................. 117 Argumentos opcionales y valores por omisin .......................... 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
Mdulo 2: Elementos del Lenguaje
Objetivos
Los objetivos del presente mdulo son los siguientes: 1. 2. 3. 4. Aprender el manejo de variables y arreglos en Visual Basic Aprender el uso de operadores en Visual Basic Aprender el manejo de estructuras de decisin y control en Visual Basic Aprender el la forma en que se programan procedimientos y funciones en Visual Basic
Programacin en Visual Basic 2008 Edition
Variables
Una variable de memoria es la referencia lgica a una posicin fsica 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 estarn disponibles mientras no liberemos la memoria, ya sea por medio de programacin o como resultado de haber cerrado la sesin de programa donde fueron definidas. Por supuesto, apagar la mquina provoca cerrar todos los programas, y por tanto, perder los valores almacenados en las variables definidas por stos. Las variables tienen siempre las siguientes caractersticas:
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 cdigo 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 ejecucin. Accesibilidad (accessibility). Es el permiso que se proporciona al cdigo para leer la variable o para escribir en la variable. Tiempo de vida (lifetime). Es el periodo de tiempo de ejecucin en el cual la variable est disponible.
Identificadores
Se le llama identificador (identifier) al nombre lgico de un elemento de programacin, por medio del cual podr ser referido. Las variables, al igual que los procedimientos, las clases, las estructuras, etctera, poseen un identificador, a travs de los cuales son utilizables de manera programtica. Reglas de composicin de los identificadores . identificadores deben cumplir con las siguientes reglas:
Los
Deben iniciar con un caracter alfabtico o con una lnea baja ( _ ). Slo pueden contener caracteres alfabticos, dgitos decimales, o lnea baja. Si inician con lnea baja, al menos deben contener un dgito decimal o un caracter alfabtico. No pueden contener espacios intermedios.
Reglas no escritas de composicin 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 vlidos, sin embargo, le ser de ms 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 ms larga sea, ms complejo el programa. S: Nombre; No: NombreDelClienteQueAdquiereProducto. Se recomienda no utilizar lnea baja en el nombre; si puede evitar dicho caracter, evtelo; recuerde que la lnea baja es el continuador de lnea del lenguaje, y puede crearse confusin innecesaria. S: VentasMensuales; No: Ventas_Mensuales. Se recomienda el manejo de letra capital para el nombre de variables; coloque una letra mayscula cada vez que inicie una palabra en su identificador (Pascal casing). S: VentasMensuales; No: ventasmensuales. Evite el uso de conjunciones. VentasDelMes. S: VentasMensuales; No:
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 maysculas y minsculas, 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 mayscula la primer letra de cada palabra de un identificador, incluyendo la primera. Este es el tipo ms 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 mtodos y propiedades.
Camel casing. El estilo Camel casing se caracteriza por colocar en mayscula 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 parmetros; si el parmetro se compone de una sola palabra, toda la palabra va en minscula. Informacin de alcance privado, tales como campos y variables.
Notacin hngara (Hungarian notation) . La Notacin hngara se caracteriza por colocar un prefijo a las variables, dando a entender su tipo o funcin. Este estilo est cada vez ms en desuso, por lo cual sugerimos evitarlo al mximo. Ejemplo: intVentasMensuales, strNombre, que nos da a entender que se trata de un dato Integer. Se recomienda usar Hungarian notation:
Nunca
N O TA Evitar la notacin hngara es la recomendacin de Microsoft. En realidad, la notacin hngara sigue siendo utilizada mucho por la comunidad de desarrollo, e incluso en el sitio de Microsoft encontramos muchos ejemplos con dicha notacin. Utilizar la notacin hngara ser a fin de cuentas una decisin del equipo de desarrollo, y no afecta la funcionalidad de las aplicaciones.
En este apartado hacemos recomendaciones solamente; lo ms 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 nmero 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 situacin 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 podrn realizar con el mismo. Se le llama dominio al conjunto de valores vlidos para un dato. Por ejemplo, el dominio de un dato que almacenar un nmero de mes, ser nmeros 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 nmeros enteros del 0 al 255.
10
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 intrnsecos. Types de usuario, llamados tambin 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 travs del cual se invoca la funcionalidad desde el cdigo fuente en un determinado lenguaje; el nombre del type puede ser ms 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 ms complejo. Todos los lenguajes tienen acceso a la misma biblioteca de clases. La variacin es que cada lenguaje tendr su implementacin para llegar a System.Int32 (Visual Basic, Integer; C#, int; C++, int o long; JScript, int). Adems de nombre, los types tambin poseen un tamao de type, que representa el consumo en bytes del type. Esto es importante dado que la memoria RAM es siempre limitada. Los types intrnsecos 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 mtodo de una clase de BCL, que no debe ser instanciada para funcionar.
11
12
Visual Basic soporta los siguientes tipos de datos intrnsecos:

Tipo de dato Estructura o Clase.NET Framework a la que se hace referencia System.Boolean (estructura) System.Byte (estructura) System.Char (estructura) System.DateTime (estructura) System.Decimal (estructura) Consumo en bytes Rango de Valores (Dominio de tipo)
Boolean
1 byte
True o False
Byte
1 byte
De 0 a 255 (sin signo)
Char
2 bytes
Caracteres UNICODE
Date
8 bytes
De Enero 1, 0001 a Diciembre 31, 9999
Decimal
12 bytes
Double
System.Double (estructura)
8 bytes
Integer
System.Int32 (estructura) System.Int64 (estructura) System.Int16 (estructura) System.Single (estructura)
4 bytes
(a) +/-79,228,162,514,264,337,593,543,950,335 sin punto decimal; (b) +/-7.9228162514264337593543950335 con 28 posiciones despus del punto decimal; (c) el mayor nmero menor a cero representable es: +/-0.0000000000000000000000000001 (a) -1.79769313486231E+308 a -4.94065645841247E-324 para valores negativos; (b) 4.94065645841247E-324 a 1.79769313486231E+308 para valores positivos De -2,147,483,648 a 2,147,483,647
Long
8 bytes
De -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807 De -32,768 a 32,767
Short
2 bytes
Single
4 bytes
String
System.String (clase)
Depende de la plataforma
(a) -3.402823E+38 a -1.401298E-45 para nmeros negativos; (b) 1.401298E-45 a 3.402823E+38 para valores positivos De 0 a aproximadamente 2 billones de caracteres Unicode
Se consideran tipos de dato numrico los siguientes: Byte, Double, Integer, Long, Short y Single. Se consideran tipos de dato no numrico los siguientes: Boolean, Date, Decimal, Object y String. Aunque Decimal almacena nmeros, el manejo que hace del punto flotante hace su manejo ms complejo. En el caso de Object, es una definicin no determinada de tipo, que puede asumir cualquier valor.
13
Algunas recomendaciones que hacemos son las siguientes:
Al definir variables, se recomienda utilizar los tipos de datos ms adecuados, cuidando que las operaciones que se realizarn con los valores no vayan a provocar un conflicto de tipos. Si va a realizar operaciones de alta precisin, 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 numricos, pues son los que ms eficientemente se manejan por la computadora. En trminos de tiempo de manejo que requieren los tipos de dato para ser manejados, el tipo de dato ms eficiente, indiscutiblemente, es Integer, mientras que el menos eficiente ser Object. Visual Basic realiza lo que se llama conversin de tipo cast, es decir, conversin de tipos de datos en tiempo de ejecucin, 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 ms cmodo dejar hacer al lenguaje, usted pierde el control de su programa; en caso de que se presenten problemas, ser ms difcil determinar en donde se encuentran. Tenga visin a futuro con los datos, a fin de que no exceda los dominios de tipo. Por ejemplo, la lgica nos dice que la suma de dos nmeros enteros ser un nmero entero; matemticamente 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 ms 2,000,000,000, exceder el lmite del dominio de tipo; en ese caso, la suma de dos Integer puede ser Long. En ocasiones los problemas originados por esta situacin (numeric overflow), se presentan despus de haber utilizado la aplicacin durante mucho tiempo.
14
Conversin de datos
En muchas ocasiones requerir realizar conversiones de tipos de datos, principalmente de datos String a otros tipos. Se conoce como conversin de datos al hecho de cambiar el tipo de dato de un valor por otro. Se tienen tres formas de conversin de datos en Visual Basic. Los tipos de conversin en Visual Basic son los siguientes.
Conversin implcita (Casting)

La conversin implcita, conocida como casting, se presenta cuando el CLR es capaz de realizar la conversin en tiempo de ejecucin, sin que el programa lo especifique. Este tipo de conversin es comn en los tipos de datos numricos. Hay un fenmeno que se conoce como narrowing, cuando la conversin 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 conversin 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
15
atencin 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.
Conversin explcita
Se presenta cuando mediante cdigo se aplican funciones especficas que realizan la conversin. Principalmente se utiliza para convertir tipos String/Char a otros tipos. La conversin explcita puede hacerse mediante funciones especficas y funciones genricas. Las principales funciones especficas utilizadas son las siguientes. Funcin CBool(Expresin) CByte(Expresin) CChar(Expresin) CDate(Expresin) CDbl(Expresin) CDec(Expresin) CInt(Expresin) CLng(Expresin) CObj(Expresin) CShort(Expresin) CStr(Expresin) Consecuencia Convierte Expresin a Boolean. Convierte Expresin a Byte. Convierte Expresin a Char. Convierte Expresin a Date. Convierte Expresin a Double. Convierte Expresin a Decimal. Convierte Expresin a Integer. Convierte Expresin a Long. Convierte Expresin a Object. Convierte Expresin a Short. Convierte Expresin a String.
La principal funcin de conversin genrica es CType, cuya sintaxis es la siguiente. CType(Expresin, NombreTipoDato) Donde Expresin es la expresin a convertir, y NombreTipoDato es el nombre del tipo de dato al que se desea convertir la expresin. Ejemplo. CType(4, Integer)
16
Conversin por mtodo

Algunos tipos de datos, por ejemplo la mayora de los numricos, tienen implcito un mtodo que permite hacer una conversin de datos. El ms comn de estos mtodos es el mtodo ToString, que permite convertir a la representacin 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. Despus se declara una variable llamada EdadTexto que tomar la representacin String de la variable Edad, es decir 30.
17
Acceso a datos Value Type y Reference Type
Visual Basic, como todo lenguaje de programacin, permite el uso de la memoria de la mquina a travs de variables de memoria; el acceso a los datos almacenados en memoria a travs del uso de variables puede llevarse a cabo a travs 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 economa 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.
18
Las operaciones realizadas con una variable no afectan a ninguna otra. La asignacin 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 posicin 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 intrnseca respecto a un tipo de acceso. Son value type:
Todos los tipos de datos que almacenan nmeros: 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. 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.
Son reference type:

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 funcin, que utilice su propia versin del dato, y que mantenga intacto el valor original del mismo. Si se utiliza ByRef, se le estar especificando al procedimiento o funcin que utilice la misma
19
posicin 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 genrico para varios objetos o datos, se recomienda ampliamente utilizar ByVal a fin de que se realicen operaciones de la manera ms segura posible.
20
Strong Typing
Antes de Visual Basic, el lenguaje haba sido muy permisivo con los programadores; obviaba muchas cosas y permita a los programadores no ser formales con la tcnica, lo que a largo plazo siempre causaba problemas. Si no se declaraban las variables, Visual Basic lo haca por nosotros; si no se especificaban los tipos de datos, Visual Basic lo haca por nosotros; si no se planeaban las conversiones, Visual Basic las realizaba de manera implcita. Eso provocaba que los errores de fondo fueran difciles de encontrar, ya que el universo de cosas que podan estar equivocadas exceda nuestro conocimiento, ya que no todo estaba bajo nuestro control. Resultaba pattico estar buscando un error de lgica 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 diramos cuenta. Para evitar esas penosas situaciones, existen dos estatutos que se agregan antes de cualquier cosa en el cdigo y que aseguran que la codificacin sigue una tcnica formal, de tipo strong typing, es
21
decir, donde todos los datos estn asociados de manera explcita y no ambigua a un tipo determinado. Option Explicit [On/Off] La instruccin 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 explcita. Las conversiones implcitas (casting) no estn 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 explcitas. Si usted especifica Option Explicit y Option Strict, es muy probable que su cdigo sea bastante formal, y no se encontrar con errores extraos en tiempo de ejecucin. Los valores predeterminados de Option Explicit y Option Strict es Off. Una excelente prctica 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.
22
Declaracin 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 ejecucin, para almacenar uno o ms valores de un determinado tipo. No se pueden utilizar variables que no hayan sido declaradas previamente. La declaracin de una variable se lleva a cabo a travs de lainstruccin de declaracin: Dim. La sintaxis ms 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 declaracin (ValorInicial).
23
N O TA La expresin "almacenar valores en las variables de memoria" es una expresin equivocada. Los valores no "se almacenan" en las variables; en realidad se almacenan en posiciones fsicas de memoria RAM, y las variables slo son el medio a travs 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 posicin fsica de memoria, que es referida por el identificador de la variable.
La especificacin del tipo de dato a travs de la palabra reservada As es opcional; si se omite la especificacin de tipo de dato, la variable se declara automticamente bajo el tipo Object. Esta declaracin automtica garantiza que no se utilice una variable que no ha sido declarada, sin embargo, es lo ms 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 continuacin se muestran ejemplos de declaracin 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 lnea 1 declara una variable Object. La lnea 2 declara una variable Integer. La 3 es exactamente igual a la lnea 2, ya que Integer es la referencia a System.Int32. La lnea 4, adems de declarar la variable, le asigna un valor de inicio. La lnea 5 demuestra que se pueden declarar varias variables de un mismo tipo, separando los identificadores por comas. La lnea 6 demuestra que Dim soporta la declaracin de dos o ms variables de un mismo tipo, y de dos o ms tipos.
24
Constantes
Se conoce como constantes a las variables que slo cambiarn 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
25
Literales
Si se menciona un nmero 4, no tenemos suficiente informacin para saber si el nmero es Byte, Integer, Double, Decimal, dado que 4 puede ser de cualquiera de esos tipos. Lo mismo ocurrira con A, dado que no sabramos si se trata de un dato String o Char. Se tienen literales que permiten definir un valor, liberndolo de las ambigedades de tipo que pudiera tener.
Valores por omisin

Cada variable, en caso de que no se le asigne un valor, tendr un valor por omisin. A continuacin se muestra una relacin de los valores por omisin para los tipos de datos.
Tipo de dato
Tipos de datos numricos

Boolean Date Decimal Object String
Valor por omisin 0 False 01/01/0001 12:00 A.M. 0 Nothing
26
Origen de las variables: Clases y Estructuras
Decamos que en Visual Basic las variables son instancias de una clase o una estructura.
Variables basadas en clase (intermediacin requerida). Sabemos que una clase es la definicin formal de un tipo de objeto. Un objeto es la instancia de una clase; ste puede contener informacin y comportamiento. En el caso de los datos almacenados en memoria a travs de un objeto, stos pueden estar disponibles al usuario mediante referencias. Uno hace referencia al objeto, y el objeto hace referencia a una posicin de memoria en donde se encuentra el dato; esa intermediacin 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 ms demandantes de recursos, pero ofrecen mayor funcionalidad.
27
Variables basadas en estructura (acceso directo, sin intermediacin ). Una estructura (structure) es muy similar a una clase, en el sentido que puede almacenar datos y mtodos; 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 intermediacin 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.
28
Alcance de las variables
El alcance (scope) de las variables determina en qu partes del cdigo podr ser utilizada una variable sin utilizar un calificador. Para entender el alcance debemos entender antes el concepto de bloque de cdigo. Un bloque de cdigo (code block) es el conjunto de lneas de cdigo que constituyen una unidad de ejecucin. Generalmente se encuentran delimitados por una lnea de inicio y una lnea de conclusin, a lo que se conoce como branching; todas las instrucciones que culminen con End son delimitadores de bloque de cdigo (Module-End Module, Sub-End Sub, If-End If, etctera). Existen otras instrucciones, como For-Next y Do-Loop, que aunque no concluyen con End, tambin contienen bloques de cdigo. Los bloques pueden ser condicionales y no condicionales. Son bloques condicionales cuando su ejecucin depende de el valor obtenido al resolver una expresin lgica (If-End If, Do-Loop, por ejemplo), mientras que son bloques no condicionales aquellos que
29
no dependen de una evaluacin para ejecutarse (Module-End Module, Namespace-End Namespace, por ejemplo). Un aspecto importante a tomar en cuenta es que un bloque de cdigo puede formar parte de otro bloque de cdigo. Se tienen los siguientes alcances:
Alcance de bloque (Block scope). El alcance de bloque se presenta cuando la variable slo est disponible en el bloque de cdigo en el que est declarada. El alcance de bloque es el ms estrecho, en el sentido de que la variable tiene la menor vigencia posible. Cmo se define: declarando la variable dentro de un bloque de cdigo. 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 slo disponible para el procedimiento en el que est declarada. Cuando las variables slo pueden ser utilizadas dentro del procedimiento que las declara, reciben el nombre de variables locales. Cmo 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 cdigo. Alcance de mdulo (Module scope). El alcance de mdulo se presenta cuando la variable est disponible para todos los procedimientos de un determinado mdulo, clase o estructura en la que est declarada. Cmo se define: declarando la variable dentro del mdulo, 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 mdulos, clases o estructuras contenidas en un espacio de nombres. Este alcance es el de
30
mayor amplitud. Cmo se define: declarando una variable a nivel mdulo, con accesibilidad Friend o Public (que ver ms 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 homnimas si se declaran con diferente alcance; en ese sentido, podemos declarar una variable X a nivel mdulo, 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 ejecucin. 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 ms estrecho; a este comportamiento se le da el nombre de shadowing. Los valores de variables con el mismo nombre y distinto alcance sern mantenidos en tiempo de ejecucin, a fin de utilizar el valor de menor alcance segn se requiera en el programa.
31
Accesibilidad de las variables
La accesibilidad (accesibility) de una variable es el permiso que se proporciona al cdigo 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 travs de cdigo. Las diferentes opciones que se tienen de accesibilidad son:
Public. Conocidas como variables pblicas. Proporciona acceso pblico a la variable; no hay restricciones de uso de la variable cuando se define como pblica. Slo se puede definir a nivel mdulo, espacio de nombres, o archivo fsico; nunca a nivel procedimiento. Protected. Conocidas como variables protegidas. Proporcionan acceso protegido a la variable, es decir, slo pueden ser utilizadas por la clase en que se declar la variable, o en aquellas clases derivadas de sta. Slo 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
32
programa que la declara, y por todos aquellos que se encuentren en el mismo ensamblado. Slo se puede definir a nivel mdulo, espacio de nombres, o archivo fsico; nunca a nivel procedimiento.
Protected Friend. Proporciona la unin de restricciones de Protected y de Friend. Private. Conocidas como variables privadas. Proporciona acceso privado a una variable. Slo estn disponibles para el alcance en el que fueron declaradas. Slo se puede definir a nivel mdulo, espacio de nombres, o archivo fsico; nunca a nivel procedimiento. Static. Conocidas como variables estticas. Permite incrementar la persistencia del valor de las variables, manteniendo el ltimo valor que haya asumido, an despus de la terminacin del procedimiento que la declar. Slo se puede definir a nivel procedimiento. No se pueden declarar variables estticas en los procedimientos de una estructura; slo 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 seran como variables pblicas 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 travs de un calificador (anteponer al nombre de la variable el nombre de la clase en donde se declar inicialmente, ms un punto separador). Slo se puede definir a nivel mdulo, espacio de nombres, o archivo fsico; nunca a nivel procedimiento. Las variables compartidas (shared variables) identifican una sola unidad de almacenamiento, sin importar cuntas 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 mltiples, ya que no basta con que las variables sean pblicas. ReadOnly. lectura. Especifica que se trata de una variable de slo
33
Si no se especifica alguna opcin de accesibilidad, las variables sern variables de instancia y privadas (instance variable, private). En caso de que se desee asignar alguna opcin de accesibilidad, la especificacin pasa a ser el estatuto de declaracin, y puede sustituir a Dim. Ejemplo. Static Dim Edad As Integer
Es lo mismo que:
Static Edad As Integer
N O TA 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 mdulo, clase o estructura que contiene el procedimiento mencionado, no podr llegar nunca a l.
34
Arreglos
Se conoce como arreglos (arrays), tambin 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 posicin de memoria dentro de un arreglo es a travs de un subndice, que es la posicin secuencial de cada elemento dentro de la coleccin. Los subndices, 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 subndices siempre se especifican entre parntesis. Las colecciones son conjuntos de objetos lgicamente relacionados, diferenciados por un subndice. En su calidad de colecciones, pueden ser explorados con la instruccin For Each, cuya sintaxis es la siguiente.
35
For Each Elemento [As TipoDato] In Coleccin BloqueCdigo [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 coleccin. Coleccin es la coleccin de objetos que podrn ser ledos de forma secuencial utilizando For Each. BloqueCodigo es el bloque de cdigo que se ejecutar de forma iterativa para cada elemento de la coleccin explorado. Al encontrar Next el proceso iterativo comienza nuevamente; es posible interrumpir el ciclo en cualquier momento, utilizando Exit For.
36
Arreglos unidimensionales
Los arreglos unidimensionales se conocen simplemente como arreglos, y requieren de un slo subndice para tener acceso a un elemento del arreglo. La forma de declarar un arreglo en Visual Basic es la siguiente. Dim Arreglo(MximoSubndice) As TipoDato Donde Arreglo es el identificador del arreglo; su nombrado sigue las mismas reglas que las variables. MximoSubndice es el nmero mayor de subndice del arreglo, y TipoDato es el tipo de dato de los elementos del arreglo. Ejemplo. Dim VentaMensual(11) As Integer
37
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 nmero determinado de elementos, el arreglo ser de un nmero indeterminado de elementos. Dim VentaMensual() As Integer A este tipo de arreglos se les llama arreglos unidimensionales, pues nicamente es necesario especificar un subndice para tener acceso a una posicin en memoria del arreglo. Tambin es posible asignar valores al momento de declarar un arreglo. En ese caso, no se deber especificar nmero de elementos, ya que el nmero de elementos se calcular automticamente considerando el nmero de valores que se especifiquen entre llaves ({ }), separados por comas (,). La sintaxis sera 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 asumirn los elementos; los valores debern estar separados por comas. Ejemplo. Dim Numeros() As Integer = {10,20,40,100}
En este caso, Numeros(1) tendr el valor de 20.
38
Arreglos multidimensionales
Se conoce como arreglos multidimensionales, a un conjunto de posiciones en memoria que son referidas por un solo identificador, a travs de dos o ms subndices. Al nmero de subndices que es necesario especificar para tener acceso a una posicin 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 ms 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 nmero mayor de subndice para la dimensin 1, MS2 es el nmero mayor de subndice para la dimensin 2, y as hasta definir todas las
39
dimensiones. arreglo. Ejemplo.
TipoDato es el tipo de dato de los elementos del
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 nmero determinado de elementos, el arreglo ser de un nmero indeterminado de elementos. Dim VentaTrim(,) As Integer A este tipo de arreglos se les llama arreglos multidimensionales, pues slo es necesario especificar un subndice para tener acceso a una posicin en memoria del arreglo. Tambin es posible asignar valores al momento de declarar un arreglo. En ese caso, no se deber especificar nmero de elementos, ya que el nmero de elementos se calcular automticamente considerando el nmero de valores que se especifiquen entre llaves ({ }), separados por comas (,). Cada llave constituye la serie de valores para una dimensin. La sintaxis sera 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 asumirn los elementos; los valores debern estar separados por comas. Ejemplo.
Dim VentaTrim(,) As Integer = {{1000,20000,10000,5000}, _ {2000,30000,15000,2000}}
40
En este caso, VentaTrim(1,2) tendr el valor de 15000.
41
Arreglos escalonados
Se conoce como arreglos escalonados (jagged arrays) a un arreglo que almacena arreglos. La sintaxis para su definicin sera la siguiente. Dim Arreglo()() As TipoDato Donde Arreglo es el identificador del arreglo; su nombrado sigue las mismas reglas que las variables. Dependiendo el nmero de arreglos que se desee incluir, se debern agregar pares de parntesis con posterioridad al nombre de variable. TipoDato es el tipo de dato que tienen los elementos en los arreglos. Ejemplo. Dim Numeros()() As Byte
42
En este caso se tiene un arreglo que almacenar dos arreglos, donde los elementos son de tipo Byte. Tambin 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 debern 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. Estaramos extrayendo, del arreglo 0, el elemento 3. El primer subndice proporcionado indica el nmero de arreglo del que se trata, mientras que el segundo subndice indica el o los subndices 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 nmero de identificacin de 1000
43
empleados y 5 nmeros de categoras de empleados, un arreglo multidimensional ocupara 1000 x 5 posiciones de memoria, es decir, 5000; un arreglo escalonado, por el contrario, requerira slo 1000 + 5, es decir, 1005. Si el arreglo fuera de datos Long (8 bytes), la diferencia en consumo de memoria sera de 31,960, que bien podra economizar. Una cosa importante a tomar en cuenta es que los arreglos escalonados no forman parte de CLS, por lo que slo trabajarn adecuadamente en implementaciones Microsoft, y no en otras plataformas que implementen considerando CLS como base.
44
Ejercicios
Los ejercicios que es necesario realizar para que el conocimiento de este mdulo quede bien comprendido, son los siguientes: 1. Lab.01: Demostrando las capacidades de las variables ByVal y ByRef 2. Lab.02: Demostrando la declaracin de variables, constantes y la realizacin de conversiones 3. Lab.03: Demostrando el alcance de las variables y la forma en que preservan valores 4. Lab.04: Comprobacin de arreglos unidimensionales, multidimensionales y escalonados
45
Lab.01: Demostrando las capacidades de las variables ByVal y ByRef

En el presente ejercicio conoceremos la forma de agregar un proyecto a una solucin existente, y adems se comprobar el manejo del alcance de las variables.
1. 2.
Abra la solucin ejercicios. 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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios. Vea cmo en Solution Explorer se agrega el nuevo proyecto a la solucin, y adems se coloca como Start up Project, es decir, el que se ejecutar al lanzar la depuracin con F5.
3.
4. Edite el programa de tal forma que aparezca como sigue.
46
Codificacin 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
Ejecucin guiada de ValRef Module1.vb
5. Construya la solucin (CTRL-MAYS-B). Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) y guarde todos los cambios que ha realizado en la solucin (CTRL-MAYS-S). Inicie la depuracin para comprobar el comportamiento de su programa (F5). 6. Este programa es type safe, dado que todas las variables debern declararse antes de ser utilizadas (Option Explicit) y las conversiones tienen que hacerse de forma explcita (Option Strict). 7. El programa declara una variable de memoria, llamada Texto, que se ver sometida a modificaciones en su contenido (lnea 7); de inicio, se le asigna un valor de Texto original, mismo que es mostrado en la consola (lnea 8). La variable ser proporcionada como argumento a dos procedimientos, uno de los cuales tratar el dato como valor (lneas 17 a la 20), y otro como referencia (lneas 22 a la 25). 8. Usando el dato como tipo valor. En la lnea 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
47
la lnea 18 se modifica el valor de Texto, por Texto Valor, y se muestran los efectos del cambio en la lnea 19. Despus de ejecutar Valor(), se muestra el contenido de la variable Texto (lnea 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 lnea 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 lnea 23 se modifica el valor de Texto, por Texto Referencia, y se muestran los efectos del cambio en la lnea 24. Despus de ejecutar Referencia, se muestra el contenido de la variable Texto (lnea 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 informacin la misma posicin 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
48
Lab.02: Demostrando la declaracin de variables, constantes y la realizacin de conversiones

Se comprobar la declaracin y uso de variables en un proceso. 1. Abra la solucin 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 AreaRectangulo. Sea cuidadoso de seleccionar en Solution la opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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 = "--- Rectngulo ---" 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
Ejecucin guiada de AreaRectangulo Module1.vb
4. Construya la solucin (CTRL-MAYS-B). Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) y guarde todos los cambios que ha realizado en la solucin (CTRL-MAYS-S). Inicie la depuracin para comprobar el comportamiento de su programa (F5). 5. La lnea 4 declara una constante, a la cual se le asigna como valor el mensaje que ha de aparecer como encabezado del programa (lnea 9); en la lnea 5 se muestra una declaracin de variable, en su forma ms
49
sencilla; en la lnea 6 se comprueba que es posible asignar un valor inicial al momento de la declaracin; en la lnea 7 se comprueba la posibilidad de declarar mltiples variables de mltiples tipos en una misma lnea; esta ltima prctica no se recomienda, por cuestiones de claridad en el cdigo. 6. En la lnea 9 se muestra el ttulo del programa en la consola. En la lnea 10 se muestra el mensaje que pregunta la base del rectngulo, y en la lnea 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 lnea 12 se encarga de convertir el dato String en Integer, utilizando para ello la funcin especfica CInt; el resultado es asignando a la variable Base. La misma mecnica se seguir para preguntar y convertir la altura del rectngulo, con la diferencia que se utilizar para la conversin la funcin genrica CType. 8. La lnea 17 calcula el rea del rectngulo, asignando el valor a la variable Resultado. Como resultado es de tipo Single, posee de forma intrnseca el mtodo ToString, que es utilizado en la lnea 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 explcita, CLR hubiera realizado el casting. 10. Proporcione un valor de 10 para la base y un 15 para la altura, y vea los resultados. Si todo ocurri como se esperaba, la salida ser la siguiente:
Entrada --- Rectngulo --Base: 10 Altura: 15 Resultado: 150
FIN DEL EJERCICIO
50
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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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 mdulo" 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
51
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
Ejecucin guiada de Alcance Module1.vb
4. Construya la solucin (CTRL-MAYS-B). Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) y guarde todos los cambios que ha realizado en la solucin (CTRL-MAYS-S). Inicie la depuracin para comprobar el comportamiento de su programa (F5). 5. Este programa es type safe, dado que todas las variables debern declararse antes de ser utilizadas (Option Explicit) y las conversiones tienen que hacerse de forma explcita (Option Strict). Lneas 1 y 2. 6. Se declaran variables con diferente alcance en las lneas 5, 9, y 12. En la lnea 5 se declara la variable Texto1; esta variable tiene un alcance a nivel mdulo, debido a que se declara dentro del mdulo, fuera de cualquier procedimiento. Esta variable podr ser utilizada por todos los procedimientos del mdulo, es decir, Main(), Procedimiento1(), y Procedimiento2(); esto se comprueba en la lneas 8 y 29, pues se despliega en la consola una variable no definida en esos procedimientos. En la lnea 9 se declara la variable Texto2, que tiene un alcance a nivel procedimiento, por estar declarada dentro de un procedimiento especfico, pero fuera de un bloque de cdigo; por esa razn se trata de una variable local. Esta variable estar disponible slo para Main(), pero no para otros procedimientos. En la lnea 12 se declara la variable Texto3, que tiene un alcance a nivel bloque de cdigo, y estar disponible desde que se declara (lnea 12) hasta que se encuentre el estatuto que marca el final del bloque de cdigo, en este caso End If, en la lnea 14. Si se trata de utilizar la variable Texto3 despus de la lnea 14, pensando que es una variable local (de alcance a nivel procedimiento), nuestro programa generar error, ya que la variable slo existe declarada para el bloque en que se declara.
52
7. Comprobando la variable esttica. En la lnea 15 se manda ejecutar Procedimiento1(); en dicho procedimiento se define una variable esttica llamada Texto4 (lnea 25). Esta variable tendr un tiempo de vida que excede el tiempo de vida del procedimiento que la declara, ya que por ser esttica, mantendr los valores en memoria aun concluida la ejecucin del procedimiento. En la lnea 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 esttica, el valor que va adoptando se comporta como un acumulador, que nunca pierde el valor que tena, obtenido de procesamientos anteriores. Las lneas 16 y 17 mandan ejecutar Procedimiento1(), a fin de que se compruebe que efectivamente la variable mantiene su valor al correr de las mltiples ejecuciones del procedimiento. 8. Comprobando Shadowing. Ya vimos que en la lnea 5 Texto1 se defini con un alcance a nivel mdulo, y al momento de declarar la variable se le asign el valor Alcance mdulo. En Procedimiento2(), se vuelve a definir la variable Texto1 (lnea 37), y se le asigna al momento de declaracin el valor Shadow. 9. a) Qu alcance tiene la variable Texto1, declarada en la lnea 37?
b) Qu valor posee Texto1, cuando es desplegada en la consola en la lnea 38?
c) Qu valor posee Texto1, cuando es desplegada en la consola en la lnea 40?
Como podr darse cuenta, el programa no genera conflicto con la doble declaracin de la variable; simplemente utiliza aquella que tenga menor alcance.
53
Si todo ocurri como se esperaba, la salida ser la siguiente:

Alcance mdulo Alcance procedimiento Alcance block --Procedimiento 1 ---Texto 1: Alcance mdulo Texto 4: Valor + -----------------------Procedimiento 1 ---Texto 1: Alcance mdulo Texto 4: Valor + Valor + -----------------------Procedimiento 1 ---Texto 1: Alcance mdulo Texto 4: Valor + Valor + Valor + -----------------------Procedimiento 2 ---Texto 1: Shadow Texto 1: Alcance mdulo ---------------------Pulse INTRO para continuar
10. Modifique la lnea 21, sustituyendo el estatuto de declaracin Static por Dim. Ejecute el programa nuevamente, y explique qu sucede:
FIN DEL EJERCICIO
54
Lab.04: Comprobacin 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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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, posicin 2") Dim Esca()() As Integer = {Uni1, Uni2} Console.WriteLine(Esca(1)(2)) Console.Write("Presione INTRO") Console.ReadLine() End Sub End Module
55
Ejecucin guiada de Arreglos Module1.vb
4. Construya la solucin (CTRL-MAYS-B). Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) y guarde todos los cambios que ha realizado en la solucin (CTRL-MAYS-S). Inicie la depuracin para comprobar el comportamiento de su programa (F5). 5. En la lnea 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 subndices irn de 0 a 3. 22 49 20 40
En la lnea 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 subndice 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 lnea 12 provoca que se vea en la consola el contenido de cada una de las posiciones en memoria. La lnea 16 declara un arreglo unidimensional de tres posiciones, llamado Uni2, que ser utilizado junto con Uni1 ms adelante. El proceso para el mostrado de contenido se repite con Uni2. Sus valores son los siguientes.
55 66 77
56
6. En la lnea 22 se declara un arreglo multidemensional, llamado Multi, constituido por dos dimensiones. Se asignan valores al momento de la declaracin, que nos indican que el arreglo ser de dos columnas y tres filas. Vea cmo el nmero de series de valores determina el nmero de filas, mientras que el nmero de elementos de cada serie de valores determina el nmero de columnas. 92 44 10 49 20 48
Las lneas de la 23 a la 28 se encargan de mostrar los valores que componen cada fila. Para ello nos apoyamos de la funcin String.Format, que hace una sustitucin directa de parmetros; vea cmo funciona. String.Format(Primer valor {0} segundo valor {1}, 10, 20) Generara como resultado: Primer valor 10 segundo valor 20 Los parmetros se incluyen con base 0, y deber proporcionarse una serie de valores separados por comas despus del String que queremos construir. El primer valor de la serie toma el la primera posicin ({0}), el segundo la segunda ({1}), y as. Los subndices en los arreglos indican la fila y la columna, considerando una base cero. 7. La lnea 32 define un arreglo escalonado, llamado Esca, que almacena los arreglos Uni1 y Uni2.
22 49 20 55 66 77
57
40
La lnea 33 muestra, del segundo arreglo almacenado (subndice 1), el tercer elemento almacenado (subndice 2). Entre los primeros parntesis ir el subndice del arreglo escalonado, es decir, permite seleccionar al arreglo a inspeccionar. En los siguientes parntesis se coloca el subndice (o subndices) del arreglo seleccionado. A diferencia de un arreglo multidimensional, en donde todas las filas tienen igual nmero de columnas, en un arreglo escalonado la forma y dimensiones dependen de los arreglos almacenados. Si todo ocurri como se esperaba, la salida ser la siguiente:
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, posicin 2 77 Presione INTRO
8. a. b. c. d.
Vea el siguiente ejemplo, y coloque las referencias que hacen falta. Utilizando Uni1. 49 = Uni1(1) Utilizando Uni2. 55 = _________________________ Utilizando Multi. 10 = _________________________ Utilizando Esca. 66 = _________________________ FIN DEL EJERCICIO
58
Operadores aritmticos
Quin no conoce los operadores aritmticos? Por formar parte de la educacin bsica difcilmente podramos agregar algo que no sepa con respecto a ellos; quiz la novedad puede ser que expliquemos cmo utiliza los operadores aritmticos el Visual Basic. No obstante lo obvio, para no ser omisos definiremos a los operadores aritmticos como los smbolos que producen, a partir de dos expresiones numricas conocidas, una nueva expresin numrica, como resultado de la aplicacin de un clculo aritmtico entre aquellas. El lenguaje dispone de los siguientes operadores aritmticos bsicos.
+ * / Suma (concatenacin) Resta Multiplicacin Divisin Suma expresiones numricas. Concatena expresiones de tipo String. Representa la diferencia entre dos nmeros o especifica la condicin negativa de uno. Multiplica dos nmeros. Divide un nmero entre otro.

\ Mod ^ Divisin entera Mdulo Exponenciacin Divide un nmero entre otro, dando un resultado necesariamente entero. Divide un nmero entre otro, dando como resultado el residuo. Sirve para elevar un nmero a una determinada potencia; un nmero puede ser negativo si el exponente es un entero.
59
La forma en que se resuelven este tipo de operadores es la siguiente. Resultado = Expresin1 Operador Expresin2 Expresin1 y Expresin2 sern siempre datos numricos. Resultado ser siempre numrico. Operador es el operador aritmtico 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 divisin de un Integer 3, entre 2, no dar un nmero Integer.
N O TA 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 ambigedad del operador +, Visual Basic soporta el uso del smbolo & para concatenacin de expresiones String. Realmente la concatenacin no se considera una operacin aritmtica.
60
Operadores de asignacin
Los operadores de asignacin son los que permiten asignar un valor a una variable o propiedad. El ejemplo clsico 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 expresin vlida para el tipo de dato de Variable.
Expresin
Aunque puede resultar obvio explicarlo, una expresin es un valor, existente o derivado; es valor existente si corresponde a una literal vlida 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 accin de operadores.
61
Vea los ejemplos siguientes de expresiones.

4 A 4 + 5 3 = 2
Existente. Valor numrico 4 Existente. Valor String A Derivado. Valor numrico 9 Derivado. Valor lgico False, pues 3 y 2 no son iguales Derivado. Valor de concatenacin String AB
A & B
Vea estos otros ejemplos, si definimos la siguiente variable.

Dim Edad As Integer = 20
Expresiones que podemos utilizar.

Edad str(Edad) Edad: & Str(Edad)
La variable misma La transformacin de la variable La transformacin de la variable y otras literales
62
Operadores de asignacin incluyente
Son operadores de asignacin incluyente, aquellos que consideran el valor que posee la variable o propiedad a la que se le asigna el valor como primera expresin de una operacin, asignando el resultado de la operacin a la variable misma. Los operadores de asignacin 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 x = x-1 x = x * 4 x = x ^ 2 Es lo mismo que Es lo mismo que Es lo mismo que Es lo mismo que x += 1 x -= 1 x *= 4 x ^= 2
63
Vea los siguientes ejemplos.

Si Var1 vale Y Var2 vale La operacin Hace valga
1000 30 4 3 13 ABCDEF 7
que
Var1
10 10 12 10 10 ABC 10
3 3 3 3 3 DEF 3
var1 ^= var2 var1 *= var2 var1 /= var2 var1 \= var2 var1 += var2 var1 &= var2 var1 -= var2
64
Operadores comparativos
Los operadores comparativos son los que permiten comparar expresiones, una en relacin a la otra, proporcionando un valor de falso (False), verdadero (True), o nulo (Null), dependiendo si la comparacin 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 especficas en donde la afectacin de un valor es importante.
65
La tabla que sigue describe los operadores comparativos que Visual Basic maneja.
Operador
< (Menor que) <= (Menor o igual que) > (Mayor que) >= (Mayor o igual que) = (Igual a) <> (Distinto de)
Verdadero si
expresin1 < expresin2 expresin1 <= expresin2 expresin1 > expresin2 expresin1 >= expresin2 expresin1 = expresin2 expresin1 <> expresin2
Falso si
expresin1 >= expresin2 expresin1 > expresin2 expresin1 <= expresin2 expresin1 < expresin2 expresin1 <> expresin2 expresin1 = expresin2
Nulo si
expresin1 o expresin2 = Null expresin1 o expresin2 = Null expresin1 o expresin2 = Null expresin1 o expresin2 = Null expresin1 o expresin2 = Null expresin1 o expresin2 = Null
La forma en que se resuelven este tipo de operadores es la siguiente. Resultado = Expresin1 Operador Expresin2 Expresin1 y Expresin2 pueden ser cualquier tipo de expresiones comparables entre s. Resultado ser siempre lgico (True, False), o nulo (Null). Operador es el operador utilizado para la comparacin. Algunos ejemplos del uso de estos operadores son.
A = B 1 > 0.5 2 >= 2 S < s
Retorna False Retorna True Retorna True Retorna True
Tome en cuenta que las letras maysculas, para efectos de comparacin, tienen un valor en cdigo ASCII menor a las minsculas, y por tanto, son menores. Adicionalmente, la A es menor que la Z.
66
Consideraciones relativas al cdigo ASCII

El juego de caracteres de 7 bits denominado ASCII (American Standard Code Information Interchange / Cdigo Americano Estndar para Intercambio de Informacin), es ampliamente utilizado para representar letras y smbolos de un teclado estndar de EE.UU. El juego de caracteres ASCII es igual que los primeros 128 caracteres (0127) del juego de caracteres ANSI, utilizado por las mquinas antiguas. Es importante que conozca algunas referencias del cdigo ASCII que pueden serle de utilidad.
Cdigo 8 13 32 64 92 ASCII Representa BackSpace (RETROCESO) Enter (INTRO) SpaceBar (BARRA ESPACIADORA) @ \
Cdigo
ASCII
Representa 0 al 9 A a la Z a a la z , , , , ,
48 al 57 65 al 90 97 al 122 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 numrico un cdigo ASCII, ste aparecer. Para ello es necesario que el teclado numrico 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 representacin simblica de un cdigo ASCII, as como de obtener el cdigo ASCII a partir de una representacin simblica. Las funciones que lo permiten son Chr( ) y Asc( ), respectivamente.
67
Sintaxis.
Chr(CdigoASCII ) Asc(Caracter)
Ejemplos.
Chr( 64 ) @ 64
Asc( @ )
68
Option compare
Uno de los conceptos importantes respecto a la comparacin de datos, especficamente de los datos de tipo cadena (String), es su sensibilidad al reconocimiento de maysculas y minsculas. Se dice que un esquema de comparacin es case-sensitive, cuando una comparacin es sensible a la diferencia entre maysculas y minsculas (A a); se dice que un esquema de comparacin es non case-sensitive, cuando una comparacin no es sensible a la diferencia entre maysculas y minsculas (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 realizarn bajo el esquema non case-sensitive; si se especifica Option Compare Binary, las comparaciones se realizarn bajo el esquema case-sensitive.
Mdulo 2: Elementos del Lenguaje Option Compare
69
debe especificarse al inicio de los programas, antes de cualquier lnea de cdigo. Si se omite la especificacin, el esquema de comparacin ser case-sensitive (Binary).
70
Operadores Is, IsNot y TypeOf
Adems 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 posicin de memoria que otra. La forma en que se resuelve este operador es la siguiente. Resultado = Expresin1 Is Expresin2 Expresin1 y Expresin2 deben ser variables de tipo reference type. Resultado ser siempre lgico (True, False).
Is retornar verdadero (True) si las variables comparadas refieren a la misma posicin 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 posicin que otro. Anteriormente, la tarea se deba realizar combinando los operadores Not e Is, de la siguiente forma.
If Not Objeto1 Is Objeto2 Then WriteLine(Diferentes)
71
Dado que esta expresin 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 posicin de memoria. La lnea de cdigo quedara como sigue.
If Objeto1 IsNot Objeto2 Then WriteLine(Diferentes)
En ocasiones la comparacin 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, tendramos que especificar lo siguiente.
If (TypeOf X Is Integer) Then WriteLine(X es Integer)
72
Operador Like
El operador Like compara dos expresiones String, no en trminos de igualdad, sino en trminos de cumplimiento de un patrn determinado. Este operador es especialmente til si tiene que verificar si una cadena de caracteres compuesta obedece a un formato predefinido. Imagine un cdigo de producto que siempre sea tres letras, un guin, y cuatro nmeros; en ese caso, tiene dos opciones: utilizar Like o desarrollar una rutina que analice caracter por caracter la expresin y sus posiciones. Sobra decir que utilizar Like es mucho ms efectivo. La forma en que se resuelve este operador es la siguiente. Resultado = Expresin1 Like Expresin2 Expresin1 debe ser expresiones String. Expresin2 es un patrn String que se pretende reconocer como existente en Expresin1. Resultado ser siempre lgico (True, False).
Mdulo 2: Elementos del Lenguaje Like
73
retornar verdadero (True) si el patrn a buscar es reconocido dentro del dato String base de la comparacin, y falso (False) en caso de que no se reconozca. El patrn a buscar, llamado patrn nominado, es una literal conformada por caracteres especiales que representan el contenido de caracteres a buscar; a continuacin una tabla que muestra dichos caracteres y su significado.
Caracter de patrn Significado

? * # [lista] [!lista]
Cualquier caracter Varios caracteres o ninguno Cualquier dgito (0-9) Cualquier caracter en la lista Cualquier caracter que no est en la lista
Vea los siguientes ejemplos.

F Like F 24/10/2002 Like ##/##/#### ABC Like AB* MP3 Like [A-Z][A-Z]# MPG Like [A-Z][A-Z]# MP3 Like [A-Z][A-Z]? MPG Like [A-Z][A-Z]? AMERICA Like A*A HP2992 Like [!H]* DP2992 Like [!H]* micorreo@mail.com Like *@*
Retorna True Retorna True Retorna True Retorna True Retorna False Retorna True Retorna True Retorna True Retorna False Retorna True Retorna True
Recomendamos que utilice los patrones para determinar la validez de formatos mixtos de datos, por ejemplo claves de cuatro letras y tres nmeros.
74
Si lo que va a evaluar son formatos ms estndar, como nmeros o fechas, recomendamos otras funciones ms sofisticadas, como IsNumeric() o IsDate().
75
Operadores lgicos
Los operadores lgicos son aquellos que sirven para unir o negar condiciones, produciendo un valor lgico. Los operadores lgicos bsicos son.
niega el resultado de una condicin. Revierte el valor; si la condicin que afecta es True producir False, y viceversa.
Not. And.
cuando de entre dos condiciones, las dos deben ser True para que en su conjunto la expresin 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 expresin sea True. (Al menos una condicin True, retronar True). Xor. cuando entre dos True, pero no las dos.
condiciones, al menos una cumple por
La forma en que se resuelven este tipo de operadores es la siguiente. Resultado = [Expresin1] Operador Expresin2
76
Expresin1 y Expresin2 son expresiones de tipo lgico. En el caso de Not, Expresin1 no se debe poner, ya que el operador acta sobre una sola expresin. Resultado ser siempre lgico (True, False). Cuando una expresin lgica se compone por una sola comparacin, se dice que es una expresin lgica simple, debido a que slo se resolver en un tiempo; si involucra dos o ms comparaciones, o la utilizacin de un operador lgico, se dice que es una expresin lgica compuesta, debido a que la expresin lgica deber resolverse en dos o ms tiempos (se resuelve la comparacin, y luego se resuelve dentro del contexto en que se encuentra). Una expresin lgica compuesta siempre se compone de expresiones lgicas simples, afectadas por operadores lgicos que las obligan a resolverse como una sola expresin lgica. Ejemplos.
Not True Not False Not A = B
Es False, porque es lo contrario a

True.
Es True, porque es lo contrario a

False.
Es True, porque A = B es False, pero negado es True. Es False, porque no todas las condiciones son True. Es True, porque al menos una condicin es True.
A = B And 1 > 0.5
A = B Or 1 > 0.5
En caso de que tenga ms de dos condiciones conjuntas, entra en operacin 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 explicacin basada en la figura 06.01.
77
Figura 06.01
Resolucin de una expresin con mltiples condiciones
Primero se resuelven las condiciones de comparacin. Ya que se resolvieron las condiciones de comparacin, se sigue el orden de izquierda a derecha; la primera condicin de tipo lgico se resuelve; el resultado de sta forma parte de la siguiente condicin, y as hasta terminar. La expresin inicia siendo una expresin lgica compuesta, formada por cuatro expresiones lgicas simples, que con la ayuda de tres operadores lgicos, se ven obligadas a resolverse como una sola expresin lgica que termina con un valor False.
Las condiciones se resuelven como si tuvieran parntesis imaginarios.

( ( (A = B Or 1 > 0.5) And 2 >= 2) And S > s)
En donde las condiciones encerradas en los parntesis de mayor profundidad se resuelven primero. Si usted agrega de manera explcita parntesis 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 resolvera la primera condicin con la segunda (False Or True, se resuelve a True), el resultado se resolvera con la tercera (True And True, retorna True), y el
78
resultado se resolvera con la cuarta (True And False, retorna False). El resultado de lo ltimo que se resolvi fue False. Cmo cambiaramos la condicin, mediante el uso de parntesis, para que el resultado fuera verdadero? A continuacin una solucin.
(S < s OR ( 2 >= 2 AND 1 > 0.5 And A = B))
De esta forma forzamos que en primera instancia se resuelva el parntesis de mayor profundidad, que contiene la segunda, tercera y cuarta expresin (True And True And False, retrona False), el resultado se resuelve con la primera condicin, por ser el parntesis de mayor profundidad que sigue (True Or False, resuelve True). Considere como regla que siempre que abra parntesis los tiene que cerrar. Una inadecuada colocacin de condiciones puede arrojar resultados errneos; le recomendamos que aunque de forma predefinida existe una preferencia, usted determine claramente qu preferencia desea, utilizando parntesis cuando tenga ms de una condicin por resolver.
79
Operadores lgicos de circuito corto
En programacin es comn que para que algo suceda, debe cumplirse ms de una condicin. Uno de los problemas que tena la anterior versin de Visual Basic, es que no era lo suficientemente inteligente para saber que ya no tena caso resolver ciertas condiciones, en el caso de And y Or. Sabemos que en el caso de And, si una expresin lgica es False todo es False; si en una comparacin nos encontramos que la primera expresin lgica es False, qu caso tiene resolver la segunda expresin? Se denominan operadores lgicos de circuito corto (shortcircuiting), aquellos que son lo suficientemente inteligentes como para determinar la necesidad de continuar evaluando condiciones posteriores a las primeras. Bsicamente son dos.
AndAlso. procesa comparaciones lgicas de circuito corto, de tipo And; produce False a la primera expresin False que se encuentra, y concluye con la resolucin de expresiones. OrElse. procesa comparaciones lgicas de circuito corto, de tipo Or; produce True a la primera expresin True que se encuentra, y concluye con la resolucin de expresiones.
80
Tabla de comportamiento de operadores lgicos La siguiente tabla muestra el comportamiento de los operadores lgicos.
Operador Si Expresin1 es
And And And And Or Or Or Or Xor Xor Xor Xor AndAlso AndAlso AndAlso
Y Expresin2 es True False True False True False True False True False True False True False
Resultado True False False False True True True False False True True False True False False
True True False False True True False False True True False False True True False
AndAlso False OrElse OrElse OrElse OrElse
True True False False
Ni siquiera evala Ni siquiera evala Ni siquiera evala Ni siquiera evala

True False
se
se False se True se True

True False
81
Prioridad entre operadores
Cuando hay varias expresiones dentro de una expresin que las engloba, cada parte de la misma se evala 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 expresin 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 ms de una categora (aritmticos, de comparacin y lgicos), se resuelven en este orden.
82

1. 2. 3.
Las expresiones que tienen operadores aritmticos. Las expresiones que tienen operadores de comparacin. Las expresiones que involucran operadores lgicos.
Esto tiene sentido si tomamos en cuenta que la materia prima para los operadores aritmticos son generalmente expresiones numricas o expresiones String, y con ellos se genera una nueva expresin numrica o expresin String. Los operadores de comparacin, por su parte, tienen como materia prima dos expresiones numricas o expresiones String, y con ellos se determina un valor lgico. Por ltimo, los operadores lgicos permiten generar una expresin lgica de dos expresiones lgicas. Los operadores de comparacin tienen la misma prioridad, es decir, se evalan de izquierda a derecha, en el orden en que aparecen. Los operadores se evalan en el siguiente orden de prioridad.
Aritmticos
Exponenciacin (^) Negatividad de expresin () Multiplicacin y divisin (*, /) Divisin de enteros (\) Mdulo aritmtico (Mod) Adicin y substraccin (+, )
Comparacin
Igualdad (=) Desigualdad (<>) Menor que (<) Mayor que (>) Menor o igual que (<=) Mayor o igual que (>=)
83
Lgicos Not And Or Xor
Cuando hay multiplicacin y divisin en la misma expresin, cada operacin se evala a medida que aparece, de izquierda a derecha. Del mismo modo, cuando se presentan adiciones y substracciones en una misma expresin, cada operacin se evala tal como aparecen de izquierda a derecha.
Uso de parntesis para otorgar preferencia de ejecucin

Es posible usar parntesis para saltar el orden de preferencia y forzar que algunas partes de una expresin se evalen antes que otras. Las operaciones entre parntesis se realizarn antes que aquellas que se encuentren fuera. Sin embargo, dentro de los parntesis, la prioridad de los operadores se mantiene segn las reglas. Cuando utilizamos los parntesis para determinar un orden determinado en que se han de resolver las expresiones, hablamos que se est especificando la preferencia de ejecucin explcita. Cuando dejamos que el lenguaje proporcione el orden de izquierda a derecha, atendiendo a la prioridad de los operadores, hablamos de la preferencia de ejecucin automtica. Los programadores profesionales acostumbran el uso de la preferencia de ejecucin explcita, ya que es ms fcil 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 concatenacin de cadenas (&) no es realmente un operador aritmtico, pero en orden de prioridad se encuentra a continuacin de todos los operadores aritmticos y antes que todos los operadores de comparacin. No olvide que por ms larga que parezca una expresin, todos los operadores actan sobre dos expresiones, y de dos en dos, hasta dejar una sola expresin final, que podr ser asignada a una variable o propiedad, o utilizada por algn estatuto o funcin.
84
Ejercicios
Los ejercicios que es necesario realizar para que el conocimiento de este mdulo quede bien comprendido, son los siguientes: 1. Lab.05: Utilizacin general de operadores en Visual Basic 2. Lab.06: Uso de operadores de asignacin incluyente y operadores de circuito corto
85
Lab.05: Utilizacin 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.
1. 2.
Abra la solucin ejercicios. 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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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
86
Ejecucin guiada de Operadores Module1.vb
4. Construya la solucin (CTRL-MAYS-B). Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) y guarde todos los cambios que ha realizado en la solucin (CTRL-MAYS-S). Inicie la depuracin para comprobar el comportamiento de su programa (F5). 5. Los resultados son simples resoluciones de operadores que no requieren explicaciones. Lo nico novedoso es el uso de mtodo 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
87
Lab.06: Uso de operadores de asignacin incluyente y operadores de circuito corto

En este ejercicio se utilizar una aplicacin de consola para comprobar los operadores de asignacin incluyente, as como los operadores de circuito corto. El programa solicita tres nmeros del 1 al 10. A travs de asignacin incluyente se acumularn los valores capturados, y mediante los operadores de circuito corto se har ms eficiente un proceso, detectndose de entre los nmeros capturados alguno que sea primo. Recuerde que un nmero primo es aquel que slo se divide entre 1 y entre s mismo; en el rango de nuestro ejemplo, slo se tienen el 1, 2, 3, y 7. En este ejercicio se utilizar una aplicacin de consola para comprobar la declaracin y uso de variables en un proceso.
1. 2.
Abra la solucin ejercicios. 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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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 Dim Dim Dim N1 As N2 As N3 As Total Integer Integer Integer As Integer = 0
Console.WriteLine("-- Suma de 3 nmeros ---------------") Console.WriteLine("-- Slo capture enteros del 1 al 10") Console.Write("Nmero 1 de 3:") N1 = CInt(Console.ReadLine()) Console.Write("Nmero 2 de 3:") N2 = CInt(Console.ReadLine()) Console.Write("Nmero 3 de 3:") N3 = CInt(Console.ReadLine()) Total += N1 Total += N2 Total += N3
88
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 nmeros es primo") Else Console.WriteLine("Ninguno de los nmeros es primo") End If Console.WriteLine("Total:" & CType(Total, String)) Console.WriteLine("Pulse INTRO para continuar") Console.ReadLine() End Sub End Module
Ejecucin guiada de Primos Module1.vb
4. Construya la solucin (CTRL-MAYS-B). Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) y guarde todos los cambios que ha realizado en la solucin (CTRL-MAYS-S). Inicie la depuracin para comprobar el comportamiento de su programa (F5). 5. El programa declara las variables de trabajo de la lnea 5 a la 8. 6. Es importante que vea cmo estamos haciendo la conversin 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 nmeros 4, 6, 8. La lnea 22 ejecuta una asignacin 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. Despus de la lnea 22, Total vale 0 + 4, es decir 4; despus de la lnea 23, vale 4 + 6, es decir 10, y despus de la lnea 24, vale 10 + 8, es decir 18. Las lneas 26, 27 y 28 realmente son una sola lnea de cdigo. Se estar evaluando si N1 es alguno de los nmeros 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 expresin es True. La misma comparacin se realiza con N2 y con N3. Internamente, con los nmeros que se proporcionaron, se resolveran 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))
89
Que sera lo mismo que:

if (False)
Por tanto, el programa tendra una salida falsa, reportando que ninguno de los nmeros tecleados es primo. Si todo ocurri como se esperaba, la salida ser la siguiente:
-- Suma de 3 nmeros ---------------- Slo capture enteros del 1 al 10 Nmero 1 de 3:4 Nmero 2 de 3:6 Nmero 3 de 3:8 Ninguno de los nmeros es primo Total:18 Pulse INTRO para continuar
8. Ahora ejecute el ensamblado, capturando los nmeros 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 expresin es True. La misma comparacin se realiza con N2 y con N3. Internamente, con los nmeros que se proporcionaron, se resolveran 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 sera lo mismo que:

If (True)
Si se fija, la forma en que se resuelve la condicin es mucho ms simple. Esto es gracias a los operadores de circuito corto. Al resolver la primer condicin, 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 ms condiciones. Si todo ocurri como se esperaba, la salida ser la siguiente:
-- Suma de 3 nmeros ---------------- Slo capture enteros del 1 al 10 Nmero 1 de 3:3 Nmero 2 de 3:6 Nmero 3 de 3:8 Al menos uno de los nmeros es primo Total:17 Pulse INTRO para continuar
FIN DEL EJERCICIO
90
Estatuto If Then Else
Son estructuras de decisin aquellas estructuras del lenguaje que permiten decidir qu lneas de cdigo se han de ejecutar, dependiendo de una condicin determinada. El estatuto condicional (If) ejecutar instrucciones dependiendo del valor de una condicin que deriva en una expresin lgica (dato de tipo Boolean). Como If tiene muchas variantes, examinaremos varias sintaxis que le aplican. He aqu la ms sencilla:
If
ExpresinLgica Then Instruccin
Donde If es el inicio de la estructura de decisin, ExpresinLgica es la expresin de tipo Boolean que determina la ejecucin de Instruccin, que en este caso slo puede constar de una sola instruccin.
91
Ejemplo.
If Precio < CreditoDisponible Then Cargo = Aprobado
Slo en caso de que ExpresinLgica derive en un valor de True, Instruccin ser ejecutada; esta sintaxis de If controla slo la ejecucin en el sentido afirmativo de la condicin. Esta forma de If es muy til para asignar valores a las variables, en caso de que una condicin se cumpla. Un bloque de cdigo es un conjunto de lneas de cdigo que tienen su propio alcance de ejecucin, y que estn siempre delimitadas. Si la ejecucin de un bloque de cdigo depende del cumplimiento de una condicin, es necesario que se delimite la estructura de decisin; el bloque de cdigo ser entonces todo lo que se encuentre entre el estatuto If y el estatuto End If.
If
End If
ExpresinLgica Then Instrucciones
Donde If es el inicio de la estructura de decisin, End If es el fin de la estructura de decisin, y todas las Instrucciones que se encuentran en el inicio y el fin, constituyen el bloque de cdigo que es controlado por la condicional. ExpresinLgica es la expresin de tipo Boolean que determina la ejecucin de Instrucciones, que en este caso puede constar de una sola instruccin o de muchas. Slo en caso de que ExpresinLgica derive en un valor de True, Instrucciones ser ejecutada; esta sintaxis de If controla slo la ejecucin en el sentido afirmativo de la condicin.
92
Ejemplo.
If Precio < CreditoDisponible Then Cargo = Aprobado CreditoDisponible -= Precio End If
es un estatuto de bloque, por lo que si inicia un bloque tendr que concluirlo. Un error muy comn es que se abren estructuras de decisin, pero no se cierran; es de mucha utilidad darle organizacin al cdigo, proporcionando diferente alineacin tabulada a las lneas inicio y fin de la estructura de decisin, y al bloque de cdigo controlado por dicha estructura. Vea nuestros ejemplos: If y End If nunca se encuentran con el mismo margen izquierdo que el bloque de cdigo que controlan; no trate de ser original al respecto, pues con ello slo lograr que la gente se de cuenta que es un programador novato y poco organizado.
If
Es posible que If controle al mismo tiempo la ejecucin en el sentido afirmativo y en el sentido negativo, a travs de la especificacin Else. Vea la sintaxis.
If
Else
ExpresinLgica Then InstruccionesAfirmativo InstruccionesNegativo
End If
Donde If es el inicio de la estructura de decisin, End If es el fin de la estructura de decisin, y todas las Instrucciones que se encuentran entre el inicio y el fin, constituyen el bloque de cdigo controlado por la condicional, pero est dividido en dos bloques de cdigo diferentes, uno que se ejecutar slo si ExpresinLgica es True (InstruccionesAfirmativo), y otro que slo se ejecutar si ExpresinLgica es False (InstruccionesNegativo).
93
Ejemplo.
If Precio < CreditoDisponible Then Cargo = Aprobado CreditoDisponible -= Precio Else Cargo = Denegado End If
ExpresinLgica es la expresin de tipo Boolean que determina ejecucin de InstruccionesAfirmativo o InstruccionesNegativo. Esta sintaxis de If controla la ejecucin en el sentido afirmativo de la condicin, o en el sentido negativo; como podr intuir, siempre se ejecutar algo.
94
Select Case
es una estructura de decisin que permite ejecutar procesos mutuamente excluyentes, en funcin a comparaciones realizadas sobre un mismo valor de referencia.
Select Case
Su sintaxis se encuentra a continuacin:

Select Case ExpresinAEvaluar Case {Condicin | Else} End Select
Instrucciones
Donde ExpresinAEvaluar es una expresin de cualquier tipo, que ser tomada como referencia. Condicin sirve para especificar una condicin relacionada con ExpresinAEvaluar, que en caso de presentarse, motiva la ejecucin de Instrucciones. Se va construyendo un rbol de decisin basado en una ExpresinAEvaluar. Se pueden agregar tantas sentencias Case como se deseen, e incluso las estructuras Select Case se pueden anidar. Si al momento de evaluar Condicin, un determinado valor de ExpresinAEvaluar cumple en dos casos, se ejecutar para la
95
primera que se encuentre. Case Else aplica cuando el valor de ExpresinAEvaluar no cumpla para ninguno de los casos anteriores, dentro de la estructura. Para ver cmo funciona este estatuto, imagnese la siguiente situacin hipottica: Una compaa tiene 35 categoras de empleados; cada categora tiene un ingreso determinado, en donde las categoras de nmero ms alto son las de mayor ingreso por salario, existiendo una relacin directamente proporcional entre categora y sueldo. Se acaba de autorizar un aumento de sueldo general en la compaa, bajo las siguientes polticas: el personal de alto nivel (categora superior a 19) no tendr aumento; las categoras 18, 17 y 14 recibirn el 15% de aumento; de la categora 8 a la 13, recibirn el 10% de aumento, a excepcin de la categora 10, que es la categora ms rezagada con respecto al salario, pues recibir el 25%. Al resto del personal, se le dar un 5% de aumento. Cmo se codificara 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 cmo 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 relacin a la ExpresinAEvaluar (en nuestro ejemplo, Categoria), ya que si no hace uso de dicha expresin, no son consideradas. Usted puede agregar como instruccin la lnea con una condicin Case que se resuelva True, pero que no involucre a Categoria; en ese caso, el cdigo dependiente de dicho Case nunca se ejecutar.
96
For Next
Son estructuras de control, llamadas tambin bucles, aquellos elementos del lenguaje que permiten la ejecucin de una o ms lneas de cdigo de manera repetida. Mediante las estructuras de control se puede repetir la ejecucin de lneas de cdigo.

Un determinado nmero de veces Hasta que una condicin sea verdadera (True) Mientras que una condicin es falsa (False) Una vez por cada elemento de una coleccin
Se analizarn los elementos del lenguaje que nos permiten codificar cada una de estas variantes. repite la ejecucin de un bloque de cdigo un nmero 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 tambin regulares y conocidos.
For Next
Su sintaxis es la siguiente.
Mdulo 2: Elementos del Lenguaje For
97
Variable = ValorInicial To ValorMximo [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. ValorMximo 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 repeticin 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 especificacin Step, se asume Incremento con valor de 1 positivo. Si Incremento es negativo, hablamos de un decremento, en trminos reales. Una instruccin que puede ser til en el caso de utilizar For Next es Exit For, que interrumpe la ejecucin del For como si ya hubiese cumplido todas las repeticiones exigidas.
98
While
ejecuta un bloque de cdigo un tiempo infinito de veces, mientras una condicin al inicio del bloque se cumpla por verdadero (True).
While
La sintaxis es la siguiente.
While ExpresinLgica Instrucciones End While
Ejemplo.
Dim Prueba As Byte = 0 While Prueba < 255 Console.WriteLine(Prueba) Prueba += 1
End While
Donde ExpresinLgica es un valor de tipo Boolean (True/False), casi siempre una comparacin, que de ser verdadera al inicio del ciclo de ejecucin, provoca la ejecucin de Instrucciones. Como recordar, los tipos de datos Byte slo pueden almacenar valores desde 0 a 255; en nuestro ejemplo, While ejecutar un
99
incremento de 1 para la variable Prueba, mientras sea menor a 255. Si dejramos que el ciclo fuera ms all de 255, el programa generara 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 ms tiles de While es el ciclo infinito, en donde ninguna operacin o variable dentro del proceso influye en la condicin que gobierna la estructura. Simple y llanamente, se proporciona el valor de True como ExpresinLgica, y no hay forma que deje de ejecutarse el ciclo.
While True End While
Instrucciones
Ejemplo.
While True Console.WriteLine("Qu nmero 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 algn momento en el proceso para ejecutar Exit While, ya que de otra manera, nunca concluir la ejecucin del programa. En el ejemplo que pusimos, mientras no teclee un 8, el programa seguir pidiendo nmeros.
N O TA Puede ser que su programa tenga un detalle que impida ejecutar Exit While en un ciclo infinito; recuerde que siempre puede detener la ejecucin de un proceso presionando la combinacin de teclas CTRLINTER o ESC.
100
Do Loop
ejecuta un bloque de cdigo un tiempo infinito de veces, hasta que una condicin se cumpla por verdadero (True). Esta instruccin brinda ms flexibilidad que While, en el sentido que se puede controlar la evaluacin 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 ms sencilla que utilizando While.
Do Loop
La sintaxis es la siguiente.
Evaluacin al inicio Do {While/Until} ExpresinLgica Instrucciones Loop Evaluacin al final Do Instrucciones Loop {While/Until} ExpresinLgica
Donde ExpresinLgica es un valor de tipo Boolean (True/False), casi siempre una comparacin. Instrucciones son las instrucciones que se estn gobernando en el bucle.
101
Si se utiliza Do con While (mientras), el ciclo se repite hasta que ExpresinLgica sea falsa. Si se utiliza Do con Until (hasta), el ciclo se repite hasta que la condicin sea verdadera. Slo se puede implementar While o Until, pero no ambas. Tambin tiene que decidir si la evaluacin 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
tiene una sentencia para interrumpir en cualquier momento el proceso: Exit Do.
Do
102
Reglas para el anidado de estructuras
Las estructuras, sean de decisin 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 mdulo, 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; asegrese de cerrar todas las estructuras que abra. Se recomienda programar de tal manera que las estructuras que se abran se cierren lo ms 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 ms rpida que cualquier otro tipo de dato.
103
Los problemas ms comunes relacionados con las estructuras anidadas (y su solucin) son:
No terminar lo que se inicia.

Solucin
If Condicin Then Instrucciones End If
Problema
If Condicin Then Instrucciones
No iniciar lo que se termina.

Solucin
For Variable = 0 to 10 Instrucciones Next Variable
Problema
Instrucciones Next Variable
Utilizar las mismas variables que controlan el proceso.

Solucin
For Variable = 0 to 10 For Variable_1 = 0 to 5 Instrucciones Next Variable_1 Next Variable
Problema
For Variable = 0 to 10 For Variable = 0 to 5 Instrucciones Next Variable Next Variable
No terminar primero la ltima estructura que se inici.

Solucin
For Variable = 0 to 10 If Condicin Then Instrucciones End If Next Variable
Problema
For Variable = 0 to 10 If Condicin Then Instrucciones Next Variable End If
104
Ejercicios
Los ejercicios que es necesario realizar para que el conocimiento de este mdulo quede bien comprendido, son los siguientes: 1. Lab.07: Uso de estructuras de decisin 2. Lab.08: Uso de For Next 3. Lab.09: Identificando errores en estructuras anidadas
105
Lab.07: Uso de estructuras de decisin

En este ejercicio se utilizar una aplicacin de consola para comprobar las estructuras de decisin. Se parte del supuesto que usted le indique al programa cunto cuesta un producto que desea comprar, as como el tipo de membreca que tiene en la tienda donde lo desea comprar. A cada tipo de membreca le aplica un determinado descuento, que ser informado por el programa.
1. 2.
Abra la solucin ejercicios. 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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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("Membresa:") WriteLine("1.- Diamante") WriteLine("2.- Premium") WriteLine("3.- Clsica") Write("Qu membresa 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
106
38 39 40 41 42 43 44
Write("Presione INTRO para continuar") ReadLine() End Sub End Module
Ejecucin guiada de Descuento Module1.vb
4. Construya la solucin (CTRL-MAYS-B). Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) y guarde todos los cambios que ha realizado en la solucin (CTRL-MAYS-S). Inicie la depuracin para comprobar el comportamiento de su programa (F5). 5. Las lneas 1 y 2 hacen de este programa un programa type safe. lneas 10 y 11 se declaran las variables de trabajo. En las
6. Cuando el programa solicite el precio (lneas 13 y 14), proporcione el valor 0. Vea en el cdigo cmo 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 (lnea 14). En la lnea 16 vemos la primera estructura de decisin del programa, que controla la ejecucin del programa en el sentido afirmativo y en el sentido negativo. En el sentido afirmativo, se ejecutar el bloque de cdigo que va de la lnea posterior al inicio de la estructura (lnea 9), hasta la lnea anterior al Else o End If (lnea 17), que dan por concluido el bloque. En el sentido negativo, se ejecutar el bloque de cdigo que va de la lnea posterior al Else (lnea 19), hasta la lnea anterior al End If (lnea36), que da por concluido el bloque. Como se proporcion el valor de cero, la condicin que gobierna la ejecucin del If se cumple en el sentido afirmativo (Precio = 0 es True), y al encontrar el Else, pasa a ejecutar la lnea 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: 0 Nada que calcular Presione INTRO para continuar
7. Ejecute la aplicacin nuevamente. Cuando le solicite el precio, proporcione el valor 2000. Cuando le solicite el tipo de membresa, proporcione el valor 2.
107
Como se proporcion el valor 2000, la condicin que gobierna la ejecucin 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 lnea 24 se recibe el valor 2, que es asignado a FactorDesc; en la lnea 25 se especifica FactorDesc como valor de referencia para las comparaciones de Select Case, que se encuentran en las lneas 26, 28 y 30, y en caso de que no se cumpla ninguna de las anteriores, se ejecuta la lnea 32. Como el valor de FactorDesc es 2 (Is = 2), se procede a ejecutar el bloque de cdigo correspondiente al cumplimiento de esa condicin; en otras palabras, ejecuta la lnea 29; vea cmo se agrega la literal D al valor, para indicarle al programa que el valor es Decimal, ya que de lo contrario podra asumirse otro tipo de dato, y ante la imposibilidad de conversiones cast se generara un error. Podramos haber resuelto tambin el problema utilizando la funcin CDec(). Concluida la ejecucin del bloque de cdigo correspondiente a la condicin que se cumpli, se enva el control del programa a la lnea posterior a la terminacin de la estructura (End Select), es decir, ejecuta la lnea 35 y hacia adelante, que despliegan el precio despus de aplicar el factor de descuento que corresponde al tipo de membresa que seleccionamos. Si todo ocurri como se esperaba, la salida ser la siguiente.
Precio del producto: 2000 Membresa: 1.- Diamante 2.- Premium 3.- Clsica Qu membresa tiene?: 2 Precio para usted: 1680 Presione INTRO para continuar
Si hubiramos especificado un tipo de membresa que no fuera 1, 2, o 3, el programa hubiera ejecutado la lnea 32, que corresponde a la condicin Case Else, es decir, cuando ninguna de las otras condiciones se cumpli. 8. Guarde todos los cambios en su solucin.
FIN DEL EJERCICIO
108
Lab.08: Uso de For Next

En este ejercicio se utilizar una aplicacin de consola para comprobar el funcionamiento de For Next.
1. 2.
Abra la solucin ejercicios. 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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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
109
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
Ejecucin guiada de Repite Module1.vb
4. Construya la solucin (CTRL-MAYS-B). Establezca el nuevo proyecto como proyecto de inicio (StartUp Project) y guarde todos los cambios que ha realizado en la solucin (CTRL-MAYS-S). Inicie la depuracin para comprobar el comportamiento de su programa (F5). 5. En las lneas 10 a la 12 se declaran variables de trabajo que nos ayudarn 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 automtica. b. Todas las dems 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 condicin. d. Las estructuras While se ejecutan mientras la condicin sigue siendo verdadera.
110
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 lneas 25, 32, 39, 46 y 53. En lugar de asignar 0, asigne 10. Se proporciona ese valor porque no es vlido para las condicionales While y Until del programa. Compruebe cmo las estructuras con evaluacin 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
111
Lab.09: Identificando errores en estructuras anidadas

En este ejercicio analizar el cdigo que se proporciona, y explicar cules son los errores que se presentan (si los hay). Si no hay problemas, indquelo 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
112
3)
For i = 1 to 10
x *= i
If x > 30 Then
Console.WriteLine(Lmite de treinta o ms)

Exit For Next i End If
FIN DEL EJERCICIO
113
Procedimientos
Los procedimientos son bloques de cdigo nominados que pueden ser mandados llamar a ejecucin. Cuando se tiene una tarea grande de programacin se puede decidir utilizar procedimientos para dividirla en otras tareas ms pequeas; la realizacin de todas las pequeas tareas particulares implican la ejecucin de la tarea general que conforman. Los procedimientos tienen como objetivo principal crear bloques de cdigo 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 cdigo delimitado por la orden Sub y End Sub; la sintaxis es la siguiente:
Sub NombreProcedimiento( ) Instrucciones End Sub
114
Donde NombreProcedimiento es el nombre que identifica al procedimiento; Instrucciones es el bloque de cdigo que ser llamado a ejecucin a travs de NombreProcedimiento. Es posible que se anteponga al Sub la accesibilidad, como Public, Friend, etctera (para mayor informacin, vea el mdulo 8), que determinarn la capacidad que tendr el procedimiento para ser reutilizado. Sub y End Sub son las lneas que delimitan el bloque de cdigo del procedimiento. La lnea Sub es la llamada lnea 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 ejecucin un procedimiento o funcin desde otro procedimiento o funcin, sin problemas.
N O TA 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 ejecucin un procedimiento

La forma de mandar llamar a ejecutar un procedimiento es muy sencilla, pues slo se coloca el nombre del procedimiento, seguido de parntesis. Vea la sintaxis:
NombreProcedimiento()
Donde NombreProcedimiento es el nombre del procedimiento que ser llamado a ejecutar. EVOLUCIN Anteriormente los procedimientos se mandaban llamar a ejecucin a travs de la orden Call, y el uso de parntesis era opcional. Eso ya no es posible en .NET; Call ya no existe, y es necesario colocar los parntesis despus del nombre del procedimiento, en todos los casos.
115
Argumentos
Los argumentos, tambin llamados parmetros, 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 parntesis en la lnea de encabezado del procedimiento. Se conocen como argumentos implcitos aquellos que son declarados por Visual Basic.NET de manera automtica; en la declaracin de este tipo de argumentos el programador no participa ms que como espectador y usuario.
116
Valores de retorno
Los valores de retorno son aquellos valores que un procedimiento puede proporcionar como resultado de su ejecucin. 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.
117
Codificacin de procedimientos
A continuacin veremos cmo 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:
Sub Despliega() Console.WriteLine(Prueba de procedimientos) End Sub
Ejemplo de ejecucin:
Despliega()
118
Si el procedimiento utiliza argumentos, estos debern declararse entre los parntesis que aparecen despus del nombre del procedimiento; pueden declararse tantos argumentos como se deseen, separndose por comas. Cada uno de ellos deber especificar si se trata de una expresin (ByVal) o una referencia (ByRef) a un objeto, seguido por el nombre del argumento, y la correspondiente declaracin de tipo:
Sub NombreProcedimiento(Argumento1 [, Argumento2, ...]) Instrucciones que pueden utilizar los Argumentos End Sub
Donde cada Argumento es una declaracin con la siguiente sintaxis:

[ByVal | ByRef] NombreArgumento As [Tipo]
Ejemplo:
Sub Despliega(ByVal Mensaje As String) Console.WriteLine(Mensaje) End Sub
Despliega(Programa de prueba de procedimientos)
119
Si el procedimiento retorna valores, se trata de una funcin; a diferencia de los procedimientos, en lugar de Sub, debe utilizarse la palabra reservada Function. Para retornar el valor de una funcin, 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:
Function DiaDeHoy() As String Return Hoy es & Now.ToString() End Function
Console.WriteLine(DiaDeHoy())
120
El mximo grado de complejidad para un procedimiento es la funcin 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:
Function Dia(ByVal FechaDada As Date) As String Return La fecha proporcionada es & _ FechaDada.ToString() End Function
Console.WriteLine(Dia(Now))
Los argumentos de una funcin determinada no necesariamente deben proporcionarse en el orden en que son declarados al momento de su codificacin; si se desea pasar los argumentos en un orden distinto al que tienen por definicin, es necesario utilizar los nombres especficos dados a los argumentos. Vea el siguiente ejemplo, que muestra cmo nominar los argumentos al momento de utilizar la funcin:
121
Console.WriteLine(Dia(FechaDada:=Now)) N O TA Es importante saber que los procedimientos y funciones no se pueden anidar; dentro de un procedimiento o funcin no se puede declarar otro procedimiento o funcin.
122
Argumentos opcionales y valores por omisin
Es posible que los argumentos no sean obligatorios en todos los casos, y tambin es posible que queramos que, en caso de omitir el valor de un argumento, ste asuma un valor por omisin. Para manejar esas situaciones, se hace el uso de Optional, as como de la asignacin al momento de declarar los argumentos. Suponga que tiene una funcin, llamada CalcVenta(), que admite dos argumentos PrecioUnitario y Cantidad, y que a partir de ah calcula el monto total de una venta (PrecioUnitario * Cantidad).
123
Si nuestra funcin estuviera definida de la siguiente forma, sera necesario proporcionar los dos argumentos siempre, o de lo contrario generaramos una excepcin:
Function CalcVenta(ByVal PrecioUnitario As Integer, _ ByVal Cantidad As Integer) As Double Return PrecioUnitario * Cantidad End Function
Si sabemos que cuando no se especifica la cantidad, quiere decir que es 1, podramos hacer lo siguiente:
Function CalcVenta(ByVal PrecioUnitario As Integer, _ Optional ByVal Cantidad As Integer = 1) As Double Return PrecioUnitario * Cantidad End Function
Podramos ejecutar la funcin de la siguiente forma:

Console.WriteLine(Precio(10))
El segundo argumento, aunque se omiti, se asumira con valor de 1, y la operacin no generara excepcin. Qu pasara si los dos argumentos fueran opcionales, y deseamos omitir el primero y dar valor al segundo?
Console.WriteLine(Precio(10))
Con la lnea anterior, Visual Basic.NET entendera 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 ) )
124
Ejercicios
Los ejercicios que es necesario realizar para que el conocimiento de este mdulo quede bien comprendido, son los siguientes: 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
125
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 ejecucin. Para ste y otros ejemplos del mdulo, proponemos el siguiente ejemplo hipottico: Una tienda con venta a crdito tiene una promocin, en donde usted compra hoy y la tienda no le comienza a cobrar sino transcurridos 90 das. Su programa debe calcular la fecha en que el cliente debe pagar, contando 90 das a partir de la fecha actual. Como la tienda cierra los domingos, si la fecha de pago (hoy + 90 das) es domingo, deber ampliarse el plazo en un da, con el fin del que el pago pueda ser realizado el da lunes. Tome en cuenta que: con Visual Basic.NET siempre podremos saber qu da es hoy, utilizando Now; podremos incrementar los das utilizando la funcin DateAdd, y validar el da de que se trata con la funcin DatePart.
1. 2.
Abra la solucin ejercicios. 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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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 Module SinArgumentos Dim FechaPago As Date Sub Main() Console.WriteLine("Hoy:" & Now.ToShortDateString) DeterminaFechaPago() Console.WriteLine("Fecha de pago:" & _ FechaPago.ToShortDateString) EsperaIntro() End Sub Sub DeterminaFechaPago() FechaPago = DateAdd(DateInterval.Day, 90, Now) If DatePart(DateInterval.Weekday, FechaPago) = 1 Then FechaPago = DateAdd(DateInterval.Day, 1, FechaPago) End If End Sub Sub EsperaIntro() Console.WriteLine("Pulse INTRO para continuar") Console.ReadLine() End Sub End Module
126
Ejecucin guiada de SinArgumentos.vb 3. Ejecute el programa presionando F5. La lnea 9 se encarga de desplegar la fecha del sistema. Para que el programa trabaje como debe ser, es necesario que almacene en algn lado la fecha calculada; para ello, se declara una variable llamada FechaPago en la lnea 6. El alcance con el que est declarada la variable (disponible en todo el mdulo) ser suficiente para que su valor pueda ser utilizado dentro y fuera de nuestro procedimiento. La lnea 10 manda llamar a ejecucin el procedimiento DeterminaFechaPago(), que calcular la fecha en que el cliente comenzar a pagar. La ejecucin del programa se traslada automticamente hasta encontrar una lnea de encabezado de procedimiento que declare a un bloque de cdigo bajo el nombre de FechaPago (lnea 15), y por tanto se procede a ejecutar el bloque de cdigo compuesto por las lneas 16 a la 19, es decir, una despus del Sub, y una antes del End Sub. La lnea 16 asigna a la variable FechaPago el resultado de sumarle a la fecha del sistema la cantidad de 90 das; las lneas 17, 18, y 19 se encargan de validar que si el da calculado es domingo (internamente, el da de la semana nmero 1), se agregar un da ms, a fin de que el da de pago sea un da hbil (lunes). El programa se encuentra el fin del procedimiento, y por tal motivo regresa el control de la ejecucin del programa a la lnea siguiente a aquella que mando llamar a ejecucin el procedimiento (lnea 11). La lnea 11 se encarga de desplegar, en formato de fecha corta, el valor que haya sido calculado, y que se encuentra en FechaPago. La lnea 13 se encarga de llamar a ejecucin 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 caracterstico: toda la comunicacin de valores con el resto del programa, sean datos de entrada o de salida, son manejados a travs de variables de memoria con alcance suficiente como para estar disponibles dentro de los procedimientos en cuestin. Como no declaran argumentos ni valores de retorno son simples. Su aparente simplicidad es una limitacin, ya que todos los programas que deseen hacer uso del procedimiento debern 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 ejecucin deber declarar necesariamente una variable que se llame FechaPago, de tipo Date.
127
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
128
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 ejecucin. Utilizaremos el mismo caso hipottico del ejercicio anterior, con una pequea variante: el cmputo de los 90 das no es a partir de la fecha de hoy, sino de una fecha cualquiera, que nosotros le proporcionaremos al programa.
1. 2.
Abra la solucin ejercicios. 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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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 Module ConArgumentos Dim FechaPago As Date Sub Main() Console.WriteLine("Hoy:" & Now.ToShortDateString) DeterminaFechaPago(Now) Console.WriteLine("Fecha de pago:" & _ FechaPago.ToShortDateString) EsperaIntro() End Sub Sub DeterminaFechaPago(ByVal FechaBase As Date) FechaPago = DateAdd(DateInterval.Day, 90, FechaBase) If DatePart(DateInterval.Weekday, FechaPago) = 1 Then FechaPago = DateAdd(DateInterval.Day, 1, FechaBase) End If End Sub Sub EsperaIntro() Console.WriteLine("Pulse INTRO para continuar") Console.ReadLine() End Sub End Module
Ejecucin guiada de ConArgumentos.vb 3. Ejecute el programa presionando F5. La lnea 9 se encarga de desplegar la fecha del sistema. Para que el programa trabaje como debe ser, es necesario que almacene en algn lado la fecha calculada; para ello, se declara una variable llamada FechaPago en la lnea 6. El alcance con el que est declarada la variable (disponible en todo el mdulo) ser suficiente
129
para que su valor pueda ser utilizado dentro y fuera de nuestro procedimiento. La lnea 10 manda llamar a ejecucin el procedimiento DeterminaFechaPago(), proporcionando como argumento el valor de la fecha del sistema (Now); pudo haber sido cualquier fecha, y el programa calculara la fecha de pago a partir de la misma. La ejecucin del programa se traslada automticamente hasta encontrar una lnea de encabezado de procedimiento que declare a un bloque de cdigo bajo el nombre de FechaPago (lnea 15). En la declaracin del procedimiento, se especifica que dicho procedimiento espera que el programa que lo manda llamar a ejecucin le proporcione un valor (ByVal) de tipo fecha (Date). Se procede a ejecutar el bloque de cdigo compuesto por las lneas 16 a la 19, es decir, una despus del Sub, y una antes del End Sub. La lnea 16 asigna a la variable FechaPago el resultado de sumarle a la fecha que proporcionamos al procedimiento la cantidad de 90 das; las lneas 17, 18, y 19 se encargan de validar que si el da calculado es domingo (internamente, el da de la semana nmero 1), se agregar un da ms, a fin de que el da de pago sea un da hbil (lunes). El programa se encuentra el fin del procedimiento, y por tal motivo regresa el control de la ejecucin del programa a la lnea siguiente a aquella que mando llamar a ejecucin el procedimiento (lnea 11). La lnea 11 se encarga de desplegar, en formato de fecha corta, el valor que haya sido calculado, y que se encuentra en FechaPago. La lnea 13 se encarga de llamar a ejecucin 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. Este programa sigue teniendo muchas de las deficiencias propias del procedimiento que no utiliza argumentos y no retorna valores. Slo 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. 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):
FIN DEL EJERCICIO
130
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 ejecucin. Utilizaremos el mismo caso hipottico del ejercicio anterior, con una pequea variante: se prohbe utilizar la variable FechaPago, que venamos utilizando como apoyo para la salida del procedimiento.
1. 2.
Abra la solucin ejercicios. 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 opcin Add to Solution, a efecto de que se agregue a la solucin llamada Ejercicios.
Codificacin 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 Module ConArgumentosFun Sub Main() 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() End Sub End Module
131
Ejecucin guiada de ConArgumentosFun.vb 1. Ejecute el programa presionando F5. La lnea 7 se encarga de desplegar la fecha del sistema. La lnea 8 manda llamar a ejecucin la funcin DeterminaFechaPago(), proporcionando como argumento el valor de la fecha del sistema; pudo haber sido cualquier fecha, y el programa calculara la fecha de pago a partir de la misma. La funcin es utilizada como si fuera una expresin String debido a que para el sistema no representa una funcin, sino lo que retorna: una expresin String. La ejecucin del programa se traslada automticamente hasta encontrar una lnea de encabezado de procedimiento que declare a un bloque de cdigo bajo el nombre de FechaPago (lnea 11). En la declaracin del procedimiento, se especifica que dicho procedimiento espera que el programa que lo manda llamar a ejecucin 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 cdigo compuesto por las lneas 12 a la 16, es decir, una despus del Function, y una antes del End Function. La lnea 12 asigna al argumento FechaBase el resultado de sumarle a la fecha que proporcionamos al procedimiento la cantidad de 90 das; las lneas 13, 14, y 15 se encargan de validar que si el da calculado es domingo (internamente, el da de la semana nmero 1), se agregar un da ms, a fin de que el da de pago sea un da hbil (lunes). El programa se encuentra el fin del procedimiento, representado por la accin de que la funcin retorn el valor. La misma lnea 8 considera el valor retronado por la funcin para desplegar la fecha calculada. El control de la ejecucin del programa contina a la lnea siguiente a aquella que mando llamar a ejecucin el procedimiento (lnea 9). La lnea 9 se encarga de llamar a ejecucin 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. Esta funcin es totalmente flexible, ya que no depende de ninguna variable externa para funcionar, y para el compilador, la funcin es una expresin String. Esta funcin podra ser reutilizada prcticamente por cualquier programa, slo hay que respetar los argumentos que requiere, y el tipo de valor que retorna.
132
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):
FIN DEL EJERCICIO

Aprenda Custom Corseware - Visual Basic 2008.demo

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Aprenda Custom Corseware - Visual Basic 2008.demo

Загружено:

Авторское право:

Доступные форматы

Aprenda Custom CourseWare

Microsoft Visual Basic Edicin 2008

MXICO WWW.APRENDA.MX 01-800-APRENDA

Tcnicas de desarrollo usando Visual Studio 2008

2 Programacin en Visual Basic 2008 Edition

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

4 Programacin en Visual Basic 2008 Edition

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

Trabajo colaborativo recomendado en .NET

6 Programacin en Visual Basic 2008 Edition

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

Creando aplicaciones en Visual Studio

8 Programacin en Visual Basic 2008 Edition

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

10 Programacin en Visual Basic 2008 Edition

Elementos de sintaxis de Visual Basic

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

12 Programacin en Visual Basic 2008 Edition

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

Lab.01: Creando una aplicacin en Visual Studio 2008.

Abriendo Visual Studio

14 Programacin en Visual Basic 2008 Edition

Creando una solucin

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

16 Programacin en Visual Basic 2008 Edition

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

18 Programacin en Visual Basic 2008 Edition

8. En caso de dudas respecto a esta prctica, revise el clip 3502.01.02.wmv.

Herramientas de Text Editor

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

20 Programacin en Visual Basic 2008 Edition

Intellisense y deteccin dinmica de errores

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

22 Programacin en Visual Basic 2008 Edition

Mdulo 1: Tcnicas de desarrollo usando Visual Studio 2008

Modificando cdigo usando Text Editor

24 Programacin en Visual Basic 2008 Edition

Elementos del lenguaje

Mdulo 2: Elementos del Lenguaje

Programacin en Visual Basic 2008 Edition

Mdulo 2: Elementos del Lenguaje

Programacin en Visual Basic 2008 Edition

Mdulo 2: Elementos del Lenguaje

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

Programacin en Visual Basic 2008 Edition

Al nombrar interfaces. Al nombrar espacios de nombres. Al nombrar mtodos y propiedades.

Mdulo 2: Elementos del Lenguaje

Programacin en Visual Basic 2008 Edition

Mdulo 2: Elementos del Lenguaje

Programacin en Visual Basic 2008 Edition

Visual Basic soporta los siguientes tipos de datos intrnsecos:

De 0 a 255 (sin signo)

De Enero 1, 0001 a Diciembre 31, 9999

System.Int32 (estructura) System.Int64 (estructura) System.Int16 (estructura) System.Single (estructura)

De -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807 De -32,768 a 32,767

Mdulo 2: Elementos del Lenguaje

Algunas recomendaciones que hacemos son las siguientes:

Programacin en Visual Basic 2008 Edition

Conversin implcita (Casting)

Mdulo 2: Elementos del Lenguaje

Programacin en Visual Basic 2008 Edition

Conversin por mtodo

Mdulo 2: Elementos del Lenguaje