 |
| Figura 77. Agregar un fichero de código existente al proyecto. |
Añadir al proyecto un fichero de código existente
Cambiar el nombre de un fichero de código
 |
| Figura 76. Cambiar el nombre de un fichero de código. |
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 |
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
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 - 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
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
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 controlSub 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