Visual Basic Basico

VisualBasicbsico

VisualBasicbsicoCarmenFernndez

STARBOOK

VisualBasicbsicoCarmenFernndez.DelaedicinStarBook2009MARCASCOMERCIALES.Lasdesignacionesutilizadasporlasempresasparadistinguirsusproductossuelensermarcasregistradas.StarBookha intentadoa lo largodeeste librodistinguir lasmarcascomercialesde lostrminosdescriptivos,siguiendoelestiloqueutilizael fabricante,sin intencinde infringir lamarcaysloenbeneficiodelpropietariode lamisma.Losdatosde losejemplosypantallassonficticiosanoserqueseespecifiquelocontrario.StarBookesmarcacomercialregistrada.Sehapuestoelmximoempeoenofreceral lectoruna informacincompletayprecisa.Sinembargo, StarBook Editorial no asume ninguna responsabilidad derivada de su uso ni tampoco decualquier violacin de patentes ni otros derechos de terceras partes que pudieran ocurrir. Estapublicacintieneporobjetoproporcionarunosconocimientosprecisosyacreditadossobreeltematratado.Suventanosuponeparaeleditorninguna formadeasistencia legal,administrativaodeningnotrotipo.Encasodeprecisarseasesoralegaluotraformadeayudaexperta,debenbuscarselosserviciosdeunprofesionalcompetente.Reservadostodoslosderechosdepublicacinencualquieridioma.Segn lodispuestoenelCdigoPenalvigenteningunapartedeeste libropuedeserreproducida,grabadaen sistemadealmacenamientoo transmitidaen formaalgunanipor cualquierprocedimiento, ya sea electrnico,mecnico, reprogrfico,magntico o cualquier otro sin autorizacinpreviayporescritodeStarBook;sucontenidoestprotegidoporlaLeyvigentequeestablecepenasdeprisiny/omultasaquienes,intencionadamente,reprodujerenoplagiaren,entodooenparte,unaobraliteraria,artsticaocientfica.EditadoporStarBookEditorialCalleJarama,3A,PolgonoIndustrialIgarsa28860PARACUELLOSDEJARAMA,MadridTelfono:916584282Fax:(+34)916581698Correoelectrnico:[email protected]:ebooks.rama.com,www.starbook.esISBN:9788499644639DepsitoLegal:M10282008Autoedicin:CarmenFernndez

Laleyprohbefotocopiarestelibro

A mi familia.

CONTENIDO

INTRODUCCIN ............................................................................... 11Bibliografa .................................................................................... 12Agradecimientos ........................................................................... 12

ESCRIBIR UN PROGRAMA ............................................................. 131.1 QU ES UN PROGRAMA ....................................................... 131.2 REALIZAR UN PROGRAMA ................................................... 14

1.2.1 Aplicacin de consola ....................................................... 151.2.1.1 Qu hace este programa? ................................................ 17

1.3 EJEMPLO ................................................................................ 18

INTERFACES GRFICAS ................................................................ 212.1 PROGRAMANDO EN WINDOWS .......................................... 222.2 APLICACIN WINDOWS ........................................................ 24

2.2.1 Crear un nuevo proyecto .................................................. 242.2.2 El formulario ...................................................................... 262.2.3 Dibujar los controles ......................................................... 272.2.4 Borrar un control ............................................................... 302.2.5 Propiedades de los objetos .............................................. 312.2.6 Escribir los controladores de eventos .............................. 33

8VISUALBASICBSICO STARBOOK

LENGUAJE BASIC ........................................................................... 373.1 TIPOS ...................................................................................... 37

3.1.1 Clases ............................................................................... 393.2 LITERALES ............................................................................. 403.3 IDENTIFICADORES ................................................................ 413.4 DECLARACIN DE CONSTANTES SIMBLICAS ................ 413.5 VARIABLES ............................................................................. 423.6 CONVERSIN ENTRE TIPOS ............................................... 433.7 OPERADORES ....................................................................... 45

3.7.1 Operadores aritmticos .................................................... 453.7.2 Operadores de relacin .................................................... 463.7.3 Operadores lgicos .......................................................... 463.7.4 Operadores de asignacin ............................................... 473.7.5 Operador de concatenacin ............................................. 48

3.8 PRIORIDAD Y ORDEN DE EVALUACIN ............................. 483.9 ESTRUCTURA DE UN PROGRAMA ...................................... 49

ENTRADA Y SALIDA ESTNDAR .................................................. 514.1 FLUJOS DE ENTRADA ........................................................... 514.2 FLUJOS DE SALIDA ............................................................... 534.3 SALIDA CON FORMATO ........................................................ 55

SENTENCIAS DE CONTROL ........................................................... 595.1 SENTENCIA DE ASIGNACIN .............................................. 595.2 SENTENCIAS DE CONTROL ................................................. 605.3 IF ... THEN ... ELSE ... ............................................................ 615.4 SELECT CASE ........................................................................ 635.5 WHILE ..................................................................................... 645.6 DO ... LOOP ............................................................................ 655.7 FOR ... NEXT ........................................................................... 665.8 FOR EACH ... NEXT................................................................ 675.9 TRY ... CATCH ........................................................................ 68

STARBOOK CONTENIDO9

PROCEDIMIENTOS .......................................................................... 716.1 DEFINICIN ............................................................................ 736.2 INVOCAR A PROCEDIMIENTOS EN OTROS MDULOS .... 766.3 PROCEDIMIENTO MAIN ........................................................ 766.4 PASANDO ARGUMENTOS A LOS PROCEDIMIENTOS ....... 776.5 NMERO INDEFINIDO DE ARGUMENTOS .......................... 786.6 PROCEDIMIENTOS RECURSIVOS ....................................... 796.7 MTODOS MATEMTICOS ................................................... 796.8 TIPOS PRIMITIVOS Y SUS MTODOS ................................. 816.9 NMEROS ALEATORIOS ...................................................... 826.10 EJEMPLO 1 ........................................................................... 836.11 EJEMPLO 2 ........................................................................... 846.12 EJEMPLO 3 ........................................................................... 85

MATRICES Y ESTRUCTURAS ........................................................ 917.1 MATRICES .............................................................................. 91

7.1.1 Declarar una matriz .......................................................... 917.1.2 Crear una matriz ............................................................... 927.1.3 Iniciar una matriz .............................................................. 937.1.4 Acceder a los elementos de una matriz ............................. 947.1.5 Ejemplo 1 .......................................................................... 957.1.6 Matrices multidimensionales ............................................ 967.1.7 Ejemplo 2 .......................................................................... 977.1.8 Argumentos que son matrices .......................................... 997.1.9 Ejemplo 3 .......................................................................... 99

7.2 EL TIPO ARRAY .................................................................... 1017.3 EL TIPO STRING .................................................................. 102

7.3.1 Matrices de cadenas de caracteres ................................ 1037.4 ESTRUCTURAS .................................................................... 105

7.4.1 Ejemplo 4 ........................................................................ 108


FLUJOS ........................................................................................... 1118.1 ESCRIBIR Y LEER CARACTERES ...................................... 1128.2 ESCRIBIR Y LEER DATOS DE CUALQUIER TIPO ............. 1168.3 ACCESO SECUENCIAL ....................................................... 120

8.3.1 Ejemplo 1 ........................................................................ 1218.3.2 Ejemplo 2 ........................................................................ 123

CONTROLES MS COMUNES ...................................................... 1279.1 ETIQUETAS, CAJAS DE TEXTO Y BOTONES ................... 1289.2 CONTROLES DE OPCIN Y BARRAS DE DESPLAZAMIENTO 1349.3 LISTAS .................................................................................. 138

MENS ............................................................................................ 14310.1 DISEO DE UNA BARRA DE MENS ................................ 14410.2 EJEMPLO 1 ......................................................................... 145

NDICE ALFABTICO .................................................................... 155

CD ................................................................................................... 161

INTRODUCCIN

Visual Basic.NET es hoy el entorno de desarrollo ms popular del mun-do. Es el sueo del programador de aplicaciones. Es un producto con una interfaz grfica de usuario para crear aplicaciones para Windows basado en el lenguaje Basic, en la biblioteca .NET y en la programacin orientada a objetos. Cuntas veces trabajando con Windows nos hemos preguntado: cmo hara yo de una forma sencilla una interfaz grfica para mi aplica-cin, similar a esas ventanas de Windows? Hoy tenemos la respuesta, con Visual Basic.

Desde que Microsoft liber Visual Basic 1.0 en 1991 han tenido lugar muchos cambios. Visual Basic 1.0 revolucion la forma de desarrollar soft-ware para Windows; desmitific el proceso de desarrollo de aplicaciones con interfaz grfica de usuario y abri este tipo de programacin a las ma-sas. En sus posteriores versiones, Visual Basic ha continuado proporcio-nando nuevas y nuevas caractersticas que facilitaron la creacin de aplicaciones para Windows cada vez ms potentes. Ahora disponemos de la versin Visual Basic.NET.

Este libro se ha escrito con la intencin de que un principiante pueda aprender de una forma sencilla a programar con el lenguaje Basic, utilizando la potencia de Visual Basic. Los diez captulos en que se ha estructurado el libro han sido expuestos precisamente pensando en lo dicho antes. Van presentando el lenguaje de una forma natural, empezando por lo ms senci-llo, exponiendo cada tema a su tiempo. En definitiva, el libro presenta una metodologa para aprender poco a poco sin apenas encontrar dificultades.


Todos los captulos van documentados con varios ejemplos resueltos que le ayudarn a completar su formacin.

Cuando finalice con este libro, no habr hecho ms que introducirse en el desarrollo de aplicaciones con interfaz grfica, esto es, en el desarrollo de aplicaciones para Windows. Si quiere seguir profundizando en estos temas y ver otros muchos nuevos, puede echar una ojeada a la bibliografa indica-da a continuacin, utilizada para confeccionar este libro.

BIBLIOGRAFA Microsoft Visual Basic .NET. Curso de programacin. Autor: Fco. Javier Ceballos Sierra (http://www.fjceballos.es/) Editorial: RA-MA (http://www.ra-ma.es/) Alfaomega (http://alfaomega.internetworks.com.mx/)

Enciclopedia de Microsoft Visual Basic Autor: Fco. Javier Ceballos Sierra (http://www.fjceballos.es/) Editorial: RA-MA (http://www.ra-ma.es/) Alfaomega (http://alfaomega.internetworks.com.mx/)

AGRADECIMIENTOS En especial, quiero expresar mi agradecimiento a Patricia Rico Berto,

profesora de educacin primaria, por su colaboracin en la revisin de este libro. Tambin, deseo expresar mi agradecimiento a Microsoft y a los crea-dores de SharpDevelop por poner a mi disposicin, en particular, y de todos los lectores, en general, el SDK y los entornos de desarrollo integrados que el estudio de esta obra requiere.

1Captulo1

ESCRIBIR UN PROGRAMA

En este captulo aprender lo que es un programa, cmo escribirlo utili-zando el lenguaje Visual Basic (as denominamos al lenguaje Basic ms la biblioteca .NET) y qu hacer para que el ordenador lo ejecute y muestre los resultados perseguidos.

1.1 QU ES UN PROGRAMA Probablemente alguna vez haya utilizado un ordenador para escribir un

documento o para divertirse con algn juego. Recuerde que en el caso de escribir un documento, primero tuvo que poner en marcha un procesador de textos, y que si quiso divertirse con un juego, lo primero que tuvo que hacer fue poner en marcha el juego. Tanto el procesador de textos como el juego son programas de ordenador.

Poner un programa en marcha es sinnimo de ejecutarlo. Cuando eje-cutamos un programa, nosotros slo vemos los resultados que produce (el procesador de textos muestra sobre la pantalla el texto que escribimos; el juego visualiza sobre la pantalla las imgenes que se van sucediendo) pero no vemos el guin seguido por el ordenador para conseguir esos resultados. Ese guin es el programa.

Ahora, si nosotros escribimos un programa, entonces s que sabemos cmo trabaja y por qu trabaja de esa forma. Esto es una manera muy dife-


rente y curiosa de ver un programa de ordenador, lo cual no tiene nada que ver con la experiencia adquirida en la ejecucin de distintos programas.

Ahora, piense en un juego cualquiera. La pregunta es: qu hacemos si queremos ensear a otra persona a jugar? Lgicamente le explicamos lo que debe hacer, esto es, los pasos que tiene que seguir. Dicho de otra for-ma, le damos instrucciones de cmo debe actuar. Esto es lo que hace un programa de ordenador. Un programa no es nada ms que una serie de instrucciones dadas al ordenador en un lenguaje entendido por l, para decirle exactamente lo que queremos que haga. Si el ordenador no entiende alguna instruccin, lo comunicar generalmente mediante mensajes visuali-zados en la pantalla.

1.2 REALIZAR UN PROGRAMA En este apartado se van a exponer los pasos a seguir en la realizacin

de un programa, por medio de un ejemplo.

La siguiente figura muestra de forma esquemtica lo que un usuario de Visual Basic necesita y debe hacer para desarrollar un programa.

Evidentemente, para poder escribir programas con Visual Basic, se ne-cesita un entorno de desarrollo.

Entornos de desarrollo integrados (EDI) para Visual Basic hay varios. Por ejemplo: Microsoft Visual Basic Express Edition o SharpDevelop que puede descargar de Internet desde las direcciones:

http://www.microsoft.com/ http://www.icsharpcode.net/OpenSource/SD/Download

Ambos EDI funcionan de forma muy parecida. Para realizar los ejem-plos de este libro vamos a elegir SharpDevelop 2.2. Su instalacin requiere que tenga instalado previamente .NET Framework 2.0 SDK que puede des-

1. Editar el programa 2. Compilarlo 3. Ejecutarlo 4. Depurarlo

Entorno de desarrollo de Visual Basic (.NET Framework SDK)

STARBOOK CAPTULO1.ESCRIBIRUNPROGRAMA15

cargar desde la misma pgina Web de SharpDevelop; por lo tanto, si an no tiene instalado este software, instlelo y despus instale SharpDevelop; en otro caso, proceda a instalar SharpDevelop directamente. En la siguiente figura se puede observar el aspecto de este entorno de desarrollo integrado:

Empecemos con la creacin de un programa sencillo: el clsico ejemplo de mostrar un mensaje de saludo.

Este sencillo programa lo realizaremos desde dos puntos de vista: me-diante una aplicacin de consola y mediante una aplicacin que muestre una interfaz grfica; este ltimo tema lo veremos en el captulo 2.

1.2.1 Aplicacin de consola Para editar y ejecutar el programa indicado anteriormente, que deno-

minaremos HolaMundo, utilizando una aplicacin de consola, los pasos a seguir se indican a continuacin:

1. Suponiendo que ya est visualizado el entorno de desarrollo, aadimos un nuevo proyecto Visual Basic.NET (Archivo, Nuevo, Solucin). Des-


pus elegimos la categora de proyecto VBNet > Aplicaciones de Win-dows, la plantilla Aplicacin de Consola, especificamos su nombre y calizacin y hacemos clic en el botn Crear. Observe que el proyecto se crear en una carpeta con el nombre que ya se ha especificado.

2. A continuacin, segn se puede observar en la figura siguiente, edita-mos el cdigo que compone el programa y lo guardamos (Archivo, Guardar). Obsrvese que el cdigo se guarda en el fichero Program.vb. El nombre del fichero puede ser cualquiera (de forma predeterminada es Program) pero la extensin tiene que ser vb.

3. El siguiente paso es compilar el programa, esto es, traducir el programa fuente a cdigo ejecutable. Para compilar el programa, ejecutamos la orden Generar HolaMundo del men Generar.

4. Finalmente, para ejecutar el programa seleccionamos la orden Ejecutar o Ejecutar sin depurar del men Depurar. El resultado, mensaje Hola Mundo!, se mostrar en una ventana de consola.


1.2.1.1 QU HACE ESTE PROGRAMA? Comentamos brevemente cada lnea del programa anterior. No pasa

nada si algunos de los trminos no quedan muy claros ya que todos ellos se vern con detalle en captulos posteriores.

La primera lnea declara el mdulo HolaMundo, porque el esqueleto de cualquier programa de consola Visual Basic se basa en la definicin de un mdulo. A continuacin se escribe el cuerpo del mdulo encerrado entre las palabras clave Module y End Module. Ambas lneas definen el bloque de cdigo en el que se escriben las acciones a llevar a cabo por el programa Visual Basic. Con esto ya sabemos que el cdigo de Visual Basic se alma-cena en mdulos. Aprenderemos ms sobre ellos en los prximos captulos.

Las siguientes lneas que empiezan por ' (comilla simple) son simple-mente comentarios. Los comentarios no son tenidos en cuenta por el compi-lador, pero ayudan a entender un programa cuando se lee.

A continuacin se escribe el procedimiento principal Main. Observe que un procedimiento se distingue por el modificador () que aparece despus de su nombre y que el bloque de cdigo correspondiente al mismo, incluido entre Sub y End Sub, define las acciones que tiene que ejecutar dicho procedimiento. Cuando se compila un programa, Visual Basic espera que


haya un procedimiento Main. Este procedimiento define el punto de entrada y de salida del programa.

En el ejemplo se observa que el procedimiento Main llama para su eje-cucin al mtodo WriteLine de la clase Console (ms adelante estudiare-mos el concepto de clase) del espacio de nombres System de la biblioteca .NET, que escribe como resultado la expresin que aparece especificada entre comillas. Una secuencia de caracteres entre comillas se denomina cadena de caracteres.

Observe tambin que la sentencia que invoca a WriteLine finaliza con un retorno de carro (tecla Entrar), sucediendo lo mismo con la cabecera del mdulo HolaMundo, con la cabecera del procedimiento Main, etc. Esto quiere decir que todas las declaraciones y sentencias en Visual Basic termi-nan con un retorno de carro. Resumiendo: un programa Visual Basic se basa en la definicin de un mdulo, un mdulo contiene procedimientos, adems de otras definiciones, y un procedimiento contiene sentencias, y otras definiciones, como veremos ms adelante.

1.3 EJEMPLO Para practicar con un programa ms, escriba el siguiente ejemplo que

visualiza como resultado la suma, la resta, la multiplicacin y la divisin de dos cantidades enteras.

Abra el EDI, cree un nuevo proyecto Visual Basic.NET (Archivo, Nuevo, Solucin). Despus elija la categora de proyecto VBNet > Aplicaciones de Windows, la plantilla Aplicacin de Consola, especifique su nombre (por ejemplo Aritmetica) y su localizacin y haga clic en el botn Crear. A conti-nuacin edite el programa como se muestra a continuacin:

Module Aritmetica ' ' Operaciones aritmticas ' Sub Main() Dim dato1, dato2, resultado As Integer dato1 = 20 dato2 = 10 ' Suma


resultado = dato1 + dato2 System.Console.WriteLine( _ "{0} + {1} = {2}", dato1, dato2, resultado) ' Resta resultado = dato1 - dato2 System.Console.WriteLine( _ "{0} - {1} = {2}", dato1, dato2, resultado) ' Producto resultado = dato1 * dato2 System.Console.WriteLine( _ "{0} * {1} = {2}", dato1, dato2, resultado) ' Cociente resultado = dato1 / dato2 System.Console.WriteLine( _ "{0} / {1} = {2}", dato1, dato2, resultado) End Sub End Module

Una vez editado el programa, gurdelo, complelo y ejectelo.


Observe las dos ltimas sentencias Console del programa Hola-Mundo anterior, para qu sirven? Adaselas a este otro.

Qu hace este programa? Fijndonos en el procedimiento principal, Main, vemos que se han declarado tres variables enteras (de tipo Integer): dato1, dato2 y resultado.

Dim dato1, dato2, resultado As Integer

El siguiente paso asigna el valor 20 a la variable dato1 y el valor 10 a la variable dato2.

dato1 = 20 dato2 = 10

A continuacin se realiza la suma de esos valores y se escriben los da-tos y el resultado.

resultado = dato1 + dato2 System.Console.WriteLine( _ "{0} + {1} = {2}", dato1, dato2, resultado)

Obsrvese que cuando una sentencia ocupa ms de una lnea fsica hay que utilizar el carcter de continuacin: un espacio en blanco ms el carcter _.

El mtodo WriteLine escribe un resultado de la forma:

20 + 10 = 30

Observe que la expresin resultante est formada por cinco elementos: dato1, " + ", dato2, " = " y resultado; unos elementos son numricos y otros son constantes de caracteres. Esto se ha especificado mediante el formato {0} + {1} = {2}; una especificacin de la forma {nmero} indica que se ha de mostrar el valor del argumento que est en la posicin nmero (en el ejem-plo, dato1 es el argumento que est en la posicin 0, dato2 est en la 1 y resultado en la 2); cualquier otro carcter entre las comillas dobles, aparte de las especificaciones, se mostrar tal cual (en el ejemplo, los espacios en blanco, el + y el =).

Un proceso similar se sigue para calcular la diferencia, el producto y el cociente.

2Captulo2

INTERFACES GRFICAS

Una de las grandes ventajas de trabajar con Windows es que todas las ventanas se comportan de la misma forma y todas las aplicaciones utilizan los mismos mtodos bsicos (mens desplegables, botones) para introducir rdenes.

Una ventana tpica de Windows tiene las siguientes partes:

1. Barra de mens.

2. Icono de la aplicacin y men de control.

3. Barra de ttulo.

4. Botn para minimizar la ventana.

5. Botn para maximizar la ventana.

6. Botn para cerrar la ventana.

7. Barra de desplazamiento vertical.

8. Marco de la ventana.

9. Barra de desplazamiento horizontal.

10. rea de trabajo.


Un objeto en general puede ser movido a otro lugar haciendo clic sobre l y arrastrndolo manteniendo pulsado el botn izquierdo del ratn.

2.1 PROGRAMANDO EN WINDOWS Una aplicacin para Windows diseada para interaccionar con el usua-

rio presentar una interfaz grfica mostrando todas las opciones que el usuario puede realizar. Dicha interfaz se basa fundamentalmente en dos tipos de objetos: ventanas (tambin llamadas formularios) y controles (boto-nes, cajas de texto, mens, listas, etc.). Por lo tanto, el diseo consistir en crear objetos que den lugar a ventanas y sobre esas ventanas se dibujarn otros objetos llamados controles. Cada objeto estar ligado a un cdigo que permanecer inactivo hasta que se produzca el evento que lo active.

Esto quiere decir que una aplicacin en Windows presentar todas las opciones posibles en uno o ms formularios, para que el usuario elija una de ellas. Por ejemplo, en la figura siguiente, cuando el usuario haga clic sobre el botn Haga clic aqu, en la caja de texto aparecer el mensaje Hola mun-do!

1

2 3 4 5 6

7

10 9 8

STARBOOK CAPTULO2.INTERFACESGRFICAS23

Por lo tanto, para programar una aplicacin Windows hay que escribir cdigo separado para cada objeto en general, quedando la aplicacin divi-dida en pequeos procedimientos o mtodos conducidos por eventos. Por ejemplo:

Private Sub BtSaludoClick(obj As Object, ev As EventArgs) etSaludo.Text = "Hola mundo!" End Sub

El mtodo BtSaludoClick ser puesto en ejecucin en respuesta al evento Click del objeto identificado por BtSaludo (botn titulado Haga clic aqu). Quiere esto decir que cuando el usuario haga clic en el objeto BtSa-ludo se ejecutar el mtodo BtSaludoClick. Esto lo ver con detalle un poco ms adelante. Por esto, esta forma de programar se denomina programa-cin conducida por eventos y orientada a objetos.

Los eventos son mecanismos mediante los cuales los objetos (venta-nas o controles) pueden notificar de la ocurrencia de sucesos. Un evento puede ser causado por una accin del usuario (por ejemplo, cuando pulsa una tecla), por el sistema (por ejemplo, transcurri un determinado tiempo) o indirectamente por el cdigo (por ejemplo, cuando el cdigo carga una ven-tana). En Windows, cada ventana y cada control pueden responder a un conjunto de eventos predefinidos. Cuando ocurre uno de estos eventos, la aplicacin Windows ejecutar el mtodo que tiene para responder a ese evento.


2.2 APLICACIN WINDOWS Un EDI (Entorno de Desarrollo Integrado) como SharpDevelop o Visual

Basic Express Edition permite disear la interfaz grfica de una aplicacin de manera visual, sin ms que arrastrar con el ratn los controles que nece-sitemos sobre la ventana destino de los mismos. Unas lneas gua o una rejilla mostradas sobre la ventana nos ayudarn a colocar estos controles y a darles el tamao adecuado, y una pgina de propiedades nos ayudar a modificar los valores de las propiedades de cada uno de los controles. Todo lo expuesto lo realizaremos sin tener que escribir ni una sola lnea de cdi-go. Despus, un editor de cdigo inteligente nos ayudar a escribir el cdigo necesario y detectar los errores sintcticos que introduzcamos.

En el captulo 1 ya explicamos cmo construir una aplicacin de conso-la con este entorno de desarrollo. Ahora aprenderemos a desarrollar aplica-ciones con interfaz grfica. Como ejemplo, vamos a realizar la aplicacin Windows HolaMundo, que escribimos anteriormente. Su aspecto ser el que apareca en la figura anterior: una ventana que incluye una etiqueta para mostrar el mensaje Hola mundo! y un botn para emitir la orden de mostrar ese mensaje.

Cules son los pasos para desarrollar una aplicacin Windows?

1. Cree un nuevo proyecto (una nueva solucin). El EDI mostrar una pgina de diseo con un formulario vaco por omisin.

2. Dibuje los controles sobre el formulario. Los controles sern tomados de una caja de herramientas.

3. Defina las propiedades del formulario y de los controles.

4. Escriba el cdigo para controlar los eventos que consideremos de cada uno de los objetos.

5. Guarde, compile y ejecute la aplicacin.

2.2.1 Crear un nuevo proyecto Suponiendo que ya est visualizado el entorno de desarrollo, aadimos

un nuevo proyecto Visual Basic.NET (Archivo, Nuevo, Solucin). Despus elegimos la categora de proyecto VBNet > Aplicaciones de Windows, la plantilla Aplicacin Windows, especificamos su nombre y localizacin y hacemos clic en el botn Crear. Observe que el proyecto se crear en una carpeta con el nombre que ya se ha especificado.


Despus de crear una nueva aplicacin Windows, el entorno de de-sarrollo mostrar un formulario, HolaMundo, en el diseador. Observe en la figura siguiente que debajo del formulario se muestran dos pestaas, Fuente y Diseo, que le permitirn alternar entre la vista de cdigo fuente y la vista del diseador grfico.

A la izquierda, en la figura siguiente, se visualizan otros dos paneles: pestaas Proyectos y Herramientas. La primera pondr a nuestra disposi-cin el conjunto de ficheros que forman la aplicacin (recibe el nombre de explorador de soluciones) y la segunda, una caja de herramientas con una gran cantidad de controles listos para ser arrastrados sobre el formulario.

Y a la derecha, tambin en la figura siguiente, se visualizan otros dos paneles: pestaas Propiedades y Clases, que muestran, respectivamente, las propiedades del objeto seleccionado (ventana o control) y el conjunto de clases que forman la aplicacin.


2.2.2 El formulario El formulario es el plano de fondo para los controles. Despus de crear

un nuevo proyecto, la pgina de diseo muestra uno como el de la figura siguiente. Se trata del aspecto grfico de un objeto de la clase MainForm derivada de Form. Para modificar su tamao ponga el cursor del ratn so-bre alguno de los cuadrados que le rodean y arrastre en el sentido deseado.

Si ahora ejecutamos este programa, para lo cual podemos elegir la or-den Iniciar sin depurar del men Depurar, o bien pulsar las teclas Ctrl+F5, aparecer sobre la pantalla la ventana, con el tamao asignado, y podremos actuar sobre cualquiera de sus controles o bien sobre las rdenes del men de control, para minimizarla, maximizarla, moverla, ajustar su tamao, etc. sta es la parte que el diseador de Visual Basic realiza por nosotros y para nosotros; prubelo. Finalmente, para cerrar la ejecucin de la aplicacin disponemos de varias posibilidades:

1. Hacer clic en el botn que cierra la ventana.


2. Hacer un doble clic en el icono situado a la izquierda en la barra de ttulo de la ventana.

3. Activar el men de control de la ventana HolaMundo y ejecutar Cerrar. 4. Pulsar las teclas Alt + F4.

2.2.3 Dibujar los controles En Visual Basic disponemos fundamentalmente de dos tipos de obje-

tos: ventanas y controles. Las ventanas son los objetos sobre los que se dibujan los controles como cajas de texto, botones o etiquetas, dando lugar a la interfaz grfica que el usuario tiene que utilizar para comunicarse con la aplicacin y que genricamente denominamos formulario.

Para aadir un control a un formulario, utilizaremos la caja de herra-mientas que se muestra en la figura siguiente. Cada herramienta de la caja crea un nico control. El significado de los controles ms comunes se expo-ne a continuacin.

Puntero. El puntero no es un control. Se utiliza para seleccionar, mover y ajustar el tamao de los objetos.

Label. Una etiqueta permite mostrar un texto de una o ms lneas que no pueda ser modificado por el usuario. Son tiles para dar instrucciones al usuario.


Button. Un botn de pulsacin lleva asociada una orden (un mtodo). Esta orden se ejecutar cuando el usuario haga clic sobre el botn.

TextBox. Una caja de texto es un rea dentro del formulario en la que el usuario puede escribir o visualizar texto.

CheckBox. Una casilla de verificacin se utiliza para seleccionar una opcin. Utilizando estos controles se pueden seleccionar varias opciones de un grupo.

RadioButton. El control botn de opcin se utiliza para seleccionar una opcin entre varias.


GroupBox. Un marco se utiliza para realzar el aspecto del formulario. Tambin los utilizamos para formar grupos de botones de opcin o bien para agrupar controles relacionados entre s.

ListBox. El control lista fija (lista desplegada) contiene una lista de ele-mentos de la que el usuario puede seleccionar uno o varios.

ComboBox. El control lista desplegable combina una caja de texto y una lista desplegable. Permite al usuario escribir lo que desea seleccionar o elegir un elemento de la lista.

HScrollBar y VScrollBar. La barra de desplazamiento horizontal y la ba-rra de desplazamiento vertical permiten seleccionar un valor dentro de un rango de valores. Estos controles se utilizan independientemente de otros objetos y no son lo mismo que las barras de desplazamiento de una venta-na.

Siguiendo con nuestra aplicacin, seleccionamos de la caja de herra-mientas que acabamos de describir los controles que vamos a utilizar. En primer lugar vamos a aadir al formulario una etiqueta. Para ello, hacemos clic sobre la herramienta etiqueta (Label) y, sin soltar el botn del ratn, la arrastramos sobre el formulario. Cuando soltemos el botn del ratn apare-cer una etiqueta de un tamao predefinido, segn se muestra en la figura siguiente:


Observe en la pgina de propiedades del entorno de desarrollo, mos-trada en la figura siguiente, la propiedad Nombre (Name). Tiene asignado el valor label1 que es el nombre por defecto dado al control caja de texto. Este nombre se utiliza para referirnos a dicho control en el cdigo de la aplica-cin.

Tambin se observan sobre la etiqueta ocho cuadrados distribuidos a lo largo de su permetro, que reciben el nombre de modificadores de tamao, los cuales permiten modificar el tamao de los controles que estamos dibu-jando. Para modificar el tamao de un control, primero seleccinelo hacien-do clic sobre l, despus apunte con el ratn a alguno de los modificadores de tamao, observe que aparece una doble flecha, y, entonces, con el botn izquierdo del ratn pulsado, arrastre en el sentido que desee ajustar el ta-mao.

Tambin puede mover el control a un lugar deseado dentro del formula-rio. Para mover un control, primero seleccinelo haciendo clic sobre l y despus apunte con el ratn a alguna zona perteneciente al mismo y, con el botn izquierdo del ratn pulsado, arrastre hasta situarlo en el lugar desea-do.

2.2.4 Borrar un control Para borrar un control, primero se selecciona haciendo clic sobre l y a

continuacin se pulsa la tecla Supr (Del). Para borrar dos o ms controles, primero se seleccionan haciendo clic sobre cada uno de ellos al mismo tiempo que se mantiene pulsada la tecla Ctrl, y despus se pulsa Supr.

Lista desplegable de los objetos de un formulario, incluido ste.

Lista de las pro-piedades del obje-to seleccionado. Una propiedad se modifica in situ.


Se pueden seleccionar tambin dos o ms controles contiguos, pulsan-do el botn izquierdo y arrastrando el ratn hasta rodearlos.

2.2.5 Propiedades de los objetos Cada clase de objeto tiene predefinido un conjunto de propiedades,

como ttulo, nombre, color, etc. Las propiedades de un objeto representan todos los datos que por definicin estn asociados con ese objeto.

Cada propiedad de un objeto tiene un valor por defecto que puede ser modificado in situ si se desea. Por ejemplo, la propiedad (Name) del formu-lario del ejemplo que nos ocupa tiene el valor MainForm.

Para cambiar el valor de una propiedad de un objeto, siga los pasos in-dicados a continuacin:

1. Seleccione el objeto. Para ello, haga clic sobre el objeto (un control seleccionado aparece rodeado por los modificadores de tamao).

2. Seleccione en la pgina de propiedades la propiedad que desea cam-biar.

3. Modifique el valor que actualmente tiene la propiedad seleccionada. El valor actual de la propiedad seleccionada aparece escrito a continua-cin del nombre de la propiedad. Para cambiar este valor, sobrescriba el valor actual o, si es posible, seleccione uno de la lista que se des-pliega haciendo clic sobre la flecha que aparece a la derecha del valor actual. Para algunas propiedades, esta flecha es sustituida por tres puntos (...). En este caso se visualizar una caja de dilogo.

Se puede tambin modificar una propiedad durante la ejecucin de la aplicacin. Esto implica aadir el cdigo necesario en el mtodo que deba realizar la modificacin.

Para verificar el valor de una misma propiedad en varios objetos, se se-lecciona sta en la pgina de propiedades para uno de ellos, y a continua-cin se pasa de un objeto al siguiente haciendo clic con el ratn sobre cada uno de ellos.

Siguiendo con nuestro ejemplo, vamos a cambiar el ttulo del formulario para que muestre Saludo. Para ello, seleccione el formulario y a continua-


cin la propiedad Text en la pgina de propiedades. Despus, sobrescriba el texto actual con el texto Saludo.

Veamos ahora las propiedades de la etiqueta. Seleccione la etiqueta y observe la lista de propiedades. Algunas de estas propiedades son Back-Color (color del fondo de la etiqueta), (Name) (identificador de la etiqueta para referirnos a ella en el cdigo) y Text (contenido de la etiqueta). Si-guiendo los pasos descritos anteriormente, cambie el valor actual de la propiedad (Name) al valor etSaludo, el valor label1 de la propiedad Text a etiqueta y alinee este texto para que se muestre centrado tanto horizontal como verticalmente; esto requiere asignar a la propiedad TextAlign el valor MiddleCenter. A continuacin, vamos a modificar el tipo de la letra de la etiqueta. Para ello, seleccione la propiedad Font en la pgina de propieda-des, pulse el botn situado a la derecha del valor actual de la propiedad y elija como tamao, por ejemplo, 14; las otras caractersticas las dejamos como estn.

El paso siguiente ser aadir un botn. Para ello, hacemos clic sobre la herramienta Button de la caja de herramientas y arrastramos el botn sobre el formulario. Movemos el botn y ajustamos su tamao para conseguir el diseo que observamos en la figura siguiente. Ahora modificamos sus pro-piedades y asignamos a Text (ttulo) el valor Haga clic aqu, y a (Name), el valor btSaludo.

Tambin observamos que al colocar el control aparecen unas lneas in-dicando la alineacin de ste con respecto a otros controles. Es una ayuda


para alinear los controles que coloquemos dentro del formulario. Puede elegir entre los modos Alinear Lneas, es el modo que estamos utilizando, o Alinear a la rejilla (se visualizan los puntos que dibujan la rejilla). Para elegir el modo de ayuda, ejecute Herramientas > Opciones, seleccione la opcin Diseador de Windows Forms. Para que las opciones elegidas tengan efec-to, tiene que cerrar el diseador y volverlo a abrir.

2.2.6 Escribir los controladores de eventos Sabemos que el nombre de un objeto, propiedad (Name), nos permite

referirnos a l dentro del cdigo de la aplicacin; por ejemplo, en las lneas de cdigo siguientes, la primera asigna el valor Hola mundo! a la propie-dad Text del objeto etSaludo y la siguiente obtiene ese valor y lo almacena en la variable sTexto:

etSaludo.Text = "Hola mundo!" Dim sTexto as String = etSaludo.Text

En Visual Basic la forma general de referirse a una propiedad de un de-terminado objeto es:

Objeto.Propiedad

donde Objeto es el nombre del formulario o control y Propiedad es el nom-bre de la propiedad del objeto cuyo valor queremos asignar u obtener.

Una vez que hemos creado la interfaz o medio de comunicacin entre la aplicacin y el usuario, tenemos que escribir los mtodos para controlar aquellos eventos que necesitemos manipular de cada uno de los objetos.

Hemos dicho que una aplicacin en Windows es conducida por eventos y orientada a objetos. Esto es, cuando sobre un objeto ocurre un suceso (por ejemplo, el usuario hizo clic sobre un botn) se produce un evento (por ejemplo, el evento Click); si nosotros deseamos que nuestra aplicacin responda a ese evento, tendremos que escribir un mtodo que incluya el cdigo que debe ejecutarse. El mtodo pertenecer a la interfaz del objeto o del objeto padre. Por ejemplo, el mtodo que responda al evento Click de un botn pertenecer a la interfaz de su ventana padre, esto es, a su conte-nedor.

Dnde podemos ver la lista de los eventos a los que puede responder un objeto de nuestra aplicacin? En la ventana de propiedades.


Por ejemplo, seleccione el botn btSaludo en la ventana de diseo, va-ya a la ventana de propiedades y muestre la lista de eventos para el control seleccionado, haciendo clic en el botn Eventos. Haga doble clic en el even-to Click, o bien escriba manualmente el nombre del controlador y pulse Entrar.

El resultado es que se aade a la clase MainForm un manejador para este evento especificado por la lnea siguiente (puede verlo en el fichero MainForm.Designer.vb):

AddHandler Me.btSaludo.Click, AddressOf Me.BtSaludoClick

La interpretacin de esta lnea de cdigo es: el mtodo BtSaludoClick del formulario (Me: es el formulario actual, MainForm) ser el manejador (Handler) para el evento Click del botn btSaludo (btSaludo.Click) de dicho formulario (Me). Esto puede variar si utiliza Microsoft Visual Basic Express Edition, pero la solucin propuesta sera anloga.

Tambin se aadi el esqueleto del mtodo BtSaludoClick (fichero MainForm.vb), al que nos hemos referido en el prrafo anterior, que respon-der a dicho evento, esto es, que se ejecutar cuando se genere dicho evento:

Sub BtSaludoClick(ByVal sender As Object, ByVal e As EventArgs) 'Escriba aqu el cdigo que tiene que ejecutarse para 'responder al evento Click producido por el botn End Sub

Eventos


El primer parmetro de este mtodo hace referencia al objeto que ge-ner el evento y el segundo contiene informacin que depende del evento.

Adems del evento Click, hay otros eventos asociados con un botn de pulsacin, segn se puede observar en la figura anterior.

Una vez aadido el controlador para el evento Click del botn btSalu-do, cmo lo completamos? Lo que desebamos era que la etiqueta mos-trara el mensaje Hola mundo! cuando el usuario hiciera clic en el botn. Segn esto, complete este controlador as:

Sub BtSaludoClick(ByVal sender As Object, ByVal e As EventArgs) etSaludo.Text = "Hola mundo!" End Sub

Para aadir el controlador anterior, tambin podramos habernos dirigi-do a la pgina de diseo y haber hecho doble clic sobre el botn de pulsa-cin.

Un detalle de estilo a la hora de escribir el cdigo. En teora, tendra-mos que anteponer a los nombres de las clases y otras estructuras de datos el nombre del espacio de nombres al que pertenecen. Por ejemplo, las cla-ses (tipos de datos) Object y EventArgs pertenecen al espacio de nombres System:

Sub BtSaludoClick(ByVal sender As System.Object, _ ByVal e As System.EventArgs) End Sub

Esto se evita aadiendo al principio del fichero fuente las sentencias Imports que especifiquen los espacios de nombres a los que pertenezcan las clases de objetos que vayamos a utilizar en dicho fichero. Por ejemplo:

Imports System Imports System.Windows.Forms Imports System.Drawing

No obstante, esto tampoco sera necesario, porque el EDI hace refe-rencia a estos espacios de nombres a travs del nodo Referencias que puede ver en el explorador de soluciones segn muestra la figura siguiente. Para aadir otras referencias, haga clic con el botn derecho del ratn sobre dicho nodo y seleccione aquellas que desee.


Anlogamente a como las carpetas o directorios ayudan a organizar los ficheros en un disco duro, los espacios de nombres organizan las clases en grupos para facilitar el acceso a las mismas y proporcionan una forma de crear tipos globales nicos, evitando conflictos en el caso de clases de igual nombre pero de distintos fabricantes, ya que se diferenciarn en su espacio de nombres.

La aplicacin est finalizada. Complela y ejectela para ver los resulta-dos.

3Captulo3

LENGUAJE BASIC

En los captulos anteriores hemos adquirido los conocimientos necesa-rios para poder abordar el desarrollo de aplicaciones bajo Visual Basic; esto es, hemos instalado un EDI y hemos construido una aplicacin desde dos puntos de vista: utilizando una consola para interactuar con la aplicacin o diseando una interfaz grfica que facilite esta interaccin usuario-aplicacin. En este captulo veremos los elementos que aporta Basic para escribir un programa. Considere este captulo como soporte para el resto de los captulos, esto es, lo que se va a exponer en l lo ir utilizando en menor o mayor medida en los captulos sucesivos. Por lo tanto, limtese ahora simplemente a realizar un estudio con el fin de informarse de los elementos con los que contamos.

3.1 TIPOS Recuerda este cdigo correspondiente a uno de los ejemplos que rea-

lizamos en el captulo 1?

Sub Main() Dim dato1, dato2, resultado As Integer dato1 = 20 dato2 = 10


En dicho cdigo se definen tres variables: dato1, dato2 y resultado, y son de tipo Integer, lo que significa que estas variables podrn almacenar valores enteros pertenecientes al intervalo que define este tipo.

Los tipos en Visual Basic se clasifican en: tipos valor y tipos referencia. Una variable de un tipo valor almacena directamente un valor (datos en general), mientras que una variable de un tipo referencia lo que permite almacenar es una referencia a un objeto (posicin de memoria donde est el objeto). Por ejemplo:

Dim dato1 As Integer = 0 ' dato1 almacena un entero. Dim sTexto as String = Nothing ' sTexto permitir ' almacenar una referencia a un objeto String.

La tabla siguiente resume los tipos intrnsecos en Visual Basic.

Tipo VB Bytes Rango de valores Boolean ? True y FalseByte 1 0 a 255 Char 2 0 a 65535 Date 8 1/Enero/1 a 31/Diciembre/9999

00:00:00 AM a 11:59:59 PM Decimal 16 +/-79228162514264337593543950335

+/-7.9228162514264337593543950335E+28 Double 8 +/-1.79769313486231570E+308 Integer 4 -2147483648 a +2147483647 Long 8 -9223372036854775808 a

+9223372036854775807 Object 4 Cualquier tipo puede ser almacenado en una

variable de tipo Object SByte 1 -128 a 127 Short 2 -32768 a 32767 Single 4 +/-3.4028235E+38 String ? 0 a 2 billones de caracteres UNICODE UInteger 4 0 a 4294967295 ULong 8 0 a 18446744073709551615 UShort 2 0 a 65535 Estructuras Tipos valor definidos por el usuario

(? = depende de la plataforma de desarrollo)

Dentro de los tipos referenciados, destacamos en este captulo la clase String porque nos permite trabajar con cadenas de caracteres. Por ejemplo, la siguiente lnea de cdigo asigna al String sTexto la cadena abc:

STARBOOK CAPTULO3.LENGUAJEBASIC39

sTexto = "abc"

3.1.1 Clases El lenguaje soportado por el EDI Visual Basic es un lenguaje orientado

a objetos. La base de la programacin orientada a objetos es la clase. Una clase es un tipo de objetos definido por el usuario. Por ejemplo, la clase String de la biblioteca .Net est definida as:

Class String ' Atributos ' Mtodos End Class

Y, cmo se define un objeto de esta clase? Pues, una forma de hacer-lo sera as:

Dim sTexto As String = New String("abc")

Suponiendo que la clase String tiene un mtodo de acceso pblico Chars(i As Integer) que devuelve el carcter que est en la posicin i, la siguiente sentencia devolver el carcter que est en la posicin 1 (la b):

Dim car As Char = sTexto.Chars(1)

Una caracterstica muy importante que aporta la programacin orienta-da a objetos es la herencia ya que permite la reutilizacin del cdigo escrito por nosotros o por otros. Por ejemplo, el siguiente cdigo define la clase MiForm como una clase derivada (que hereda) de Form:

Class MiForm Inherits Form ' Atributos ' Mtodos End Class

La clase MiForm incluir los atributos y mtodos heredados de Form ms los atributos y mtodos definidos por el usuario en esta clase. Esto significa que un objeto de la clase MiForm podr ser manipulado por los mtodos heredados y por los propios.


Tanto las clases (por ejemplo String, Object, etc.) como las matrices que estudiaremos ms adelante son tipos referencia.

3.2 LITERALES Un literal en Visual Basic puede ser: un entero, un real, un valor boo-

leano, un carcter, una cadena de caracteres, una fecha y hora y Nothing.

El lenguaje Visual Basic permite especificar un literal entero en base 10, 8 y 16. Por ejemplo:

256 nmero decimal 256 &O400 nmero decimal 256 expresado en octal &H100 nmero decimal 256 expresado en hexadecimal

Un literal real est formado por una parte entera, seguida por un punto decimal y una parte fraccionaria. Tambin se permite la notacin cient-fica, en cuyo caso se aade al valor una e o E, seguida por un expo-nente positivo o negativo. Por ejemplo:

-17.24 27E-3

Una constante real tiene siempre tipo Double, a no ser que se aada a la misma una F, en cuyo caso ser de tipo Single, o D, en cuyo caso es de tipo Decimal.

Los literales de un solo carcter son de tipo Char. Este tipo de literales est formado por un nico carcter encerrado entre comillas dobles se-guido del carcter de tipo C (conversin explcita de String a Char). Ejemplo:

" "C espacio en blanco "x"C letra minscula x

Un literal de cadena de caracteres es una secuencia de caracteres encerrados entre comillas dobles. Las cadenas de caracteres en Visual Basic son objetos de la clase String. Esto es, cada vez que en un pro-grama se utilice un literal de caracteres, Visual Basic crea de forma au-tomtica un objeto String con el valor del literal.


Los literales fecha y hora son de tipo Date. Este tipo de literales est formado por una fecha (mes, da, ao separados por / o -) y una hora (horas, minutos, segundos separados por dos puntos, ms AM o PM si el formato es de 12 horas) delimitados por el carcter #. Algunos ejem-plos son:

#12/15/2012 10:00:00 AM# #12/15/2012# #10:05:00 PM# #12-15-2012 15:00:00#

3.3 IDENTIFICADORES Los identificadores son nombres dados a tipos, literales, variables, cla-

ses, interfaces, mtodos, espacios de nombres y sentencias de un progra-ma. La sintaxis para formar un identificador es la siguiente:

{letra|_}[{letra|dgito|_}]...

Los identificadores pueden tener cualquier nmero de caracteres (real-mente pueden tener hasta 1.023 caracteres). Algunos ejemplos son:

Suma Clculo_Nmeros_Primos _ordenar VisualizarDatos

3.4 DECLARACIN DE CONSTANTES SIMBLICAS

Declarar una constante simblica significa decirle al compilador Visual Basic el nombre de la constante y su valor. Esto se hace utilizando el califi-cador Const.

Const identificador As tipo = cte[, identificador As tipo = cte]...

Un ejemplo puede ser el siguiente:


Const pi As Double = 3.1415926

3.5 VARIABLES Una variable representa un espacio de memoria para almacenar un va-

lor de un determinado tipo. La sintaxis para declarar una variable es la si-guiente:

Dim identificador As tipo [, identificador As tipo]...

El siguiente ejemplo declara tres variables de tipo Short (en dos grupos diferentes), una variable de tipo Integer y dos variables de tipo String.

Module ElementosVB Dim da, mes As Short, ao As Short = 2001 Public Sub Main() Dim contador As Integer = 0 Dim Nombre As String = "", Apellidos As String da = 20 Apellidos = "Fernndez" ' ... End Sub ' ... End Module

La declaracin de una variable puede realizarse a nivel del mdulo dentro del mdulo pero fuera de todo procedimiento (Sub) o a nivel del procedimiento.

Toda variable declarada en un bloque (mdulo, procedimiento, etc.) se inicia por omisin por el compilador Visual Basic con el valor Nothing (esta constante puede ser convertida implcitamente a cualquier tipo).

Cul es la vida de una variable? El perodo de tiempo durante el cual la variable est disponible para usarla. Una variable declarada con Dim existe slo mientras el procedimiento se est ejecutando, pero si se declara Static, continuar existiendo y conservar su valor aun cuando el procedi-miento haya finalizado. Un mdulo conserva sus variables mientras la apli-cacin est en ejecucin.


Cul es el mbito de una variable? El bloque de cdigo desde el cual la variable est accesible sin calificarla; ste queda determinado por dnde est declarada la variable. Un bloque de cdigo es un conjunto de senten-cias terminadas por una sentencia End, Else, Loop o Next.

Qu cdigo de una aplicacin puede acceder a una variable definida en la misma? Est determinado por las palabras clave Dim, Public, Protec-ted, Friend, Protected Friend o Private utilizadas en la declaracin de la variable. En un procedimiento slo se puede utilizar Dim y la accesibilidad siempre es privada. La accesibilidad pblica, protegida, privada, amiga, etc., no slo se puede definir para una variable, sino tambin para un mdulo, para una clase y para un procedimiento.

Un elemento declarado Public es accesible desde toda la aplicacin y desde otras aplicaciones que hagan referencia a sta. Si est declarado Private, slo est accesible desde el mdulo donde ha sido definido y Friend desde la propia aplicacin.

3.6 CONVERSIN ENTRE TIPOS En principio, Visual Basic permite convertir implcitamente un dato de

cualquier tipo a cualquier otro tipo. Esto puede originar prdidas de datos cuando un valor de un determinado tipo sea convertido a otro tipo con me-nor precisin o de capacidad ms pequea.

La figura siguiente resume los tipos colocados de izquierda a derecha de menos a ms precisos; las flechas indican las conversiones implcitas seguras (desde cualquier tipo a todos los que figuran a su derecha):

Tambin, el tipo Char puede ser convertido implcitamente a String,

cualquier tipo puede ser convertido a Object y Nothing puede ser converti-do a cualquier tipo. El tipo Boolean no admite una conversin implcita a ningn otro tipo.

Las conversiones implcitas de Integer a Single, de Long a Single o Double, o de Decimal a Single o Double, pueden dar lugar a una prdida de precisin, pero no a un error durante la ejecucin.

Las conversiones inversas a las implcitas que hemos calificado como seguras, no siempre son satisfactorias porque pueden fallar durante la eje-

Short Byte Long Integer DoubleSingle Decimal


cucin si el valor a almacenar sobrepasa el rango permitido. Por eso, nor-malmente los compiladores obligan a realizar este tipo de conversiones de forma explcita; Visual Basic no, para forzar esta situacin hay que aadir al programa la sentencia:

Option Strict On

En este caso, para realizar una conversin de forma explcita utilizare-mos la funcin CType que tiene la sintaxis siguiente:

CType(expresin, tipo)

En el siguiente ejemplo se pueden observar dos conversiones admiti-das por Basic de forma predeterminada: una de Single a Double y otra de Double a Integer.

Dim entero1 As Integer = 0, real1 as Double = 0.0 Dim real2 As Single = 12.345 real1 = real2 entero1 = real2

La primera no presenta ningn problema pero en la segunda hay una prdida de precisin ya que el Double pasa a Integer redondeando el valor al entero ms prximo. Si quisiramos que este tipo de conversin no se produjera de forma implcita, sino que el compilador forzara a realizar una conversin explcita, tendramos que proceder de la forma siguiente:

Option Strict On Module ElementosVB Public Sub Main() Dim entero1 As Integer = 0, real1 as Double = 0.0 Dim real2 As Single = 12.345 real1 = real2 entero1 = CType(real2, Integer) ' ... End Sub ' ... End Module

Puede realizar una aplicacin de consola y probar lo expuesto.


3.7 OPERADORES Los operadores son smbolos que indican cmo los datos se manipu-

lan. Se pueden clasificar en los siguientes grupos: aritmticos, relacionales, lgicos, de asignacin y de concatenacin.

3.7.1 Operadores aritmticos Operador Operacin + Suma. Los operandos pueden ser enteros o reales. Resta. Los operandos pueden ser enteros o reales. * Multiplicacin. Los operandos pueden ser enteros o

reales. / Divisin real. Los operandos pueden ser enteros o re-

ales. El resultado es de tipo Double, excepto cuando un operando es Single y el otro no es Double, en este caso el resultado ser Single, o bien si ambos operandos son de tipo Decimal, entonces ser Decimal.

\ Divisin entera. Los operandos pueden ser de todos los tipos numricos, incluidos los tipos reales, sin signo y Decimal. Si alguno de los operandos es de un tipo real, Visual Basic lo convierte a Long redondeando. El resul-tado es entero en todos los casos.

^ Exponenciacin (ab). Los operandos a y b pueden ser enteros o reales. En cualquier caso, los operandos son convertidos implcitamente a Double. Si a es negativo, b tiene que ser entero.

Mod Resto de una divisin. Los operandos pueden ser ente-ros o reales. Si ambos operandos son enteros, el resto ser entero; en otro caso, el resto ser real.

Cuando en una operacin aritmtica los operandos son de diferentes ti-pos, ambos son convertidos al tipo del operando de precisin ms alta. Por ejemplo:

Dim a As Double = 10 Dim b As Single = 20 Dim c As Integer = 2, r As Integer = 0 r = CType(7.5 * System.Math.Sqrt(a) - b / c, Integer)


3.7.2 Operadores de relacin Operador Operacin < Primer operando menor que el segundo? > Primer operando mayor que el segundo? = Primer operando mayor o igual que el segundo? Primer operando distinto que el segundo? = Primer operando igual que el segundo?

3.7.3 Operadores lgicos El resultado de una operacin lgica (AND, OR, XOR y NOT) ser un

valor booleano verdadero o falso (True o False) cuando sus operandos sean expresiones que den lugar tambin a un resultado verdadero o falso. Por lo tanto, las expresiones que dan como resultado valores booleanos (vanse los operadores de relacin) pueden combinarse para formar expre-siones booleanas utilizando los operadores lgicos indicados a continua-cin.

Operador Operacin And o AndAlso AND. Da como resultado True si al evaluar cada uno de

los operandos el resultado es True. Si uno de ellos es False, el resultado es False. Si se utiliza AndAlso en lugar de And y el primer operando es False, el segundo operando no es evaluado.

Or u OrElse OR. El resultado es False si al evaluar cada uno de los operandos el resultado es False. Si uno de ellos es True, el resultado es True. Si se utiliza OrElse en lugar de Or y el primer operando es True, el segundo operan-do no es evaluado.

Not NOT. El resultado de aplicar este operador es False si al evaluar su operando el resultado es True, y True en ca-so contrario.

Xor XOR. Da como resultado True si al evaluar cada uno de los operandos el resultado de uno es True y el del otro False; en otro caso el resultado es False.


El resultado de una operacin lgica cuando sus operandos son expre-siones que producen un resultado de tipo Boolean es tambin de tipo Boo-lean. Por ejemplo:

Dim p As Integer = 10, q As Integer = 0 Dim r As Boolean r = p 0 And q 0 ' da como resultado False r = p 0 Or q > 0 ' da como resultado True r = q < p And p


3.7.5 Operador de concatenacin El operador de concatenacin (&) permite generar una cadena de ca-

racteres a partir de otras dos. La forma de utilizarlo es la siguiente:

var = expresin1 & expresin2

La variable var tiene que ser de tipo String u Object y el tipo de expre-sin1 y expresin2 si no es de tipo String es convertido a String.

El operador & podr ser reemplazado por el operador + slo cuando expresin1 y expresin2 sean de tipo String. El siguiente ejemplo clarifica lo expuesto:

Dim s1, s2, s3 As String, n As Integer = 3 s2 = "Hola" s3 = " amigos" s1 = n & s3 ' s1 = "3 amigos" s1 = s2 + s3 ' s1 = "Hola amigos"

3.8 PRIORIDAD Y ORDEN DE EVALUACIN La tabla que se presenta a continuacin resume las reglas de prioridad

de todos los operadores. Las lneas se han colocado de mayor a menor prioridad. Los operadores escritos sobre una misma lnea tienen la misma prioridad.

Una expresin entre parntesis siempre se evala primero. Los parn-tesis tienen mayor prioridad y son evaluados de ms internos a ms exter-nos.

Operador Operacin Procedimientos (mtodos) Llamadas a procedimientos ^ Exponencial + Ms y menos unitarios * / Multiplicacin y divisin \ Divisin entera Mod Resto de una divisin + Suma y resta


& Concatenacin =, , , =, Like, Is, TypeOf...Is

Comparacin Not Negacin And, AndAlso AND Or, OrElse OR Xor XOR

En Visual Basic, todos los operadores binarios son evaluados de iz-quierda a derecha. En el siguiente ejemplo, primero se divide z entre 2 y a continuacin el resultado se resta de y, asignando el valor obtenido a x.

Dim x, y, z As Integer y = 20 : z = 15 x = y - z \ 2 ' resultado x = 13

3.9 ESTRUCTURA DE UN PROGRAMA El cdigo de una aplicacin Visual Basic se agrupa en mdulos que al-

macenamos en uno o ms ficheros. A su vez, los ficheros se agrupan en proyectos y stos, en soluciones. Como norma general, cualquier cdigo que escribamos perteneciente a una aplicacin, cuando incluye sentencias del tipo indicado a continuacin, debe seguir la secuencia:

Sentencias Option. Sentencias Imports. Sentencias Module, Class y Namespace, si procede.

Adems, todo programa Visual Basic tiene que tener un procedimiento denominado Main, y slo uno, que puede estar definido en un mdulo o en una clase (en una clase habra que declararlo Shared compartido). Este procedimiento es el punto de entrada al programa y tambin el punto de salida.

Por ejemplo, el siguiente programa muestra cmo calcular el rea de un crculo de radio especificado.

Module AreaCirculo Public Const pi as Double = 3.1415926


Sub Main() Dim radio As Double = 10.5 Dim AreaCirculo As Double = 0.0 AreaCirculo = pi * radio ^ 2 Console.WriteLine("rea del crculo de radio" & _ " {0} = {1}", radio, AreaCirculo) Console.Write("Pulse una tecla para continuar...") Console.ReadKey(True) End Sub End Module

Todos los miembros (variables y procedimientos) de un mdulo estn-dar (Module) son Shared por omisin (compartidos); en una clase para que un miembro sea Shared habra que declararlo as explcitamente. Esto significa que cuando una parte de un programa cambia una variable pblica definida en un mdulo estndar, y posteriormente otra parte del mismo programa lee esa variable, sta obtendr el ltimo valor almacenado. En cambio, los datos miembro no Shared definidos en una clase (atributos y mtodos de la clase) existen separadamente para cada objeto creado de esa clase.

A las variables Shared de un Module o de una Class se accede a travs del nombre del mdulo o de la clase. Por ejemplo:

AreaCirculo.pi

De lo anterior se deduce que una variable pblica definida en un mdu-lo estndar es visible en todo el programa y existe hasta que finalice el pro-grama, mientras que una variable pblica no Shared de una clase slo puede ser accedida all donde exista un objeto de esa clase, y existe mien-tras el objeto al que pertenece exista.

4Captulo4

ENTRADA Y SALIDA ESTNDAR

Frecuentemente un programa necesitar obtener informacin desde un origen o enviar informacin a un destino. Por ejemplo, obtener informacin desde el teclado o bien enviar informacin a la pantalla. En este captulo aprender cmo leer los datos requeridos por su aplicacin del teclado y cmo mostrar los resultados en una consola.

4.1 FLUJOS DE ENTRADA La clase Console proporciona dos mtodos que tienen un especial in-

ters porque permiten a un programa leer datos de la entrada estndar (del teclado). Estos mtodos son:

Public Shared Function Read() As Integer Public Shared Function ReadLine() As String

El mtodo Read simplemente lee caracteres individuales del flujo de entrada estndar; concretamente lee el siguiente carcter disponible. De-vuelve un entero (Integer) correspondiente al cdigo del carcter ledo o bien un valor negativo cuando en un intento de leer no hay ms datos.

Por ejemplo, el siguiente cdigo lee un carcter del teclado:


Module LeerUnCaracter Sub Main() Dim car As Char Console.Write("Introduzca un carcter: ") car = Convert.ToChar(System.Console.Read()) Console.WriteLine(car) Console.Write("Pulse una tecla para continuar...") Console.ReadKey(True) End Sub End Module

El entero devuelto por el mtodo Read es convertido en un carcter in-vocando al mtodo ToChar de la clase Convert del espacio de nombres System. El mtodo ReadKey obtiene el carcter de la tecla pulsada por el usuario.

El mtodo ReadLine lee una lnea del flujo vinculado con la entrada estndar; concretamente lee la siguiente lnea disponible. Devuelve una referencia a un objeto String que envuelve la lnea leda o bien una referen-cia nula (Nothing en Visual Basic) cuando no hay datos disponibles.

Una lnea est definida como una secuencia de caracteres seguidos por un retorno de carro (CR: &000D), un avance de lnea (LF: &000A), o bien por ambos (propiedad System.Environment.NewLine de tipo String; este valor es automticamente aadido al final del texto escrito por WriteLi-ne). La cadena de caracteres devuelta no contiene el carcter o caracteres de terminacin.

Por ejemplo, el siguiente cdigo lee una lnea de la entrada estndar y la visualiza en la pantalla:

Module LeerUnaCadena Public Sub Main() Dim sdato As String ' variable para almacenar una ' lnea de texto Console.Write("Introduzca un texto: ") sdato = Console.ReadLine() ' leer una lnea de texto Console.WriteLine(sdato) ' escribir la lnea leda Console.Write("Pulse una tecla para continuar...") Console.ReadKey(True) End Sub End Sub End Module

STARBOOK CAPTULO4.ENTRADAYSALIDAESTNDAR53

Analicemos el procedimiento Main del programa anterior. Primeramen-te define una referencia, sdato, a un objeto String; esto permitir leer una cadena de caracteres. Despus lee una lnea de texto introducida a travs del teclado y la visualiza.

4.2 FLUJOS DE SALIDA La clase Console tambin proporciona dos mtodos que tienen un es-

pecial inters porque permiten a un programa escribir datos en la salida estndar (en la ventana de la consola). Estos mtodos son:

Public Shared Sub Write([arg]) Public Shared Sub WriteLine([arg])

Por ejemplo, el siguiente cdigo (se presentan dos versiones) escribe un valor n en la salida estndar y sita el punto de insercin (el cursor) en la lnea siguiente:

Dim n As Double = 10.5 System.Console.WriteLine(n) ' escribe: 10,5 System.Console.WriteLine("Valor = " & n) ' escribe: Valor = 10,5

Los mtodos Write y WriteLine son esencialmente los mismos; ambos escriben su argumento en la salida estndar. La nica diferencia entre ellos es que WriteLine aade la cadena NewLine (avance al principio de la lnea siguiente) al final de su salida, y Write no. En otras palabras, la siguiente sentencia:

System.Console.Write("El valor no puede ser negativo" & _ System.Environment.NewLine)

es equivalente a esta otra:

System.Console.WriteLine("El valor no puede ser negativo")

En el ejemplo anterior, se puede observar que Write aade al final de la cadena de caracteres un retorno de carro ms un avance de lnea que Wri-teLine no necesita aadir, ya que dicha operacin est implcita en este mtodo.


Los argumentos para Write y WriteLine pueden ser de cualquier tipo primitivo o referenciado: Object, String, Char(), Char, Integer, Long, Sin-gle, Double, Boolean, Decimal, etc. Sin argumentos, WriteLine escribe la cadena NewLine, lo que se traduce en un avance a la lnea siguiente.

Como ejemplo, el siguiente programa utiliza WriteLine para escribir da-tos de varios tipos en la salida estndar.

Module TestTiposDatos ' Tipos de datos Public Sub Main() Dim sCadena As String = "Lenguaje Visual Basic.NET" Dim cMatrizCars() As Char = "abc" ' matriz de cars. Dim dato_Integer As Integer = 4 Dim dato_long As Long = Long.MinValue ' mnimo valor Long Dim dato_Single As Single = Single.MaxValue ' mximo valor Single Dim dato_Double As Double = Math.PI ' 3.1415926 Dim dato_bool As Boolean = True Console.WriteLine(sCadena) Console.WriteLine(cMatrizCars) Console.WriteLine(dato_Integer) Console.WriteLine(dato_long) Console.WriteLine(dato_Single) Console.WriteLine(dato_Double) Console.WriteLine(dato_bool) Console.Write("Pulse una tecla para continuar...") Console.ReadKey(True) End Sub End Sub End Module

Los resultados que produce el programa anterior son los siguientes:

Lenguaje Visual Basic.NET abc 4 -9223372036854775808 3,402823E+38 3,14159265358979 True


Observe que se puede imprimir un objeto: el primer mtodo WriteLine imprime un objeto String. Cuando se utiliza Write o WriteLine para imprimir un objeto, el dato impreso depende del tipo del objeto. En el ejemplo se puede observar que la impresin de un objeto String hace que se imprima la cadena de caracteres que almacena.

4.3 SALIDA CON FORMATO Los mtodos Write y WriteLine tambin permiten mostrar los datos

segn un formato. Para ello utilizaremos las siguientes formas de estos mtodos:

Public Shared Sub Write(formato[, argumento]...) Public Shared Sub WriteLine(formato[, argumento]...)

formato Especifica cmo va a ser la salida. Es una cadena de caracte-res formada por caracteres ordinarios y especificaciones de formato. El formato se lee de izquierda a derecha.

Dim edad As Integer = 0 Dim peso As Single = 0 ' ... WriteLine("Tiene {0,2:d} aos y pesa {1,6:f2} kilos", edad, peso)

argumento Representa el valor o valores a escribir. Cada argumento debe tener su correspondiente especificacin de formato y en el mismo orden. Si hay ms argumentos que especificaciones de formato, los argumentos en exceso se ignoran.

WriteLine("Tiene {0,2:d} aos y pesa {1,6:f2} kilos", edad, peso)

Cuando se ejecute la sentencia anterior, los caracteres ordinarios se escribirn tal cual y las especificaciones de formato sern sustituidas por los

caracteres ordinarios

especificaciones de formato


valores correspondientes en la lista de argumentos. As, para edad igual a 20 y peso igual 70.5 el resultado ser:

Tiene 20 aos y pesa 70,50 kilos

Una especificacin de formato est compuesta por:

{posicin[, ancho][:tipo[decimales]]}

Una especificacin de formato siempre est incluida entre { }. El signifi-cado de cada uno de los elementos se indica a continuacin:

posicin Posicin 0, 1, 2, etc., del argumento en la lista de argumentos. ancho Opcional. Mnimo nmero de posiciones para la salida. Si el

ancho se omite o el valor a escribir ocupa ms posiciones de las especificadas, el ancho se incrementa en lo necesario. Si este valor es negativo el resultado se justifica a la izquierda dentro del ancho especificado; si es positivo la justificacin se hace a la derecha.

tipo Opcional. Uno de los caracteres de la tabla mostrada a conti-nuacin.

decimales Opcional. Nmero mnimo de dgitos a mostrar en el caso de enteros o de decimales en el caso de fraccionarios. Cuando se especifica se escribe justo a continuacin de tipo, sin es-pacios en blanco.

La siguiente tabla muestra los formatos utilizados ms comnmente y ejemplos de utilizacin de los mismos:


Carc-ter

Descrip-cin

Ejemplos Salida

C o c Moneda Console.Write("{0,9:C2}", 4.5) Console.Write("{0,9:C2}", -4.5)

4,50 -4,50

D o d Enteros Console.Write("{0:D5}", 45) Console.Write("{0,5:D}", 45)

00045 45

E o e Cientfico Console.Write("{0:E}", 450000)

4,500000E+005

F o f Coma fija Console.Write("{0:F2}", 45) Console.Write("{0:F0}", 45) Console.Write("{0,8:F2}",45) Conso-le.Write("{0,8:F2}",145.3)

45,00 45 45,00 145,30

G o g General Console.Write("{0:G}", 4.5) 4,5 N o n Numrico Console.Write("{0:N}",

4500000) 4.500.000,00

P o p % Console.Write("{0:N}", 0.12345)

12,35 %

X o x Hexadecimal Console.Write("{0:X}", 450) Console.Write("{0:X}", &Hff7a)

1C2 FF7A

5Captulo5

SENTENCIAS DE CONTROL

En este captulo aprender fundamentalmente a escribir el cdigo para que un programa tome decisiones y para que sea capaz de ejecutar bloques de sentencias repetidas veces.

5.1 SENTENCIA DE ASIGNACIN Una sentencia es una lnea de texto que indica una o ms operaciones

a realizar. Una lnea puede tener varias sentencias, separadas unas de otras por dos puntos:

total = cantidad * precio : suma = suma + total

Una sentencia Basic puede escribirse en varias lneas fsicas utilizando el carcter de continuacin de lnea (un espacio en blanco seguido del carcter de subrayado). Por ejemplo:

PagoMensual = CantidadPrest * _ (Inters / (1 - (1 / ((1 + Inters) ^ Meses))))

La sentencia ms comn en cualquier lenguaje de programacin es la sentencia de asignacin. Su forma general es:


variable = expresin

que indica que el valor que resulte de evaluar la expresin tiene que ser almacenado en la variable especificada. Por ejemplo:

Dim cont As Integer Dim intereses As Double, capital As Double Dim tantoPorCiento As Single Dim mensaje As String '... cont = cont + 1 intereses = capital * tantoPorCiento / 100 mensaje = "La operacin es correcta"

Toda variable tiene que ser declarada antes de ser utilizada.

5.2 SENTENCIAS DE CONTROL Las sentencias de control permiten tomar decisiones y realizar un pro-

ceso repetidas veces. Basic dispone de las siguientes sentencias de control:

If ... Then If ... Then ... Else Select Case While ... End While Do ... Loop While For ... Next For ... Each Try ... Catch

Veamos a continuacin la sintaxis correspondiente a cada una de ellas; cualquier expresin especificada entre corchetes - [ ] - es opcional.

STARBOOK CAPTULO5.SENTENCIASDECONTROL61

5.3 IF ... THEN ... ELSE ... La sentencia If permite ejecutar condicionalmente una o ms senten-

cias y puede escribirse de las dos formas siguientes:

If [(]condicin[)] Then sentencia 1 [Else sentencia 2]

o bien:

If [(]condicin[)] Then sentencia 1 [Else sentencia 2] End If

donde condicin es una expresin booleana, y sentencia 1 y sentencia 2 representan a una o ms sentencias simples. Cuando se utiliza el primer formato y como sentencia 1 y/o sentencia 2 se escriben varias sentencias simples, hay que separar unas de otras por dos puntos; ste es uno de los motivos por los que se utiliza ms el segundo formato. En este caso, lo ms normal es que cada sentencia simple se finalice pulsando la tecla Entrar.

Una sentencia If se ejecuta de la forma siguiente:

1. Se evala la condicin y se obtiene un resultado verdadero o falso.

2. Si el resultado es verdadero (True), se ejecutar lo indicado por la sen-tencia 1.

3. Si el resultado es falso (False), la sentencia 1 se ignorar y se ejecutar lo indicado por la sentencia 2 si la clusula Else se ha especificado.

4. En cualquier caso, la ejecucin contina en la siguiente sentencia eje-cutable que haya a continuacin de la sentencia If.

If (a = b * 5) Then x = 4 a = a + x Else b = 0 End If ' siguiente lnea del programa


En el ejemplo anterior, si se cumple que a es igual a b * 5, se ejecutan las sentencias x = 4 y a = a + x. En otro caso, se ejecuta la sentencia b = 0. En ambos casos, la ejecucin contina en la siguiente lnea del programa.

Cuando sentencia 2 coincida con otra sentencia If se puede utilizar esta otra sintaxis:

If [(]condicin 1[)] Then sentencia 1 ElseIf [(]condicin 2[)] Then sentencia 2 ElseIf [(]condicin 3[)] Then sentencia 3 ... Else sentencia n End If

Por ejemplo, al efectuar una compra en un cierto almacn, si adquiri-mos ms de 100 unidades de un mismo artculo, nos hacen un descuento de un 40%; entre 25 y 100, un 20%; entre 10 y 24, un 10%; y no hay des-cuento para una adquisicin de menos de 10 unidades. La solucin que calcula el descuento a aplicar sera de la siguiente forma:

If (cc > 100) Then desc = 40.0F ' descuento 40% ElseIf (cc >= 25) Then desc = 20.0F ' descuento 20% ElseIf (cc >= 10) Then desc = 10.0F ' descuento 10% Else desc = 0.0F ' descuento 0% End If

Obsrvese que las condiciones se han establecido segn los descuen-tos de mayor a menor. Como ejercicio, piense o pruebe qu ocurrira si establece las condiciones segn los descuentos de menor a mayor.


5.4 SELECT CASE La sentencia Select permite ejecutar una de varias acciones en funcin

del valor de una expresin. Es una sentencia especial para decisiones mltiples. La sintaxis para utilizar esta sentencia es:

Select [Case] [(]expresin-test[)] Case expresin 1 [sentencias 1] [Case expresin 2] [sentencias 2] [Case expresin 3] [sentencias 3] . . . [Case Else] [sentencias n] End Select

donde expresin-test es una expresin numrica o alfanumrica, y expre-sin 1, expresin 2... representan una lista de expresiones que puede tener cualquiera de las formas siguientes:

expresin[, expresin] . . . expresin To expresin Is operador-de-relacin expresin combinacin de las anteriores separadas por comas

Aqu, expresin es cualquier expresin numrica o de caracteres del mismo tipo que expresin-test. Por ejemplo:

Case Is < x ' expresin-test < x Case 3 ' expresin-test = 3 Case x To 20 ' expresin-test = x, x+1, ...,20 Case 3, x ' expresin-test = 3, x Case -1, x To 5 ' expresin-test = -1, x, x+1, ...,5 Case "s", "SI" ' expresin-test = "s", "SI" Case Is >= 10 ' expresin-test >= 10


Cuando se utiliza la forma expresin To expresin, el valor ms peque-o debe aparecer en primer lugar.

Cuando se ejecuta una sentencia Select, Basic evala la expresin-test y busca el primer Case que incluya el valor evaluado, ejecutando a conti-nuacin el correspondiente bloque de sentencias. Si no existe un valor igual a la expresin-test, entonces se ejecutarn las sentencias a continuacin de Case Else, si se ha especificado. En cualquier caso, el control pasa a la siguiente sentencia a End Select. Por ejemplo:

Select Case x Case 1 str = "1" Case 2, 3 str = "2 3" Case 4 To 9 str = "4 a 9" Case Else str = "otro valor" End Select

En este ejemplo, si x vale 1, se asigna 1 a la variable str; si vale 2 3, se asigna 2 3 a str; si vale 4, 5, 6, 7, 8 9, se asigna 4 a 9 a str; y en cualquier otro caso, se asigna otro valor a la variable str. Cuando se pro-duce una coincidencia, se ejecuta slo el cdigo que hay hasta el siguiente Case o hasta End Select si se trata del ltimo Case.

5.5 WHILE La sentencia While ejecuta una o ms sentencias cero o ms veces,

dependiendo del valor de una expresin booleana. Su sintaxis es:

While [(]condicin[)] sentencias End While

donde condicin es cualquier expresin booleana y sentencias es un bloque de una o ms sentencias.

La ejecucin de la sentencia While sucede as:

1. Se evala la condicin y se obtiene un resultado verdadero o falso.


2. Si el resultado es falso (False), el bloque de sentencias no se ejecuta y se pasa el control a la siguiente sentencia en el programa.

3. Si el resultado de la evaluacin es verdadero (True), se ejecuta el blo-que de sentencias y el proceso descrito se repite desde el punto 1.

Por ejemplo, el siguiente cdigo, que podr ser incluido en cualquier procedimiento, solicita obligatoriamente una de las dos respuestas posibles: s/n (s o no).

While (car "s"c And car "n"c) Console.Write("Desea continuar s/n (s o no) ") car = Convert.ToChar(Console.Read()) Console.ReadLine() End While

5.6 DO ... LOOP Un Loop (lazo o bucle) repite la ejecucin de un conjunto de sentencias

mientras una condicin dada sea cierta o hasta que una condicin dada sea cierta. La condicin puede ser verificada antes o despus de ejecutarse el conjunto de sentencias. Esta sentencia presenta diferentes alternativas para su utilizacin:

Do [{While|Until} condicin] [sentencias] [Exit Do] [sentencias] Loop Do [sentencias] [Exit Do] [sentencias] Loop [{While|Until} condicin]

donde condicin es cualquier expresin que se evale a True o a False.

Esta sentencia permite realizar varias estructuras diferentes. Permite, como se puede apreciar en los formatos presentados, crear lazos o bucles con la condicin de terminacin al final o al principio del bloque de senten-cias. Por ejemplo:


Dim i As Integer = 1, suma As Integer = 0 Do While i


La sentencia Exit For permite salir de un bucle For ... Next antes de que ste finalice.

Un bucle For ... Next se ejecuta ms rpidamente cuando la variable es entera y las expresiones 1, 2, 3, constantes. Por ejemplo:

Dim i, suma As Integer 'i y suma son enteros de valor 0 For i = 1 To 99 Step 2 ' Para i=1,3,5,... hasta 99 suma = suma + i Next i System.Console.WriteLine(suma)

Si el valor de la expresin 3 es negativo, se comprueba si la variable es menor que la expresin 2, en cuyo caso se pasa a ejecutar la siguiente sentencia a Next. En otro caso, se ejecuta el bucle y se decrementa la va-riable. Este proceso se repite hasta que la variable sea menor que la expre-sin 2. Por ejemplo, el siguiente cdigo conduce al mismo resultado que el anterior.

Dim i As Integer, suma As Integer For i = 99 To 1 Step -2 ' Para i=99,97,... hasta 1 suma = suma + i Next i System.Console.WriteLine(suma)

5.8 FOR EACH ... NEXT For Each ... Next es similar a la sentencia For, con la diferencia de que

ahora se repite un grupo de sentencias por cada elemento de una coleccin de objetos o de una matriz. Esto es especialmente til cuando no conoce-mos cuntos elementos hay en la coleccin o en la matriz. Su sintaxis es la siguiente:

For Each elemento In coleccin/matriz [sentencias] [Exit For] [sentencias] Next elemento

donde elemento es una variable de un tipo compatible con el tipo de los elementos de la coleccin o de la matriz. Por ejemplo, el cdigo que se


muestra a continuacin suma los elementos de una matriz de enteros de-nominada matriz_m (las matrices sern estudiadas en un captulo posterior):

Dim matriz_m() as Integer = {1, 2, 3, 4, 5, 6} Dim x, suma As Integer For Each x In matriz_m suma = suma + x Next x System.Console.WriteLine(suma) ' suma = 21

La sentencia For de este ejemplo indica que por cada valor x en la ma-triz matriz_m se tiene que ejecutar la sentencia:

suma = suma + x

5.9 TRY ... CATCH Cuando durante la ejecucin de un programa se produce un error que

impide su continuacin, Basic lanza una excepcin que hace que se visuali-ce un mensaje acerca de lo ocurrido y se detenga la ejecucin. Cuando esto ocurra, si no deseamos que la ejecucin del programa se detenga, habr que utilizar Try para poner en alerta al programa acerca del cdigo que puede lanzar una excepcin y utilizar Catch para capturar y manejar cada excepcin que se lance. Por ejemplo, el cdigo que se muestra a continua-cin:

Dim dato1, dato2, dato3 As Integer dato1 += 1 dato3 = dato1 \ dato2 dato2 += 1 ' Otras sentencias System.Console.WriteLine(dato1 & " " & dato2 & " " & dato3)

lanzar la excepcin del tipo System.DivideByZeroException:

Excepcin no controlada: System.DivideByZeroException: Intento de dividir por cero at Test.Main() in Test.vb:line n


La informacin dada por el mensaje anterior, adems del tipo de ex-cepcin, especifica que ha ocurrido una divisin por cero en la lnea n.

Modifiquemos este cdigo con la intencin de capturar la excepcin lanzada. El resultado puede ser el siguiente:

Dim dato1, dato2, dato3 As Integer Try dato1 += 1 dato3 = dato1 \ dato2 dato2 += 1 ' Otras sentencias Catch e As System.DivideByZeroException ' Manejar una excepcin de tipo DivideByZeroException System.Console.WriteLine("Error: " & e.Message) dato3 = dato1 End Try System.Console.WriteLine(dato1 & " " & dato2 & " " & dato3)

Ahora, si la sentencia dato3 = dato1 \ dato2 da lugar a una divisin por cero, Visual Basic detendr temporalmente la ejecucin de la aplicacin y lanzar una excepcin de tipo DivideByZeroException que ser capturada por el bloque Catch. La ejecucin del programa se reanudar a partir de la primera sentencia perteneciente al bloque Catch y continuar hasta el final del programa. Se puede observar que la opcin que se ha tomado ante la excepcin lanzada ha sido suponer una divisin entre 1, esto es: dato3 = dato1. El resultado cuando finalice la aplicacin ser:

Error: Intento de dividir por cero. 1 0 1

Cuando un procedimiento lanza una excepcin, el sistema es respon-sable de encontrar a alguien que la atrape con el objetivo de manipularla. El conjunto de esos alguien es el conjunto de procedimientos especificados en la pila de llamadas hasta que ocurri el error. Por ejemplo, fijndonos en la figura siguiente, cuando se ejecute el procedimiento crearFichero y se invoque al mtodo datoLong, la pila de llamadas crecer as:

Main > crearFichero > Leer.datoLong > System.Console.ReadLine


Si al ejecutarse el mtodo ReadLine ocurriera un error, ste lanzara una excepcin de la clase IOException que interrumpira el flujo normal de ejecucin. Despus, el sistema buscara en la pila de llamadas, hacia abajo y comenzando por el propio mtodo que produjo el error, uno que imple-mente un manejador (bloque Catch) que pueda atrapar esta excepcin. Si el sistema, descendiendo por la pila de llamadas, no encontrara este mane-jador, el programa terminara.

System.Console.ReadLine

crearFichero

Leer.datoLong

Main

6Captulo6

PROCEDIMIENTOS

De la misma forma que la biblioteca .NET proporciona mtodos prede-finidos como WriteLine (a un procedimiento definido en una clase general-mente se le denomina mtodo), nosotros tambin podemos aadir a nuestro programa nuestros propios procedimientos e invocarlos de la misma forma que lo hacemos con los predefinidos.

Por ejemplo, en el programa siguiente el procedimiento Main muestra la suma de dos valores cualesquiera; dicha suma la obtiene invocando a un procedimiento sumar aadido por nosotros que recibe en sus parmetros x e y los valores a sumar, realiza la suma de ambos y utilizando la sentencia Return, devuelve el resultado solicitado por Main.

Function sumar(x As Double, y As Double) As Double Dim resultado As Double = 0 resultado = x + y Return resulta

Documents

Visual Basic Basico