Añadir al proyecto un fichero de código existente

Si tenemos código de otro proyecto, que nos gustaría utilizar en el proyecto actual, o bien hemos escrito código utilizando un editor distinto del proporcionado por VS.NET, podemos añadirlo a nuestro proyecto utilizando la opción de menú Proyecto + Agregar elemento existente. Hemos de observar que es necesario que el código escrito esté en un fichero con extensión .VB. Por ejemplo, he utilizado el Bloc de notas para escribir un módulo que contiene un procedimiento, y lo he guardado en un fichero con el nombre MiCodigo.VB. Al utilizar la opción antes mencionada, se abrirá una caja de diálogo, con la que navegaré por las carpetas del equipo para localizar el fichero; al pulsar el botón Abrir, se añadirá dicho fichero al proyecto. Ver Figura 77

Figura 77. Agregar un fichero de código existente al proyecto.

.

Cambiar el nombre de un fichero de código

Figura 76. Cambiar el nombre de un fichero de código.

Si no queremos que el nombre de un fichero de código sea igual que alguno de los módulos que contiene, debemos abrir la ventana Explorador de soluciones, hacer clic derecho sobre el nombre del fichero de código, y elegir la opción Cambiar nombre. Esto nos permitirá dar un nuevo nombre al fichero .VB que contiene el código. Ver Figura 76.

Crear un nuevo módulo dentro de un fichero existente - III

Veamos a continuación un ejemplo. En el apartado anterior, hemos creado un nuevo módulo con el nombre Module2, creándose al mismo tiempo, un nuevo fichero de código con el nombre Module2.VB. Pues bien, para añadir otro módulo más dentro de este fichero de código, al que daremos el nombre Cuentas, tan sólo hemos de poner la declaración del nuevo módulo antes o después del existente. Ver Figura 75.

Figura 75. Inclusión de un módulo dentro de un archivo de código

Con este ejemplo intentamos demostrar que los módulos de código son totalmente independientes del archivo físico que los alberga; por tal razón, varios módulos pueden escribirse dentro del mismo archivo.

Crear un nuevo módulo dentro de un fichero existente - II

Debemos tener en cuenta que no es posible anidar módulos, es decir, no podemos declarar un módulo dentro de la declaración de un módulo ya existente. Ver Código fuente 156.

Module NombreModulo
' esto no es válido y producirá un error
Module NombreNuevo
End Module
End Module

Código fuente 156

Crear un nuevo módulo dentro de un fichero existente - I

Esto es aún más fácil, ya que en esta situación solamente debemos escribir la declaración del módulo dentro del fichero de código, utilizando las palabras clave Module...End Module, junto al nombre que vamos a dar al módulo. Ver su sintaxis en el Código fuente 155.

Module NombreModulo

' código

' ......

End Module

Código fuente 155

Agregar un nuevo módulo (y archivo) de código - II

Figura 74. Módulo recién creado.

Agregar un nuevo módulo (y archivo) de código - I

Deberemos seleccionar en el IDE de VS.NET, la opción de menú Proyecto + Agregar módulo. Esto abrirá la caja de diálogo Agregar nuevo elemento, en la que automáticamente aparecerá un nombre para el módulo, asignado por el IDE. Podemos emplear dicho nombre o escribir otro distinto. Ver Figura 73. 

Al pulsar Abrir, se creará un nuevo fichero con el nombre indicado en la caja de diálogo y la extensión .VB, que contendrá un módulo también del mismo nombre, dentro del cual podemos empezar a escribir código. Ver Figura 74.

Organización y ámbito de los elementos del lenguaje - II

En este apartado describiremos las operaciones básicas a realizar, para añadir nuevos módulos de

código a un proyecto, quitarlos, y agregar otros ya existentes. Lo comentado aquí será igualmente

válido a la hora de manejar clases en los temas dedicados a la programación orientada a objeto.

Organización y ámbito de los elementos del lenguaje - I

Archivos y módulos de código en un programa

La plataforma .NET Framework nos permite una gran flexibilidad para ordenar el código de nuestra aplicación, que debemos organizar en contenedores físicos y lógicos de código. Un contenedor físico no es otra cosa que un archivo con extensión .VB, que son los que la plataforma reconoce como archivos con código VB.NET. Podemos tener uno o varios dentro de un proyecto. Un contenedor lógico, dicho del modo más simple, es aquel elemento en el entorno de .NET que nos permite escribir en su interior declaraciones y procedimientos, que serán accesibles desde otros elementos dentro del proyecto actual, o bien desde otros proyectos, en función de su ámbito o accesibilidad. El entorno de .NET Framework dispone de varios tipos de contenedores lógicos, entre los que se encuentran los módulos, clases, interfaces, estructuras, etc. Los espacios de nombres (namespaces) son un tipo de contenedor lógico especial, cuya misión consiste en albergar al resto de contenedores lógicos; una especie de metacontenedor. La estructura básica de un contenedor lógico se muestra en la Figura 71. La configuración por defecto en este sentido para VS.NET, establece que cada vez que añadimos un nuevo módulo o clase a un proyecto, se crea un nuevo archivo con extensión .VB, que contiene el mencionado módulo o clase. El nombre utilizado es el mismo para el archivo y el módulo o clase. Sin embargo, podemos incluir varios contenedores lógicos, de igual o distinto tipo, dentro del mismo archivo de código. Ver Figura 72.

Bifurcaciones incondicionales con Goto - V

Como conclusión podemos deducir que el uso de Goto para ejecutar bloques de código dentro de un procedimiento, es una práctica totalmente desaconsejable, debido a la pérdida de estructuración del código, y complejidad en el mantenimiento del programa que producen. Ante el análisis de un determinado problema a resolver, recomendamos al lector un detallado estudio del mismo, ya que con toda seguridad, siempre dispondremos de una alternativa estructurada de escribir su algoritmo, que evite el uso de la instrucción Goto.

Bifurcaciones incondicionales con Goto - IV

Ahora veamos en el Código fuente 154, el algoritmo resuelto con la conversión a mayúsculas realizada mediante la llamada a un procedimiento. En esta ocasión, el código del programa queda mucho mejor organizado y estructurado, siendo además, más fácil su mantenimiento y lectura.

Public Sub Main()

Dim Nombre As String

Dim Ciudad As String

Dim Dato As String

Console.WriteLine("Introducir un nombre")

Nombre = Console.ReadLine()

' llamamos al procedimiento que realiza la operación de conversión

MostrarMayus(Nombre)

' ejecutamos el resto del código de este procedimiento

Ciudad = "Salamanca"

Dato = Nombre & " " & Ciudad

Console.WriteLine("Los valores unidos son: {0}", Dato)

Console.ReadLine()

End Sub

' -----------------------------

Public Sub MostrarMayus(ByVal ElNombre As String)

' en este procedimiento convertimos el parámetro a mayúsculas

Console.WriteLine("El nombre en mayúsculas es: {0}", UCase(ElNombre))

End Sub

Código fuente 154

Bifurcaciones incondicionales con Goto - III

A continuación vamos a proponer un problema que abordaremos aportando una solución mediante dos vías: una que emplee Goto y otra estructurada, para ver las diferencias entre cada una de ellas. Debemos introducir un nombre mediante la ventana de la consola, y mostrarlo convertido a mayúsculas, para posteriormente, concatenar dicho nombre con otra cadena y mostrar el resultado. Veamos en el Código fuente 153 la versión de este algoritmo, con la fase de conversión a mayúsculas realizada utilizando una etiqueta a la que llamaremos con Goto.

Public Sub Main()

Dim Nombre As String

Dim Ciudad As String

Dim Dato As String

Console.WriteLine("Introducir un nombre")

Nombre = Console.ReadLine()

' saltamos con Goto a la etiqueta MostrarMayus

GoTo MostrarMayus

' estas líneas no se ejecutarán

Ciudad = "Salamanca"

Dato = Nombre & " " & Ciudad

Console.WriteLine("Los valores unidos son: {0}", Dato)

MostrarMayus:

' en esta etiqueta de código mostramos el valor

' de la variable en mayúsculas

Console.WriteLine("El nombre en mayúsculas es: {0}", UCase(Nombre))

Console.ReadLine()

End Sub

Código fuente 153

Bifurcaciones incondicionales con Goto - II

En el ejemplo del Código fuente 152, podemos ver que para ejecutar un bloque de código lo situamos en una etiqueta, y mediante Goto se realiza una bifurcación a la misma. Sin embargo, el inconveniente con esta construcción reside en que una vez ejecutado el código de la etiqueta, no se devuelve el flujo de la ejecución al punto en el que se hizo la llamada con Goto (cosa que sí sucede cuando utilizamos procedimientos), sino que continúa la ejecución hasta el final del procedimiento, con lo que perdemos toda la estructuración en el programa.

Sub Main()

Dim Valor As Integer

Dim Resultado As Integer

Console.WriteLine("Introducir valor")

Valor = Console.ReadLine()

Goto OperacVarias ' realizamos un salto con Goto

' estas líneas no se ejecutarán

Resultado = Valor * 5

Console.WriteLine("El resultado es {0}", Resultado)

' etiqueta de código

OperacVarias:

Console.WriteLine("Estamos en el bloque de Goto")

End Sub

Código fuente 152

Bifurcaciones incondicionales con Goto - I

La instrucción Goto, al igual que sucede con las estructuras de control del lenguaje, realiza una bifurcación en el flujo de ejecución del programa. La diferencia con las estructuras de control radica en que Goto realiza la bifurcación de forma incondicional, mientras que las estructuras proporcionan una alternativa para permitir realizar o no las oportunas bifurcaciones. 

Por este motivo se suele decir que Goto realiza un salto no estructurado en la ejecución del programa. Goto realiza un salto hacia lo que se denomina una etiqueta de código, que consiste en un bloque de líneas encabezadas por un identificador y dos puntos. Las etiquetas de código deben situarse al final del procedimiento en el que vayan a utilizarse, y para realizar un salto en la ejecución hacia una de ellas, debemos escribir dicha etiqueta en el procedimiento y utilizar Goto con la sintaxis del Código fuente 151.

Goto NombreEtiqueta

Código fuente 151

Interruptores - II

En el anterior ejemplo, el cambio de estado del interruptor lo podemos simplificar en gran medida mediante el uso del operador Not. El Código fuente 150 muestra el fragmento de código del anterior ejemplo en el que se cambia el estado pero mediante esta otra técnica.

' cambiar el estado del interruptor

Interruptor = Not Interruptor

Código fuente 150

Interruptores - I

Dentro de un proceso repetitivo, un interruptor o switch consiste en una variable que tomará dos estados: conectado y desconectado; de forma que en función de dicho estado se ejecutará un determinado bloque de código. Veamos un ejemplo en el Código fuente 149.

Sub Main()

Dim Valores() As Integer = {345, 43, 875, 126, 900, 4112}

Dim Interruptor As Integer

Dim Contador As Integer

Dim Cantidad1 As Integer

Dim Cantidad2 As Integer

' inicializar el estado del interruptor

Interruptor = 1

For Contador = 0 To UBound(Valores)

' según el estado del interruptor

' acumular el valor de la posición actual

' del array en una u otra variable

If Interruptor = 1 Then

Cantidad1 += Valores(Contador)

Else

Cantidad2 += Valores(Contador)

End If

' cambiar el estado del interruptor

If Interruptor = 1 Then

Interruptor = 0

Else

Interruptor = 1

End If

Next

End Sub

Código fuente 149

Acumuladores

Un acumulador es una variable que va almacenando dentro de un bucle el resultado de una suma efectuada a cada iteración del mismo, tal y como se muestra en el Código fuente 148.

Sub Main()

Dim Contador As Integer

Dim Acumulador As Integer

Dim Cantidad As Integer

For Contador = 1 To 5

Console.WriteLine("Introducir una cantidad numérica")

Cantidad = Console.ReadLine()

Acumulador += Cantidad

Console.WriteLine("El acumulador contiene un valor de {0}", Acumulador)

Next

Console.ReadLine()

End Sub

Código fuente 148

Contadores

Un contador consiste en una variable que como su propio nombre indica, realizará un cálculo de las iteraciones efectuadas dentro de un bucle. El Código fuente 147 muestra un ejemplo.

Sub Main()

Dim Contador As Integer

Dim Nombre As String

Console.WriteLine("Introducir un nombre")

Do While Nombre <> "Carlos"

Contador += 1

Console.WriteLine("Valor del contador: {0}", Contador)

Nombre = Console.ReadLine()

Loop

Console.WriteLine("El bucle se ha ejecutado {0} veces", Contador)

Console.ReadLine()

End Sub

Código fuente 147

Construcciones derivadas de las estructuras de control

El carácter de bifurcación o iteración de las estructuras de control, nos permite la creación de construcciones de código que se repiten un número determinado de veces, para llevar el control de las ejecuciones de un bloque de código y acumulación de valores. Los nombres más habituales con que se conocen este tipo de construcciones son: interruptor, contador y acumulador.

Anidación incorrecta de estructuras

Cuando escribimos estructuras de control anidadas, debemos ser precavidos para evitar que parte de una estructura de nivel interior quede fuera de la estructura exterior, ya que esto provocaría un error de sintaxis Al escribir estructuras anidadas, hemos de poner cuidado para evitar que parte de la estructura de nivel interior, quede fuera de la estructura de nivel exterior, ya que esto provocaría un error, como muestra el esquema de la Figura 70.

Figura 70. Esquema de anidación incorrecta de estructuras de control.

Anidación de estructuras de distinto tipo y a varios niveles

En el siguiente ejemplo vamos a realizar una combinación de estructuras anidadas de tipos distintos y a más de un nivel de profundidad. A partir de un array de cadenas de caracteres, vamos a realizar un proceso que se va a repetir tantas veces como cadenas haya en el array. En cada proceso vamos a dar tres oportunidades de introducir una cadena por consola. Si la cadena introducida coincide con el elemento del array que corresponde al número de iteración que estamos haciendo actualmente sobre el bucle For, se mostrará un mensaje y saldremos a la siguiente iteración de For. Ver Código fuente 146.

Sub Main()

Dim Nombres() As String = {"Ana", "Pedro", "Luis", "Elena", "Olga"}

Dim Repeticiones As Integer

Dim Valor As Integer

Dim Nombre As String

For Repeticiones = 0 To 4

Console.WriteLine("Captura de nombre, intento {0}", Repeticiones + 1)

Valor = 1

Do While Valor <= 3

Console.WriteLine("Introducir un nombre")

Nombre = Console.ReadLine()

If Nombre = Nombres(Repeticiones) Then

Console.WriteLine("Nombre correcto")

Exit Do

End If

Valor += 1

Loop

Next

End Sub

Código fuente 146

Anidación de estructuras de repetición

El Código fuente 145 muestra un ejemplo de anidación de dos estructuras For...Next.

Sub Main()
' dos estructuras For anidadas
Dim Contador1 As Integer
Dim Contador2 As Integer
For Contador1 = 1 To 5
Console.WriteLine("Estructura externa, valor: {0}", Contador1)
For Contador2 = 1 To 3
Console.WriteLine("---- Estructura interna, valor: {0}", Contador2)
Next
Next
End Sub

Código fuente 145

Anidación de estructuras de selección

El Código fuente 144 muestra un ejemplo de anidación de dos estructuras If...End If

Sub Main()
' dos estructuras If anidadas
Dim ValorEntrada As Integer
Dim Nombre As String
Console.WriteLine("Introducir un número")
ValorEntrada = Console.ReadLine()
' estructura externa
If ValorEntrada = 5 Then
Console.WriteLine("Introducir un nombre")
Nombre = Console.ReadLine()
' estructura interna
If Nombre = "Pedro" Then
Console.WriteLine("Has llegado al interior")
End If
End If
End Sub

Código fuente 144

Anidación de estructuras de control

Esta técnica de escritura del código consiste en incluir una estructura de control dentro de otra estructura ya existente. La estructura anidada o interior puede ser del mismo o diferente tipo que la estructura contenedora o exterior, siendo posible además, anidar más de una estructura, y a varios niveles de profundidad. Veamos unos ejemplos en los siguientes apartados

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. El Código fuente 142 muestra su sintaxis.

For Each Elemento In ColecArray

' código

' ......

[Exit For]

' código

' ......

Next

Código fuente 142

El Código fuente 143 muestra un ejemplo del uso de esta estructura de control

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

Código fuente 143