Wikilibros:Libros/Lenguaje Visual Basic

Lenguaje Visual Basic

Visual Basic es un lenguaje de programación de los llamados "visuales", puesto que parte de la programación que se realiza con él se basa en la utilización de elementos visuales. La palabra "Visual" hace referencia al método que se utiliza para crear la interfaz gráfica de usuario. En lugar de escribir numerosas líneas de código para describir la apariencia y la ubicación de los elementos de la interfaz, simplemente podemos agregar objetos prefabricados en su lugar dentro de la pantalla, que ahorran mucho tiempo de programación y que sobrepasan el concepto de la programación convencional en cuanto a la estructura secuencial del programa. Tradicionalmente el lenguaje Basic (Beginners All-Purpose Symbolic Instruction Code) se ha considerado como el lenguaje adecuado para principiantes en el mundo de la programación, si bien se le achaca que no tiene la potencia suficiente para cubrir todas las expectativas de los programadores avanzados. Cierto es que aunque nos permite la creación de componentes y trabajar con objetos, otros lenguajes tienen más potencia en la programación orientada a objetos, pero a medida que han avanzado en las versiones de Visual Basic, ha aumentado su versatilidad.

Definición de Visual Basic

referencia: http://www.alegsa.com.ar/Dic/visual%20basic.php

Visual Basic es una aplicación y un lenguaje de programación desarrollado por Alan Cooper para Microsoft. Se origina en el clásico lenguaje BASIC. La primera versión salió en 1991 en un entorno relativamente sencillo para facilitar la creación de programas gráficos. Visual Basic, como su nombre lo indica, utiliza una interfaz totalmente visual.

Actualmente, los programas creados en Visual Basic sólo funcionan en Windows. La aplicación Visual Basic, permite crear ventanas, botones, menús, etc. de forma sencilla con solo arrastrar y soltar los elementos. Luego se pueden definir las apariencias, posiciones y comportamientos tanto de forma visual como utilizando códigos de programación.

Este lenguaje toma elementos de diferentes paradigmas como el orientado a objetos y el orientado a eventos.

Visual Basic suele considerarse un sistema RAD (Rapid Application Development), porque permite crear aplicaciones de forma rápida, especialmente para prototipos.

Origen del Nombre. http://www.elguille.info/colabora/NET2005/Percynet_Historia_Visual_Basic_NET.htm

VISUAL supongo que la mayoría sabe a que se refiere, y esto es, a que es un lenguaje con un entorno visual, con un entorno gráfico, es decir, un lenguaje que incluye una interfaz de desarrollo gráfico. La otra parte es BASIC B.A.S.I.C. significa: Beginner’s All-purpose Symbolic Instruction Code, traduciendo esto sería: Código de instrucciones de uso universal para principiantes. Basic es un lenguage de programación que actúa como un intermediario entre el operador y el computador. Mediante el vocabulario y las reglas Basic, se le ordena al computador lo que se quiere que haga y el PC transforma estas instrucciones para poder ejecutarlas. Otros lenguajes de programación que pueden emplearse son el Pascal, Fortran y Ensamblador. BASIC es traducido a código binario, también se puede escribir programas en código binario pero es muy difícil por eso crearon el Basic. BASIC es un lenguaje de programación desarrollado por los estadounidenses John Kemeny y Thomas Kurtz en el Dartmouth College. La versión original del lenguaje Basic fue creada en el año 1964

Objetivo: http://www.scribd.com/doc/9817828/Ceballos-Microsoft-Visual-Basic-NET-Curso-de-programacion

El objetivo de visual basic es permitir a todos los desarrolladores en general abordar el desarrollo de aplicaciones complejas con facilidad, eliminando los errores de programación más comunes en C y C++, por ejemplo:

. El recolector de basura libera el programador del peso que conlleva el manejo manual de la memoria. . Todos los objetos creados dinámicamente así como las matrices son inicializados a cero, así como las variables locales. . Visual Basic unifica el sistema de tipo, permitiendo ver a cada uno de ellos en el lenguaje como un objeto.

Permite desarrollar una amplia gama de aplicaciones para la nueva plataforma de Microsoft .NET la cual se caracteriza por proporcionar utilidades y servicios para sacar un provecho total tanto de la informática como de las comunicaciones.

Clásico hola mundo

Programa Hola Mundo

Después del Click

Compilador http://es.wikipedia.org/wiki/Microsoft_Visual_Basic#Compilador El compilador de Microsoft genera ejecutables que requieren una DLL para que funcionen, en algunos casos llamada MSVBVMxy.DLL (acrónimo de "Microsoft Visual Basic Virtual Machine x.y", siendo x.y la versión) y en otros VBRUNXXX.DLL ("Visual Basic Runtime X.XX"), que provee todas las funciones implementadas en el lenguaje. Además existen un gran número de bibliotecas (DLL) que facilitan el acceso a muchas funciones del sistema operativo y la integración con otras aplicaciones.

Just-In-Time http://msdn.microsoft.com/es-es/library/5hs4b7a6(VS.80).aspx

La depuración Just-In-Time es una característica que inicia automáticamente el depurador de Visual Studio cuando un programa que se ejecuta fuera de Visual Studio se encuentra con un error grave. La depuración Just-In-Time permite examinar el error antes de que el sistema operativo finalice la aplicación. El depurador de Visual Studio no necesita estar en ejecución cuando se produce el error.

Si se produce un error mientras la depuración Just-In-Time está habilitada, se abre un cuadro de diálogo que le preguntará si desea depurar el programa y qué depurador desea utilizar.

Si un programa que se ejecuta como otro usuario inicia un error grave, aparecerá un cuadro de diálogo de advertencia de seguridad antes de que se inicie el depurador. Para obtener más información, vea Advertencia de seguridad: La asociación a un proceso que no es de confianza puede ser peligrosa.

Representando Palabras, Números, y Valores con Variables

Los tipos de datos en Visual Basic determinan que tipos de valores o datos pueden ser almacenados en una variable, y también como son almacenados esos datos. ¿Por qué hay diferentes tipos de datos? La razón de esto es por la siguiente situación: si se tiene tres variables, donde dos de ellas almacenan números mientras que la tercera almacena un nombre, se puede aplicar la aritmética usando las dos primeras, pero no se puede aplicar la aritmética con el nombre. Asignar un tipo de dato a una variable hace más fácil de determinar cómo puede, o no, ser usada esta variable.

Nota: Los tipos de datos también son usados en otros elementos de programación tal como ser constantes, propiedades y funciones.

Tipos de datos numéricos

La mayoría de los programas computacionales trabajan con números de alguna manera u otra. Ya que hay diferentes maneras de expresar números, Visual Basic tiene varios tipos de datos numéricos para trabajar de manera más eficiente. El tipo de dato numérico que más se usa es el Integer, que es usado para representar un número entero (un numero sin parte fraccionaria). Al elegir un tipo de dato para representar números enteros bastante grandes, se deberá usar el tipo de dato Long que puede almacenar números más grandes que aproximadamente nueve trillones; mientras no se necesite almacenar un numero de tal magnitud un Integer es más eficiente. No todos los números son enteros; por ejemplo, cuando se dividen dos números enteros, el resultado es un número entero mas una parte fraccionaria. El tipo de dato Double es usado para representar números con una parte fraccionaria.

Nota: Hay tipos de datos numéricos adicionales como el Decimal, Short, SByte, y UInteger; estos son típicamente usados en programas muy largos donde la memoria en uso y velocidad son importantes.

Tipos de datos para texto

La mayoría de los programas también manejan texto, ya sea mostrando información al usuario o capturando texto ingresado por el usuario. El texto es almacenado en un tipo de dato String, que puede contener series de letras, números, espacios, y otros caracteres. Un String puede ser de cualquier longitud, desde una oración o un párrafo a un solo caracter o inclusive estar vacía (un null string). Para una variable que solo va a representar un solo caracter, existe también el tipo de dato Char. Si solo se va almacenar un carácter en una solo variable, se puede usar un tipo de dato Char en vez de un String.

Otros tipos de datos

Además de texto y números, los programas hay veces necesitan almacenar otros tipos de información, como ser verdadero o falso, una fecha, un dato que tiene un significado especial para el programa.
Para valores que pueden ser representados como verdadero/falso, si/no, o encendido/apagado, Visual Basic tiene el tipo de dato Boolean. Una variable Boolean puede almacenar uno de dos valores: True o False.
Aunque las fechas se pueden representar con números, el tipo de dato Date hace fácil calcular fechas o tiempo, como ser el número de días hasta cumplir años o la cantidad de minutos hasta el almuerzo.
Cuando se necesita almacenar más de un tipo de dato en una solo variable, se usa un tipo de dato compuesto. Los tipos de datos compuestos incluyen arreglos, estructuras, y clases. Estos tipos de datos se verán más adelante.
Finalmente, hay casos en los que el tipo de dato que se necesita almacenar sea diferente con el tiempo. El tipo de dato Object permite declarar una variable y definir su tipo de dato más adelante. Este tipo de dato se verá con más detalle más adelante.

Tipos de Datos Numéricos

Visual Basic brinda varios tipos de datos numéricos para manejar números en varias representaciones. Los tipos integrales representan solo números enteros (positivos, negativos, y cero), y los tipos no integrales representan números enteros y fraccionarios.

Tipos numéricos integrales

Los tipos numéricos integrales son aquellos que representan solamente números sin parte fraccionaria. Los tipos integrales con signo son el tipo de dato SByte (8 bit), el tipo de dato Short (16 bit), el tipo de dato Integer (32 bit), y el tipo de dato Long (64 bit). Si una variable siempre almacena números enteros en vez de fraccionarios, se declara como uno de estos tipos. Los tipos integrales sin signo son el tipo de dato Byte (8 bit), el tipo de dato UShort (16 bit), el tipo de dato UInteger (32 bit), y el tipo de dato ULong (64 bit). Si una variable contiene datos binarios, o de naturaleza desconocida, se declara como uno de estos tipos.

Desempeño Las operaciones aritméticas se realizan con más rapidez con los tipos integrales que con otros tipos de datos. Se realizan más rápido con los tipos Integer y UInteger en Visual Basic.

Enteros grandes Si se necesita almacenar un entero más grande que lo permisible en un tipo de dato Integer, se puede usar el tipo de dato Long en sustitución. Las variables Long pueden almacenar desde -9,223,372,036,854,775,808 hasta 9,223,372,036,854,775,807. Las operaciones con los Long son un poco más lentas que con los Integer. Si se necesitara almacenar magnitudes aun más grandes, se usa el tipo de dato Decimal. En estas variables se pueden almacenar números desde -79,228,162,514,264,337,593,543,950,335 hasta 79,228,162,514,264,337,593,543,950,335 si no se usan posiciones decimales. Sin embargo, las operaciones con números Decimal son considerablemente más lentas que con cualquier otro tipo de dato numérico.

Enteros pequeños Si no se necesita todo el rango del tipo de dato Integer, se puede usar el tipo de dato Short, que puede almacenar enteros desde -32,768 hasta 32,767. Para el rango más pequeño de los enteros, el tipo de dato SByte almacena enteros desde -128 hasta 127. Si se tiene un número bastante grande de variables que almacenan enteros pequeños, el tiempo de ejecución del lenguaje común hay veces puede almacenar variables Short y Sbyte más eficientemente y ahorrar el consumo de memoria. Sin embargo, las operaciones con el Short y Sbyte son un poco lentas en comparación con el Integer.

Enteros sin signo Si una variable nunca necesita almacenar números negativos, se pueden usar los tipos sin signo como ser Byte, UShort, UInteger, y ULong. Cada uno de estos tipos de datos puede almacenar un número positivo del doble de magnitud que su correspondiente tipo con signo (SByte, Short, Integer y Long). En términos de desempeño, cada tipo sin signo es exactamente tan eficiente como su correspondiente tipo con signo. En particular, UInteger comparte con Integer la distinción de ser el más eficiente de todos los tipos elementales de datos numéricos.

Tipos numéricos no integrales

Los tipos numéricos no integrales son aquellos que representan números enteros y fraccionarios.
Estos tipos de datos son el Decimal (128 bit), el tipo de dato Single (32 bit), y el tipo de dato Double (64 bit). Todos son tipos con signo. Si una variable puede llegar a contener una fracción, se declara como uno de estos tipos.

Decimal no es un tipo de dato de punto flotante. Los números Decimal tienen un valor entero binario y un factor entero de escala que especifica que porción del valor es una fracción decimal.

Los números de punto flotante (Single y Double) tienen rangos más largos que los números Decimal, pero pueden ser objeto de errores de redondeo. Los tipos de punto flotante soportan menos dígitos significativos que un Decimal pero pueden representar valores de más grande magnitud.

Los valores de números no integrales pueden ser expresados como mmmEeee, en donde mmm es la mantisa (los dígitos significativos) y eee es el exponente (una potencia de 10). Los valores positivos más grandes de los tipos no integrales son: 7.9228162514264337593543950335E+28 para el Decimal, 3.4028235E+38 para el Single, y 1.79769313486231570E+308 para el Double.

Desempeño
El Double es el más eficiente de los tipos de datos fraccionarios, porque los procesadores en las plataformas actuales desempeñan las operaciones de punto flotante con doble precisión. Sin embargo, las operaciones con los Double no son tan rápidas como con los tipos de datos integrales como ser el Integer.

Magnitudes pequeñas
Para números con magnitudes pequeñas más cercanas a 0, las variables Double pueden almacenar números tan pequeños como -4.94065645841246544E–324 para valores negativos y 4.94065645841246544E-324 para valores positivos.

Números fraccionarios pequeños
Si no se necesita todo el rango de un tipo de dato Double, se puede usar el tipo de dato Single, que puede almacenar números con punto flotante desde -3.4028235E+38 hasta 3.4028235E+38. Las magnitudes más pequeñas más cercanas a 0 para las variables Single son -1.401298E-45 para valores negativos y 1.401298E-45 para valores positivos. Si se tiene un numero bastante grande de variables que almacenan números pequeños de punto flotante, el tiempo de ejecución del lenguaje común puede hay veces almacenar las variables Single más eficientemente y ahorrar el consumo de memoria.

Palabras y Texto: Usando Variables String para Organizar Palabras

El tipo de dato String se usa para representar palabras y texto.

¿Qué es una cadena?

Una cadena es cualquier serie de caracteres, así como letras, números, caracteres especiales, y espacios. Las cadenas pueden ser frases legibles para el ser humano u oraciones, como “El perro es el mejor amigo del hombre”, o una combinación ilegible, como “@4G&fr!?^ 21(-H”. Las variables String son creadas como cualquier otra variable: primero declarando la variable y asignándole un valor, como se muestra aquí.

Visual Basic Dim aCadena As String = "Esta es una cadena"

Cuando se asigna texto real (también llamado literal de cadena) a una variable String, el texto debe estar encerrado por comillas (""). Se puede usar el carácter = para asignar una variable String a otra variable String, como se muestra en el siguiente ejemplo.

Visual Basic 	
Dim aCadena As String = "Esta es una cadena"

Dim bCadena As String = ""
bCadena = aCadena

El código previo asigna el mismo valor de aCadena al valor de bCadena.
Se puede usar el carácter ampersand (&) para combinar dos o más cadenas en una nueva cadena, como se muestra aquí. Esto se conoce también como concatenación.

Visual Basic 	
Dim aCadena As String = "usando variables"
Dim bCadena As String = "string"
Dim cCadena As String = ""
cCadena = aCadena & bCadena

El ejemplo previo declara tres variables String y respectivamente le asigna usando variables y string a las primeras dos, y después asigna los valores combinados de las primeras dos a la tercera variable. El valor de cCadena es usando variablesstring porque no hay espacio al final de aCadena o al principio de bCadena. Las dos cadenas solo están unidas entre sí. Si se quisiera agregar espacios o cualquier otra cosa entre dos cadenas, se debe hacer usando literales de cadena, como " ", como se muestra aquí.

Visual Basic 	
Dim aCadena As String = "usando variables"
Dim bCadena As String = "string"
Dim cCadena As String = ""
cCadena = aCadena & " " & bCadena

El texto que está contenido en cCadena ahora se lee usando variables string.

Matrices: Variables Que Representan Más De Un Valor

Las variables se usan para almacenar diferentes tipos de datos para ser usados por un programa. Hay otro tipo de variable llamada matriz que brinda una manera conveniente para almacenar varios valores del mismo tipo.
Supongamos que estamos escribiendo un programa para un equipo de beisbol y queremos almacenar los nombres de los jugadores que se encuentran en el campo. Se pude crear nueve variables String, una por cada jugador, o crear una variable matriz que se parecería al siguiente código.

Visual Basic 	
Dim jugadores() As String

Se declara una variable matriz poniendo paréntesis después del nombre de la variable. Si se sabe cuantos valores se tienen que almacenar, también se puede especificar el tamaño del matriz en la declaración de la siguiente manera.

Visual Basic 	
Dim jugadores(8) As String

Una matriz consiste en un numero de valores, o elementos, comenzando con el elemento 0 y terminando en el numero especificado en la declaración. El tamaño de la matriz es 9, ya que en este caso contiene los elementos 0 al 8 para un total de nueve elementos. Cuando se quiere referir a uno de los jugadores del equipo, solo se resta 1. Por ejemplo, para referirse al primer jugador, se referencia el elemento 0, para referirse al noveno jugador, se referencia el elemento 8.

Asignando valores a una matriz

Así como otros tipos de valores, se puede asignar valores a una matriz. Para hacerlo, se refiere al número del elemento como parte de la asignación, como se muestra.

Visual Basic 	
jugadores(0) = "Juan"
jugadores(3) = "Mario"

En el código anterior, el valor Juan es asignado al primer elemento de la matriz (índice 0) y el valor Mario es asignado al cuarto elemento de la matriz (índice 3). Los elementos de la matriz no tienen que ser asignados en orden, y cualquier valor no asignado tendrá un valor por omisión; en este caso, una cadena vacía.
Así como en otros tipos de valores, se puede declarar y asignar valores a una matriz en una línea simple, como sigue.

Visual Basic 	
Dim jugadores() As Integer = {1, 2, 3, 4, 5, 6, 7, 8, 9}

En este caso, las llaves indican una lista de valores. Los valores son asignados a elementos en la lista ordenada. En este caso el tamaño de la matriz no se especifica; es determinado por el número de elementos listados.

Recuperando valores de una matriz

Así como se usaron números para especificar la posición de un elemento en una matriz, se usa el número del elemento para especificar el valor que se quiere recuperar.

Visual Basic 	
Dim alBate As String
alBate = jugadores(3)

Este código recupera el cuarto elemento de la matriz y se lo asigna a la variable cadena alBate.

Manejo de Excepciones

Visual Basic admite un control de excepciones (errores) tanto estructurado como no estructurado. El control de errores estructurado y no estructurado permite establecer un plan para detectar posibles errores, y así impedir que éstos interfieran en los supuestos objetivos de la aplicación. Si se produce una excepción en un método que no esté preparado para controlarla, la excepción se propagará de vuelta al método de llamada o al método anterior. Si el método anterior tampoco tiene controlador de excepciones, la excepción se propagará de vuelta al llamador del método, y así sucesivamente. La búsqueda de un controlador continuará hasta la pila de llamadas, que es la serie de procedimientos a los que se llama dentro de la aplicación. Si ésta tampoco encuentra un controlador para la excepción, se mostrará un mensaje de error y la aplicación finalizará.

Nota Un método puede contener un método de control de excepciones estructurado o uno no estructurado, pero no ambos. Control estructurado de excepciones En el control estructurado de excepciones, los bloques de código se encapsulan y cada uno de ellos tiene uno o varios controladores asociados. Cada controlador especifica una forma de condición de filtro para el tipo de excepción que controla. Cuando el código de un bloque protegido genera una excepción, se busca por orden en el conjunto de controladores correspondientes y se ejecuta el primero que contenga una condición de filtro coincidente. Un método puede tener varios bloques de control estructurado de excepciones y dichos bloques pueden además estar anidados. La instrucción Try...Catch...Finally se utiliza específicamente para el control estructurado de excepciones. Aquí en este manualillo solo se explicará este método, el control estructurado de excepciones. Visual Basic admite el control estructurado de excepciones, que facilita la tarea de crear y mantener programas mediante controladores de errores consistentes y exhaustivos. El control estructurado de excepciones es un código diseñado para detectar y dar respuesta a los errores que se producen durante la ejecución, mediante la combinación de una estructura de control (similar a Select Case o While) con excepciones, bloques de código protegidos y filtros.

El uso de la instrucción Try…Catch…Finally permite proteger bloques de código con posibilidades de generar errores. Los controladores de excepciones pueden anidarse, y las variables que se declaren en cada bloque tendrán un ámbito local.

Try ‘El código que puede producir el error Catch [filtros opcionales o tipos de errores a capturar] ‘Código para cuando se produzca un error

[bloques catch adicionales]

Finally ‘Código para cuando aparezca o no un error End Try

El bloque Try de un controlador de excepción Try...Catch...Finally contiene la sección del código que el controlador de errores va a supervisar. Si se produce un error durante la ejecución de cualquier parte del código de esta sección, Visual Basic examinará cada instrucción Catch de Try...Catch...Finally hasta que encuentre una cuya condición coincida con el error. Si la encuentra, el control se transferirá a la primera línea de código del bloque Catch. Si no se encuentra una instrucción Catch coincidente, la búsqueda continuará en las instrucciones Catch del bloque Try...Catch...Finally exterior que contiene el bloque en el que ocurrió la excepción. Este proceso se prolongará a lo largo de toda la pila hasta que se encuentre un bloque Catch coincidente en el procedimiento actual. De no encontrarse, se produciría un error. El código de la sección Finally siempre se ejecuta en último lugar, inmediatamente antes que el bloque de control de errores pierda su ámbito, con independencia de que se ejecute el código de los bloques Catch. Sitúe el código de limpieza (el código que cierra los archivos y libera los objetos, por ejemplo) en la sección Finally.

Filtrar errores en el bloque Catch Los bloques Catch ofrecen tres opciones para filtrar errores específicos. En una de ellas, los errores se filtran basándose en la clase de la excepción (en este caso ClassLoadException), como se muestra en el siguiente código: Try

  ' "Try" block.

Catch e as ClassLoadException

  ' "Catch" block.

Finally

  ' "Finally" block.

End Try Si se produce un error ClassLoadException, se ejecuta el código del bloque Catch especificado. En la segunda opción para filtrar errores, la sección Catch puede filtrar cualquier expresión condicional. Un uso común de este formato del filtro Catch consiste en comprobar números de error específicos, como se muestra en el código siguiente: Try

  ' "Try" block.

Catch When ErrNum = 5 'Type mismatch.

  ' "Catch" block.

Finally

  ' "Finally" block.

End Try

Cuando Visual Basic encuentra el controlador de errores coincidente, ejecuta el código de este controlador y pasa el control al bloque Finally.

Nota Al buscar un bloque Catch que controle una excepción, se evalúa el controlador de cada bloque hasta encontrar uno que coincida. Puesto que estos controladores pueden ser llamadas a funciones, es posible que se produzcan efectos secundarios no esperados; por ejemplo, una llamada de este tipo puede cambiar una variable pública y provocar que ésta se utilice en el código de un bloque Catch distinto que termina controlando la excepción. La tercera alternativa, consiste en combinar las primeras dos opciones y utilizar ambas para el control de excepciones. El bloque Finally siempre se ejecuta, con independencia de cualquier otra acción que tenga lugar en los bloques Catch anteriores. No puede utilizar Resume o Resume Next en el control estructurado de excepciones.

Ahora se realizarán una serie de ejemplos que aclararán lo expuesto

Ejemplo 1.

Module Module1

   Sub Main()
       Dim sValor As String
       Dim iNumero As Integer
       Try
           'Aqui comienza el control de errores
           Console.WriteLine("Introducir un número")
           sValor = Console.ReadLine
           'Si no hemos introducido ningún número
           iNumero = sValor 'aquí se producira un error

       Catch
           'Si se produce un error, se generará una excepción
           'que capturamos en este bloque de código
           'manipulador de excepción, definido por Catch
           Console.WriteLine("Error al introducir el número" & ControlChars.CrLf & "el valor {0} es incorrecto", sValor)
       End Try
       Console.Read()
   End Sub

End Module

Esta y las siguientes 2 líneas no pertenecen al código anterior Observen que antes de module1 no están declaradas Option Explicit On o Option Strict On.

Ejemplo 2. El clásico de la división por cero el que está en todos los libros

Module Module1

   Sub Main()
       Dim x As Integer = 5
       Dim y As Integer = 0
       Try
           x /= y
       Catch ex As Exception When y = 0
           Console.WriteLine(ex.Message)
       Finally
           Console.WriteLine("Este código siempre se ejecuta")
       End Try
       Console.Read()
   End Sub

End Module

Esta y las siguientes 2 líneas no pertenecen al código anterior Observen que antes de module1 no están declaradas Option Explicit On o Option Strict On.

Otra forma de generar la anterior excepción es:

Ejemplo 3

Module Module1

   Sub Main()
       Dim x As Integer = 0
       Try
           Dim y As Integer = 100 / x
       Catch e As ArithmeticException
           Console.WriteLine("ArithmeticException Handler: {0}", e.ToString())
       Catch e As Exception
           Console.WriteLine("Generic Exception Handler: {0}", e.ToString())
       End Try
       Console.Read()
   End Sub

End Module

Ejemplo 4

El siguiente ejemplo es el mismo del ejemplo 1 pero se le adicionó al final más código

Module Module1

   Sub Main()
       Dim sValor As String
       Dim iNumero As Integer
       Try
           'Aqui comienza el control de errores
           Console.WriteLine("Introducir un número")
           sValor = Console.ReadLine
           'Si no hemos introducido ningún número
           iNumero = sValor 'aquí se producira un error

       Catch
           'Si se produce un error, se generará una excepción
           'que capturamos en este bloque de código
           'manipulador de excepción, definido por Catch
           Console.WriteLine("Error al introducir el número" & ControlChars.CrLf & "el valor {0} es incorrecto", sValor)

       End Try
       Dim dtFecha As Date
       Console.WriteLine("Introducir una fecha")
       'Si ahora se produce un error,
       'al no disponer de una estructura para controlarlo
       'se cancelará la ejecución
       dtFecha = Console.ReadLine
       Console.WriteLine("La fecha es {0}", dtFecha)
       Console.ReadLine()
   End Sub

End Module

Se debe tener en cuenta la forma de capturar los errores desde los más específicos hasta los más generales de lo contrario los errores serán tomados dentro del primer catch no permitiendo capturar el error específico que necesitamos. Por ejemplo en el ejercicio anterior el catch es muy general esto quiere decir que cualquier error que se produzca entrará a este bloque.

Gramatica BNF

Module = { Import } SS 
Import = IMPORT "(" Ident ")" ";" 
SS = (Var | E) { ";" (Var | E) } [ ";" ] 
Var = VAR "(" Ident ")" 
E = Value 
| E BinOp E 
| UnOp E 
| "(" E ")"
| E "(" [ E { "," E } ] ")" 
| E "[" E "]" 
| Ident "=" E 
| Statement 
| FieldRef 
Value = nil | Bool | String | Real | Integer | Sequence 
Bool = XFTRUE "(" ")" | XFFALSE "(" ")" 
String = "’" { Char } "’" | ’"’ { Char } ’"’
Real = Integer [ Fraction ] [ Exponent ]
Fraction = "." Integer 
Exponent = ( "e" | "E" ) [ "+" | "-"] Integer 
Integer = Digit { Digit } 
Sequence = "[" [ E { "," E } ] "]" 
BinOp = "+" | "-" | "*" | "/" | DIV | MOD 
| "<" | "<=" | "==" | "!=" | ">" | ">=" 
| AND | OR 
| "|" | "?"
UnOp = "-" | "+" | "!"
Statement = WhileStat | IfStat | FunStat | EveryStat | ConcurrentStat | ReturnStat<br>
WhileStat = WHILE SS DO SS END
IfStat = IF SS THEN SS [ ElseStat ] END
ElseStat = ELSE SS | ELSIF SS THEN SS [ ElseStat ]
FunStat = FUN "(" "(" [ Ident { "," Ident } ] ")" "," SS ")"
EveryStat = FOREACH Ident IN E DO SS END
ConcurrentStat = BEGINCONCURRENT SS2 ENDCONCURRENT
SS2 = (Var | E) { CONC (Var | E) }
ReturnStat = RETURN [E]
FieldRef = E "." Ident [ "(" [ E { "," E } ] ")" ]
Ident = Letter { Letter | Digit }
229
Digit = "0" .. "9"
Letter = "a" .. "z" | "A" .. "Z"

Caracteristicas Especificas

Adicionalmente a las funciones del Upgrade Wizard de Microsoft, el Visual Basic Upgrade Companion™ incorpora las siguientes características:

Brinda la posibilidad de generar C# directamente desde el código fuente de Visual Basic 6.0.
Posee una interfaz gráfica (“Upgrade Manager”) que mejora la experiencia del usuario y facilita el proceso de migración de Visual Basic a .NET. Permite la creación de perfiles de migración específicos mediante la selección y aplicación de instrucciones para convertir de VB6 a .NET un proyecto determinado.
Actualiza el modelo de datos de ADO a ADO.NET
Permite la migración de aplicaciones multi-proyectos y con código mixto de ASP y VB6
Infiere los tipos de datos más apropiados para variables, parámetros y valores de retorno, evitando el uso de tipos de datos genéricos.
Promueve el uso de librerías nativas de .NET en lugar de las librerías de compatibilidad de Visual Basic
Soporta la migración de numerosos controles ActiveX hacia controles Windows Forms que ofrecen una funcionalidad similar
Realiza análisis sobre el código con el fin de detectar patrones que pueden ser convertidos a estructuras típicas de .NET.
Convierte el código no estructurado a estructurado, reduciendo la presencia de “código spaghetti”y mejorando el mantenimiento y evolución de la aplicación migrada. Esto incluye la conversion de patrones frecuentemente utilizados para el manejo de errors. Por ejemplo, el Visual Basic Upgrade Companion reconoce los patrones de “On Error Goto” y “On Error Resume Next” y los remplaza con la estructura “Try-Catch” de .NET.

Para más información sobre nuestras soluciones de migración de Visual Basic, visite las páginas de servicios para migrar de VB a .NET, del programa de capacitación y del Visual Basic Upgrade Companion en nuestro sitio principal (en inglés), o contáctenos directamente para discutir sus necesidades y requerimientos específicos.

Variables

Una variable es un identificador del programa que guarda un valor que puede ser modificando durante el transcurso de dicha aplicación.
Declaración
La declaración de una variable es el proceso por el cual comunicamos al compilador que vamos a crear una nueva variable en el programa.
Para declarar una variable utilizaremos la palabra clave Dim, seguida del identificador o nombre que daremos a dicha variable. Ver Código fuente 49

Sub Main()
Dim MiValor
End Sub

Asignación de valor

Para asignar un valor a una variable utilizaremos el operador de asignación: el signo igual ( = ), situando a su izquierda la variable a asignar, y a su derecha el valor. Ver Código fuente 53

Dim Cuenta As Integer
Cuenta = 875

Según el tipo de dato de la variable, puede ser necesario el uso de delimitadores para encerrar el valor que vamos a asignar.

Tipos numéricos. Las variables de tipos de datos numéricos no necesitan delimitadores, se

asigna directamente el número correspondiente. Si necesitamos especificar decimales, utilizaremos el punto ( . ) como carácter separador para los decimales

Cadenas de caracteres. En este caso es preciso encerrar la cadena entre comillas dobles ( " ).

Programación con Visual Basic .NET © Grupo EIDOS

Fechas. Al asignar una fecha a una variable de este tipo, podemos encerrar dicho valor entre

el signo de almohadilla ( # ) o comillas dobles ( " ). El formato de fecha a utilizar depende del delimitador. Cuando usemos almohadilla la fecha tendrá el formato Mes/Día/Año; mientras que cuando usemos comillas dobles el formato será Día/Mes/Año.

Las fechas pueden contener además información horario que especificaremos en el formato Hora:Minutos:Segundos FranjaHoraria. En el caso de que no indiquemos la franja horaria (AM/PM) y si estamos utilizando el signo almohadilla como separador, el entorno insertará

automáticamente los caracteres de franja horaria correspondientes.

Tipos lógicos. Las variables de este tipo sólo pueden tener el valor True (Verdadero) o False

(Falso).
Además de asignar valores como acabamos de explicar, podemos asignar el contenido de una variable a otra o el resultado de una expresión, como veremos más adelante en el apartado dedicado a operadores. El Código fuente 54 muestra unos ejemplos de asignación a variables, que después visualizamos en la consola.

Sub Main()
Dim ImporteFac As Integer
Dim Precio As Double
Dim Valor As String
Dim FhActual As Date
Dim FhNueva As Date
Dim FhCompletaUno As Date
Dim FhCompletaDos As Date
Dim FhHora As Date
Dim Correcto As Boolean
ImporteFac = 875
Precio = 50.75
Valor = "mesa"
FhActual = #5/20/2001# ' mes/día/año
FhNueva = "25/10/2001" ' dia/mes/año
FhCompletaUno = #10/18/2001 9:30:00 AM#
FhCompletaDos = "7/11/2001 14:22:00"
FhHora = #5:40:00 PM#
Dim NuevaCadena As String
NuevaCadena = Valor ' asignar una variable a otra
Correcto = True
' mostrar variables en la consola
Console.WriteLine("Variable ImporteFac: {0}", ImporteFac)
Console.WriteLine("Variable Precio: {0}", Precio)
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable FhActual: {0}", FhActual)
Console.WriteLine("Variable FhNueva: {0}", FhNueva)
Console.WriteLine("Variable FhCompletaUno: {0}", FhCompletaUno)
Console.WriteLine("Variable FhCompletaDos: {0}", FhCompletaDos)
Console.WriteLine("Variable FhHora: {0}", FhHora)
Console.WriteLine("Variable NuevaCadena: {0}", NuevaCadena)
Console.WriteLine("Variable Correcto: {0}", Correcto)

Corto Circuito

Los operandos de las expresiones logical-AND y logical-OR se evalúan de izquierda a derecha. Si el valor del primer operando es suficiente para determinar el resultado de la operación, el segundo operando no se evalúa. Esto se denomina evaluación de "cortocircuito". En Visual Basic .NET, se evalúan tanto los operandos de logical-AND como los de logical-OR, independientemente del resultado del primer operando. Estos operadores no se comportan igual que en Microsoft Visual C# .NET. El comportamiento de estos operadores es similar al que tienen en Microsoft Visual Basic 6.0. Por tanto, los operadores logical-AND y logical-OR no siguen la evaluación de "cortocircuito." No obstante, existen dos nuevos operadores en Visual Basic .NET (AndAlso y OrElse). Puede utilizar estos operadores en lugar de los operadores logical-AND y logical-OR, respectivamente. Puede tener la funcionalidad de evaluación de "cortocircuito" en Visual Basic .NET utilizando estos operadores.

Código de ejemplo en Visual Basic .NET

En la siguiente sección se muestra la evaluación de "cortocircuito" en Visual Basic .NET.

Public Function FalseFunc() As Boolean
        MsgBox("Function Returning False")
        FalseFunc = False
    End Function

    Public Function TrueFunc() As Boolean
        MsgBox("Function Returning True")
        TrueFunc = True
    End Function

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        If FalseFunc() And TrueFunc() Then
            'Do Nothing
        End If
    End Sub

    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
        If TrueFunc() Or FalseFunc() Then
            MsgBox("Both function are called.")
        End If
    End Sub

El resultado indica que los operadores logical-AND y logical-OR se tratan de la misma forma en Visual Basic .NET y en Visual Basic 6.0. De forma predeterminada, la evaluación de "cortocircuito" no se produce en Visual Basic .NET con los operadores logical-AND y logical-OR. En Visual Basic .NET, es posible utilizar los operadores AndAlso y OrElse en lugar de los operadores logical-AND y logical-OR, respectivamente. Puede tener la funcionalidad de evaluación de "cortocircuito" en Visual Basic .NET utilizando estos nuevos operadores. Los pasos siguientes muestran la evaluación de "cortocircuito" en Visual Basic .NET:

Private Function TrueFunc() As Boolean
      MessageBox.Show("Function Returning True")
      Return True
   End Function

   Private Function FalseFunc() As Boolean
      MessageBox.Show("Function Returning False")
      Return False
   End Function

   Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
      If FalseFunc() AndAlso TrueFunc() Then
         ' Do Nothing
      End If
   End Sub

   Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
      If TrueFunc() OrElse FalseFunc() Then
         MsgBox("Only TrueFunc is called.")
      End If
   End Sub

Estructuras de control

Las estructuras de control contienen bloques de código que serán ejecutados en función del resultado obtenido al evaluar una expresión asociada a la estructura. A este proceso de redirección del flujo del programa hacia un determinado bloque de código se le denomina bifurcación Según el modo de ejecución del código que contienen, las estructuras de control se dividen en los siguientes tipos: selección y repetición.
Selección
Las estructuras de selección o decisión permiten ejecutar un bloque de código entre varios disponibles, según el resultado de la evaluación de una expresión situada en la cabecera de la estructura.

If...End If

La sintaxis de esta estructura puede aplicarse de diferentes formas en función del tipo de decisión a resolver.
Decisión simple.

La sintaxis de decisión simple se muestra en el Código fuente 135.

If Expresión Then
' código
' ......
' ......
End If

Si al evaluar Expresión se devuelve como resultado Verdadero, se ejecutarán las líneas o bloque de código comprendido entre If y End If. Si Expresión es Falso, se desviará la ejecución a la primera línea de código que haya después de End If.

Sub Main()
Dim Valor As Integer
Console.WriteLine("Introducir un número")
Valor = Console.ReadLine()
If Valor = 5 Then
Console.WriteLine("Estamos dentro de la estructura If," & _" ya que su expresión devuelve Verdadero")
End If
Console.ReadLine()
End Sub

Decisión simple en una línea.
En el caso de que sólo haya que ejecutar una instrucción sencilla cuando se cumple la expresión de la estructura, podemos omitir la palabra clave End If, escribiendo la sentencia a ejecutar en la misma línea de la declaración de la estructura If, justo a continuación de la palabra Then. La sintaxis en este caso, se simplifica.

Sub Main()
Dim Valor As Integer
Dim Resultado As Integer
Console.WriteLine("Introducir un número")
Valor = Console.ReadLine()
If Valor = 5 Then Resultado = Valor + 10
Console.WriteLine("La variable resultado contiene {0}", Resultado)
Console.ReadLine()
End Sub

Decisión doble.
Además de ejecutar un bloque de código cuando la expresión valga Verdadero, podemos también ejecutar código cuando la expresión devuelva Falso. En este caso añadiremos a la estructura la palabra clave Else.

Sub Main()
Dim Valor As Integer
Dim Resultado As Integer
Console.WriteLine("Introducir un número")
Valor = Console.ReadLine()
If Valor = 5 Then
Resultado = Valor + 10
Else
Resultado = 777
End If
Console.WriteLine("La variable resultado contiene {0}", Resultado)
Console.ReadLine()
End Sub

En este ejemplo, cuando Valor contenga 5 se ejecutará el bloque de código que hay a continuación de If, pero cuando Valor contenga un número distinto, se ejecutará el código que hay a continuación de Else. La ejecución en cualquier caso, continuará después a partir de la siguiente línea que haya a partir de la palabra clave End If.

Select Case...End Select

Se trata de una evolución en la estructura If...End If de decisión múltiple, y su trabajo consiste en evaluar una expresión y comparar el resultado con la lista de expresiones de cada uno de los casos proporcionados.
La lista de expresiones asociada a cada Case en esta estructura estará separada por comas y podrá tener alguno de los siguientes formatos:

Expresión.
ExpresiónMenor To ExpresiónMayor
Is OperadorComparación Expresión

Tras evaluar la expresión de la estructura, si se encuentra una coincidencia con alguno de los Case, se ejecuta el bloque de código situado entre dicho Case y el siguiente. En caso de que no haya ninguna coincidencia, podemos opcionalmente, ejecutar un bloque por defecto, utilizando la palabra clave Case Else. Finalizada esta estructura, la ejecución continuará a partir de la línea situada después de End

Select.
Sub Main()
Dim Valor As Integer
Console.WriteLine("Introducir un número")
Valor = Console.ReadLine()
Select Case Valor
Case 5
Console.WriteLine("El valor es 5")
Case 120, 250
Console.WriteLine("El valor es 120 ó 250")
Case 3000 To 4000
Console.WriteLine("El valor está en el rango de 3000 a 4000")
Case Is < 10
Console.WriteLine("El valor es menor de 10")
Case Else
Console.WriteLine("El valor es {0}, y no se cumple ningún caso", Valor)
End Select
Console.ReadLine()
End Sub

En el caso de que tras evaluar la expresión, haya más de un Case cuya lista de expresiones se cumpla, se ejecutará el que esté situado en primer lugar. Repetición
Estas estructuras, también denominadas bucles, ejecutan un bloque de código de forma repetitiva mientras se cumpla una condición asociada a la estructura. A cada una de las veces en que se ejecuta el código contenido en estas estructuras se le denomina iteración.

While...End While

Se trata del tipo más sencillo, ejecuta las líneas de código que contiene, mientras que la expresión situada junto a While devuelva Verdadero.

Sub Main()
Dim Valor As Integer
Dim Contador As Integer
Console.WriteLine("Introducir un número")
Valor = Console.ReadLine()
Console.WriteLine("Mostrar en consola todos los números desde 1 hasta el
introducido")
While Contador < Valor
Console.Write("-" & Contador)
Contador += 1
End While
Console.ReadLine()
End Sub

Repeat
Es similar al while . En while la Condición para que se repita el bloque de instrucciones se evalúa desde el principio del ciclo de repeticiones, en cambio, en la estructura do-while, al principio se ejecuta el bloque y luego se evalúa la condición para ver si se sigue ejecutando o no. Esto significa que el bloque se ejecutará por lo menos una vez.

num = 1;
do {
printf(“%d”, num);
num = num + 1;
} while (num<=10);
printf(“La variable num vale: %d”, num);

Esto imprime en pantalla:

1
2
3
4
5
6
7
8
9
10
La variable num vale: 11

Do...Loop

Esta estructura ejecuta un conjunto de líneas de código, en función del valor devuelto por una expresión, que a modo de condición, podemos situar al comienzo o final de la estructura. Es posible además, no utilizar la expresión de evaluación al principio o final, debiendo en ese caso, introducir alguna condición en el interior del código de la estructura, para forzar la salida del bucle y evitar caer en un bucle infinito. La instrucción Exit Do nos permite forzar la salida del bucle, pudiendo emplearla tantas veces como sea necesario.
Veamos a continuación, las diferentes variantes disponibles.

Condición al principio
La diferencia entre usar While o Until reside en que empleando While, el código del bucle se ejecutará mientras la expresión devuelva Verdadero. En el caso de Until, el código se ejecutará mientras que la expresión devuelva Falso.

Sub Main()
Dim Valor As Integer
Dim Palabra As String
Dim Contador As Integer
Dim Pruebas As Integer
' bucle con While
Do While Valor <> 200
Console.WriteLine("Introducir un número")
Valor = Console.ReadLine()
Loop
' bucle con Until
Do Until Palabra = "coche"
Console.WriteLine("Introducir una palabra")
Palabra = Console.ReadLine()
Loop
' inicializar contador,
' en este caso vamos a pedir también
' al usuario que introduzca un número,
' pero si después de cinco intentos,
' no consigue acertar, forzamos la salida
' de la estructura
Contador = 1
Do While Pruebas <> 200
Console.WriteLine("Introducir un número - Intento nro.{0}", Contador)
Pruebas = Console.ReadLine()
If Contador = 5 Then
Exit Do
Else
Contador += 1
End If
Loop
End Sub

En el último caso de este ejemplo, podemos observar como empleamos además, la anidación de diferentes estructuras, combinándolas para realizar las comprobaciones oportunas.

Condición al final.
La diferencia en este caso, consiste en que el contenido de la estructura se ejecuta al menos una vez.

Sub Main()
Dim Valor As Integer
Dim Palabra As String
' bucle con While
Do
Console.WriteLine("Introducir un número")
Valor = Console.ReadLine()
Loop While Valor <> 200
' bucle con Until
Do
Console.WriteLine("Introducir una palabra")
Palabra = Console.ReadLine()
Loop Until Palabra = "coche"
End Sub

Sin condición.
Este es el modo más sencillo de la estructura: sin incluir condición al principio o final. También es el modo más peligroso, ya que si no incluimos un control dentro del código, corremos el riesgo de caer en un bucle infinito.
En el ejemplo del Código fuente, establecemos una condición de salida mediante una estructura If dentro del bucle, que comprueba el contenido de la variable, y fuerza la salida cuando tenga un valor superior a cierto número

ub Main()
Dim Valor As Integer
Do
Console.WriteLine("Introducir un número")
Valor = Console.ReadLine()
' comprobar y salir del bucle si es necesario
If Valor > 400 Then
Exit Do
End If
Loop
End Sub

For...Next

Esta estructura ejecuta un bloque de código un número determinado de veces, establecido por un rango de valores y controlado por un contador.
El elemento Contador se inicializa con un valor y el código existente entre For y Next es ejecutado una serie de veces, hasta que el valor de Contador se iguala a Fin.
Por defecto, los incrementos de Contador son en uno, pero podemos cambiar este aspecto utilizando el modificador Step, mediante el que podemos establecer el número en el que se van a realizar los incrementos. Step también nos permite realizar decremento utilizando un número negativo. Si queremos realizar una salida de la ejecución de esta estructura antes de haber completado el número de iteraciones establecidas, podemos utilizar la instrucción Exit For, que provocará dicha salida de igual modo que el explicado anteriormente en la estructura Do...Loop.
ejemplos de uso de este tipo de bucle.

Sub Main()
Dim Contador As Integer
Dim Final As Integer
' recorrido simple del bucle
Console.WriteLine("Bucle For normal")
For Contador = 1 To 10
Console.WriteLine("Variable Contador: {0}", Contador)
Next
Console.WriteLine()
' recorrer el bucle especificando un incremento
Console.WriteLine("Bucle For con incremento")
Console.WriteLine("Introducir el número de ejecuciones para el bucle")
Final = Console.ReadLine()
For Contador = 1 To Final Step 4
Console.WriteLine("Variable Contador: {0}", Contador)
Next
Console.WriteLine()
' recorrer el bucle especificando un decremento
Console.WriteLine("Bucle For con decremento")
For Contador = 18 To 4 Step -1
Console.WriteLine("Variable Contador: {0}", Contador)
Next
Console.WriteLine()
' este bucle no se ejecutará,
' al ser mayor el valor de contador
' que el valor final, y no haber
' establecido un decremento
For Contador = 18 To 4
Console.WriteLine("Variable Contador: {0}", Contador)
Next
' recorrer el bucle y salir antes de completar
' todas las iteraciones
Console.WriteLine("Bucle For con salida antes de completar")
For Contador = 1 To 10
Console.WriteLine("Variable Contador: {0}", Contador)
If Contador = 7 Then
Exit For
End If
Next
Console.ReadLine()
End Sub

For Each...Next

Se trata de una variante de la estructura For...Next, y su misión consiste en ejecutar un bloque de código por cada uno de los elementos existentes en un array o colección.

Sub Main()
' crear un array y rellenarlo con valores
Dim lsColores() As String = {"Azul", "Verde", "Marino", "Violeta"}
Dim lsColor As String
' en cada iteración se obtiene un elemento
' del array lsColores, y se guarda en la variable lsColor
For Each lsColor In lsColores
Console.WriteLine(lsColor)
Next
End Sub