Tipificación obligatoria - II

Si configuramos a nivel de fichero de código, escribiremos esta instrucción al comienzo del fichero con el modificador oportuno. Consulte el lector el anterior apartado para un mayor detalle sobre el acceso a esta ventana de propiedades del proyecto. En el ejemplo del Código fuente 38, establecemos Option Strict On a nivel de fichero de código, y a partir de ese momento, no podremos asignar un tipo de dato Double a un Integer, o un valor numérico a una variable String, por exponer un par de casos de los más comunes. El código erróneo será marcado por el IDE como un error de sintaxis, e igualmente se producirá un error si intentamos ejecutar el programa.

Figura 55. Configuración de Option Strict a nivel de proyecto.

Option Strict On

Module Module1

Sub Main()

' ahora es obligatorio establecer

' el tipo de dato a todas las variables

Dim Valor As Integer

Dim TotalGeneral As Double

Dim Dato As String

TotalGeneral = 500

Valor = TotalGeneral ' error, no se permite la conversión implícita

Dato = TotalGeneral ' error, no se permite la conversión implícita

End Sub

End Module

Código fuente 38

Tipificación obligatoria - I

Cuando declaramos una variable, no es obligatorio por defecto, establecer un tipo de dato para la misma. Igualmente, al asignar por ejemplo, una variable numérica a una de cadena, se realizan automáticamente las oportunas conversiones de tipos, para transformar el número en una cadena de caracteres. Veamos un ejemplo en el Código fuente 37.

Sub Main()
' no es necesario tipificar la variable, tipificación implícita,
' la variable Valor se crea con el tipo Object

Dim Valor
' tipificación explícita
Dim Importe As Integer
Dim UnaCadena As String
' al asignar una fecha a la variable Valor,
' sigue siendo de tipo Object, pero detecta que
' se trata de una fecha y guarda internamente
' esta información como un subtipo Date
Valor = #8/20/2001#
Importe = 590
' no es necesario hacer una conversión de tipos previa
' para asignar un número a una variable de cadena,
' ya que se realiza una conversión implícita,
' la variable UnaCadena contiene la cadena "590"
UnaCadena = Importe
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable Importe: {0}", Importe)
Console.WriteLine("Variable UnaCadena: {0}", UnaCadena)
Console.ReadLine()
End Sub

Código fuente 37

Como ya comentábamos en el apartado anterior, si no asignamos el tipo de dato adecuado al declarar una variable, .NET le asigna el tipo Object, lo que afecta negativamente al rendimiento de la aplicación. La instrucción Option Strict, junto a sus modificadores On/Off, nos permite establecer si en el momento de declarar variables, será obligatoria su tipificación. También supervisa la obligatoriedad de realizar una conversión de tipos al efectuar asignaciones entre variables, o de expresiones a variables.

• Option Strict On. Hace obligatoria la tipificación de variables y la conversión de tipos explícita.
  • Option Strict Off. Hace que no sea obligatoria la tipificación de variables. La conversión entre tipos distintos en asignaciones y expresiones es realizada automáticamente por el entorno. Opción por defecto. Podemos configurar Option Strict a nivel de proyecto y de fichero de código, de igual forma que con Option Explicit. En el caso de configurar a nivel de proyecto, deberemos abrir la ventana de propiedades del proyecto, y en su apartado Generar, establecer el valor correspondiente en la lista desplegable Option Strict. Ver Figura 55.

Option Explicit a nivel de fichero

Para establecer la declaración obligatoria a nivel de fichero, debemos situarnos al comienzo del fichero de código y escribir la instrucción Option Explicit con el modificador correspondiente. El Código fuente 36 muestra un ejemplo de cómo desactivar esta característica en el fichero de código actual.

' desactivar declaración obligatoria de variables
' ahora podemos, dentro de este fichero de código,
' escribir todas las variables sin declarar
Option Explicit Off
Module Module1
Sub Main()
Valor = "coche"
MiDato = 984
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable MiDato: {0}", MiDato)
Console.ReadLine()
End Sub
End Module

Código fuente 36

Option Explicit a nivel de fichero, nos permite establecer el modo de declaración de variables sólo para ese fichero en el que lo utilizamos, independientemente del tipo de obligatoriedad en declaración de variables establecido de forma general para el proyecto. Podemos por ejemplo, tener establecido Option Explicit On para todo el proyecto, mientras que para un fichero determinado podemos no obligar a declarar variables escribiendo al comienzo del mismo Option Explicit Off. El hecho de tener Option Explicit Off no quiere decir que no podamos declarar variables, podemos, por supuesto declararlas, lo que sucede es que el compilador no generará un error al encontrar una variable sin declarar. El otro grave problema al no declarar variables proviene por la incidencia en el rendimiento de la aplicación. Cuando tenemos Option Explicit Off, el entorno de .NET por cada identificador que encuentre sin declarar, crea una nueva variable, y ya que desconoce qué tipo de dato querría utilizar el programador, opta por asignarle el más genérico: Object. Una excesiva e innecesaria proliferación de variables Object afectan al rendimiento del programa, ya que .NET Framework debe trabajar doblemente en la gestión de recursos utilizada por dichas variables. En el próximo apartado trataremos sobre la obligatoriedad a la hora de tipificar variables. Por todo lo anteriormente comentado, a pesar de la engañosa facilidad y flexibilidad de Option Explicit Off, nuestra recomendación es tener configurado siempre Option Explicit On a nivel de aplicación, nos ahorrará una gran cantidad de problemas.

Option Explicit a nivel de proyecto - II

Mucho más fácil que tener que declarar las variables ¿verdad?. Pues precisamente esta facilidad es uno de los graves problemas de no declarar variables. En un procedimiento de prueba con poco código, esto no supone una importante contrariedad. Sin embargo pensemos un momento, que en lugar de un pequeño procedimiento, se trata de una gran aplicación con muchas líneas de código, procedimientos, y cientos de variables. Al encontrarnos con una variable de esta forma, no sabremos si esa variable ya la hemos utilizado con anterioridad en el procedimiento, si ha sido pasada como parámetro al mismo, etc. Estas circunstancias provocan que nuestro código se vuelva complejo de interpretar, retrasando la escritura general de la aplicación. Si volvemos a activar Option Explicit On, inmediatamente sabremos que algo va mal, ya que toda variable no declarada, quedará subrayada por el IDE como un error de escritura. Las ventajas son evidentes.

Option Explicit a nivel de proyecto - I

Para establecer Option Explicit a nivel de proyecto, debemos abrir la ventana Explorador de soluciones, hacer clic en el nombre del proyecto, y a continuación pulsar el botón de propiedades en esa misma ventana. Esto mostrará la ventana de propiedades del proyecto, en cuyo panel izquierdo haremos clic sobre el elemento Generar. Finalmente abriremos la lista desplegable del elemento Option Explicit, seleccionaremos un valor (On, Off) y pulsaremos Aplicar y Aceptar. Ver Figura 54. Con la declaración obligatoria desactivada podríamos escribir código como el mostrado en el Código fuente 35

Sub Main()
Valor = "coche"

MiDato = 984
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable MiDato: {0}", MiDato)
Console.ReadLine()
End Sub
Código fuente 35

Figura 54. Propiedades del proyecto para modificar la declaración obligatoria de variables.

Declaración obligatoria

Es obligatorio, por defecto, la declaración de todas las variables que vayamos a utilizar en el código. En el caso de que intentemos utilizar una variable no declarada, se producirá un error. La declaración de variables proporciona una mayor claridad al código, ya que de esta forma, sabremos en todo momento si un determinado identificador corresponde a una variable de nuestro procedimiento, de un parámetro, etc. Mediante la instrucción Option Explicit, y sus modificadores On/Off, podemos requerir o no la declaración de variables dentro del programa. 

• Option Explicit On. Hace obligatoria la declaración de variables. Opción por defecto. 

• Option Explicit Off. Hace que no sea obligatoria la declaración de variables. Podemos aplicar esta instrucción para que tenga efecto a nivel de proyecto y a nivel de fichero de código.

Valor inicial - II

Por otro lado podemos, inversamente, inicializar una variable que ya tiene valor, asignándole la palabra clave Nothing; con ello, la variable pasa a tener el valor por defecto o inicial. Ver el Código fuente 34.

Sub Main()

Dim Valor As String

Dim FhActual As Date

Dim ValorLogico As Boolean

' asignar valores a variables

Valor = "mesa"

FhActual = "10/8/2001"

ValorLogico = True

' inicializar variables

Valor = Nothing

FhActual = Nothing

ValorLogico = Nothing

' mostrar variables en la consola

Console.WriteLine("Variable Valor: {0}", Valor)

Console.WriteLine("Variable FhActual: {0}", FhActual)

Console.WriteLine("Variable ValorLogico: {0}", ValorLogico)

Console.ReadLine()

End Sub

Código fuente 34

Valor inicial - I

Toda variable declarada toma un valor inicial por defecto, a no ser que realicemos una asignación de valor en el mismo momento de la declaración. A continuación se muestran algunos valores de inicio en función del tipo de dato que tenga la variable: 

• Numérico. Cero ( 0 ). 

• Cadena de caracteres. Cadena vacía ( "" ). 

• Fecha. 01/01/0001 0:00:00. 

• Lógico. Falso (False). 

• Objeto. Valor nulo (Nothing). 

El Código fuente 33 muestra un ejemplo de valores iniciales.

Sub Main()
Dim ImporteFac As Integer
Dim Valor As String
Dim FhActual As Date
Dim FhNueva As Date
Dim ValorLogico As Boolean
Dim UnObjeto As Object
' mostrar variables en la consola
Console.WriteLine("Variable ImporteFac: {0}", ImporteFac)
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable FhActual: {0}", FhActual)
Console.WriteLine("Variable FhNueva: {0}", FhNueva)
Console.WriteLine("Variable ValorLogico: {0}", ValorLogico)
Console.WriteLine("Variable UnObjeto: {0}", UnObjeto)
Console.ReadLine()
End Sub
Código fuente 33

Asignación de valor - II

• Tipos lógicos. Las variables de este tipo sólo pueden tener el valor True (Verdadero) o False (Falso). Además de asignar valores de la forma que acabamos de explicar, podemos asignar el contenido de una variable a otra, o el resultado de una expresión a una variable, como veremos más adelante en el apartado dedicado a operadores. El Código fuente 31 muestra unos ejemplos de asignación a variables, que después visualizamos en la consola.

Module Module1
Sub Main()
Dim ImporteFac As Integer
Dim Precio As Double
Dim Valor As String
Dim Letra As Char
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"
Letra = "A"c
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 Letra: {0}", Letra)
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)
Console.ReadLine()
End Sub
End Module

Código fuente 31

Otra cualidad destacable en este apartado de asignación de valores, reside en que podemos declarar una variable y asignarle valor en la misma línea de código, como vemos en el Código fuente 32.


Dim Valor As String = "mesa"
Dim ImporteFac As Integer = 875
Código fuente 32

Asignación de valor - I

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 29.

Dim Cuenta As Integer
Cuenta = 875

Código fuente 29

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 ( " ). 

• Tipo carácter simple. Al asignar un carácter a una variable de tipo Char debemos encerrarlo entre comillas dobles igual que hacemos con una cadena, situando además, la letra c junto al carácter, fuera de las comillas, aunque esto último no sería obligatorio. Veamos un ejemplo en el Código fuente 30.

Dim Letra As Char
Letra = "A"c
Letra = "A" ‘ <-- no es necesario el uso de c junto al carácter a asignar
Código fuente 30

• 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 horaria 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.

Declaración múltiple en línea

En el caso de que tengamos que declarar más de una variable del mismo tipo, podemos declararlas todas en la misma línea, separando cada una con una coma, e indicando junto a cada variable el tipo de dato que va a tener; o bien, si especificamos el tipo de dato al final de la lista de variables, todas tendrán el mismo tipo de dato. Ver el Código fuente 28.

Dim Nombre As String, Cantidad As Integer, MiFecha As Date
Dim Importe, Totalizado, Precision As Integer
Código fuente 28

Tipificación - II

Si al declarar una variable no indicamos el tipo, por defecto tomará Object, que corresponde al tipo de datos genérico en el entorno de ejecución de .NET Framework, y que admite cualquier valor. Según la información que acabamos de ver, si declaramos una variable de tipo Byte e intentamos asignarle el valor 5899 se va a producir un error, ya que no se encuentra en el intervalo de valores permitidos para esa variable. Esto puede llevar al lector a preguntar: “¿por qué no utilizar siempre Object y poder usar cualquier valor?, o mejor ¿para qué necesitamos asignar tipo a las variables?”. 

El motivo de tipificar las variables reside en que cuando realizamos una declaración, el entorno de .NET debe reservar espacio en la memoria para los valores que pueda tomar la variable, como puede ver el lector en la tabla anterior, no requiere el mismo espacio en memoria una variable Byte que una Date. Si además, declaramos todas las variables como Object, los gastos de recursos del sistema serán mayores que si establecemos el tipo adecuado para cada una, ya que como .NET Framework no sabe el valor que puede tomar en cada ocasión la variable, debe realizar un trabajo extra de adecuación, consumiendo una mayor cantidad de recursos. Una correcta tipificación de las variables redundará en un mejor aprovechamiento de las capacidades del sistema y en un código más veloz en ejecución. Cuantos más programas se diseñen optimizando en este sentido, el sistema operativo ganará en rendimiento beneficiándose el conjunto de aplicaciones que estén en ejecución. VS.NET dispone de una ayuda al asignar el tipo a una variable, que nos muestra la lista de tipos disponibles para poder seleccionar uno sin tener que escribir nosotros el nombre. Al terminar de escribir la palabra As, aparecerá dicha lista, en la que pulsando las primeras letras del tipo a buscar, se irá situando en los más parecidos. Una vez encontrado, pulsaremos la tecla [INTRO] o [TAB] para tomarlo. Ver Figura 53.

Figura 53. Lista de tipos de datos al declarar una variable.

Tipificación - I

La tipificación de una variable es la operación por la cual, al declarar una variable, especificamos qué clase de valores o tipo de datos vamos a poder almacenar en dicha variable. En VB.NET utilizamos la palabra clave As seguida del nombre del tipo de datos, para establecer el tipo de una variable. Ver Código fuente 27.

Sub Main()
Dim Valor As String ' cadena de caracteres
Dim Cuenta As Integer ' numérico entero
Dim FhActual As Date ' fecha
End Sub
Código fuente 27

La Tabla 3 muestra la relación de tipos de datos disponibles en el lenguaje.

Tabla 3. Tipos de datos en VB.NET.

Lugar de la declaración

Podemos declarar variables en muy diversos lugares del código. El punto en el que declaremos una variable será determinante a la hora del ámbito o accesibilidad a esa variable desde otros puntos del programa. Por ahora, y ciñéndonos a la declaración de variables dentro de procedimientos, recomendamos declarar todas las variables en la cabecera o comienzo del procedimiento, para dar mayor claridad al mismo. Después de la declaración, escribiremos el resto de instrucciones del procedimiento.

Denominación

Como se comentaba en el apartado sobre identificadores, el nombre que podemos asignar a una variable tiene que seguir ciertas reglas: debe comenzar por letra, no puede ser una palabra reservada, ni incluir caracteres especiales del lenguaje. El Código fuente 26 nos muestra algunos ejemplos de declaraciones.

Sub Main()
' declaraciones correctas
Dim B
Dim Hola
Dim ABCD
Dim Nuevo10
Dim Es_otro
' declaraciones incorrectas
Dim 7Nuevo
Dim Avan+zar
Dim End ' nombre incorrecto
Dim Va-bien
End Sub

Código fuente 26

Como podemos comprobar en este fuente, y ya explicamos antes, incluimos comentarios en el código usando la comilla simple ( ' ), seguida del comentario correspondiente.

Declaración

La declaración de una variable es el proceso por el cual creamos e inicializamos 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 25.


Sub Main()
Dim MiValor
End Sub
Código fuente 25

Variables

Una variable es aquel elemento dentro de un programa que guarda un valor; dicho valor podrá cambiar durante el funcionamiento del programa (de ahí el nombre de variable). El contenido de la variable no es otra cosa que una posición en la memoria del ordenador que almacena el valor, y debido a que la memoria es un medio de almacenamiento no permanente, al finalizar el programa el valor se perderá, por lo que el uso de variables se limita al tiempo de ejecución del programa. Para manejar y asignar nombre a una variable, emplearemos un identificador.

Obtener información de la consola

Para tomar el texto tecleado en el indicador de comandos de la ventana de la consola disponemos del método ReadLine( ), que devuelve una cadena que podemos pasar a una variable para su tratamiento posterior. Veamos un ejemplo en el Código fuente 24.

Module Module1
Sub Main()

Dim UnValor As String
Console.WriteLine("Escribir algo")
UnValor = Console.ReadLine()
Console.WriteLine("Hemos escrito el siguiente texto")
Console.WriteLine(UnValor)
End Sub
End Module

Código fuente 24

La Figura 52 muestra el resultado.

Figura 52. Obtención del texto escrito en la consola.

Visualizar información en la consola - III

La otra técnica consiste en utilizar parámetros sustituibles, indicando en la cadena los lugares en los que queramos que se incluyan el contenido de las variables que necesitemos. Por ejemplo, supongamos que en la cadena “Hola voy a un coche”, queremos insertar los valores “conducir” y “azul”, que están situados en variables, de modo que la cadena resultante sea: “Hola voy a conducir un coche azul”. 

Para solucionar este problema, en la cadena tenemos que incluir unos marcadores que indican que en ese punto vamos a sustituir el marcador por una variable, y además el número de orden de la variable, tal y como la vamos a situar al llamar al método WriteLine( ). 

Los marcadores son los símbolos de llaves utilizados de una forma similar a la siguiente: {0} Cuando llamamos a WriteLine( ) sabemos que le pasamos como parámetro el valor a mostrar, pero podemos pasar más parámetros separados por comas, como pueden ser variables; dichos parámetros serán utilizados para sustituirse en la cadena pasada como primer parámetro. 

La Figura 51 muestra un esquema del uso de este método.

Figura 51. Esquema de parámetros sustituibles al usar el objeto Console.

Podemos comprobar, que a continuación de la cadena pasada en WriteLine( ), la primera variable se sustituirá en el marcador {0}, la siguiente en el {1}, y así sucesivamente.

Visualizar información en la consola - II

Si al escribir un texto en la consola, queremos combinar una cadena de caracteres con el contenido de una variable, podemos optar por dos técnicas. Por un lado podemos concatenar (unir) la cadena a la variable mediante el operador de concatenación del lenguaje ( & ). Ver Código fuente 23.


Module Module1
Sub Main()
Dim UnValor As String
UnValor = "al parque"
Console.WriteLine("Vamos de paseo " & UnValor)
End Sub
End Module
Código fuente 23

El resultado se muestra en la Figura 50.

Figura 50. Concatenar valores al mostrarlos en la consola.

Visualizar información en la consola - I

Para escribir texto llamaremos al método Write( ) o WriteLine( ) del objeto Console. Como parámetros a estos métodos, es decir, entre los paréntesis que los acompañan, situaremos la información a mostrar: una cadena, variable o expresión. Veamos un ejemplo en el Código fuente 22.

Module Module1
Sub Main()
Dim UnValor As String
UnValor = "algo más de texto"
' esta cadena va en una línea
Console.WriteLine("Una línea de prueba")
' ahora mostramos una variable
Console.WriteLine(UnValor)
' las siguientes cadenas se ponen juntas
Console.Write("Coche")
Console.Write("Tren")
' aquí añadimos una línea en blanco
Console.WriteLine()
End Sub
End Module
Código fuente 22
La diferencia entre Write( ) y WriteLine( ) consiste en que mediante el primero, todas las llamadas que hagamos a ese método escriben el texto seguido, mientras que el último lo hace en líneas separadas. La Figura 49 muestra el resultado del anterior ejemplo.

Figura 49. Escritura de texto con el objeto Console.

Manejo de la consola del sistema

Antes de pasar a trabajar con los elementos del lenguaje vamos a dar unos breves apuntes sobre el objeto Console, que representa a una ventana MS-DOS, símbolo del sistema, o consola, como la denominaremos fundamentalmente en este texto. 

En el tema anterior ya tuvimos un primer contacto con la consola realizando nuestro primer programa, el conocido Hola mundo. Sin embargo, en este apartado vamos a dar unas indicaciones básicas de uso, ya que la consola será el elemento principal que utilizaremos para mostrar y obtener datos por pantalla. 

Debido a su sencillez de uso y rápida ejecución, la consola se convierte en el elemento ideal para realizar pruebas, y en nuestro caso, mostrar ejemplos. Aunque la consola es un objeto, no vamos a entrar aquí a describir en qué consisten los objetos ni su uso en profundidad, recomendamos al lector la consulta de los temas específicos sobre programación orientada a objetos del texto. 

De igual modo, los conceptos sobre variables, parámetros, concatenación, y demás aspectos del lenguaje que se utilizan en estos ejemplos introductorios a la consola, se explicarán más adelante en los apartados correspondientes a los elementos del lenguaje.

Indentación del código - II

Cuando queramos indentar una línea simplemente hemos de situarnos al comienzo de la misma y pulsar la tecla [TAB], para quitar tabulaciones pulsaremos [TAB + MAYÚS]. Como ya hemos indicado, el entorno de desarrollo de VS.NET por defecto indenta automáticamente el código según lo vamos escribiendo. Si queremos variar algún aspecto en cuanto a este comportamiento del editor, podemos configurar las características de indentación establecidas en el IDE seleccionando la opción de menú Herramentas + Opciones. Al abrir la ventana Opciones seleccionaremos la carpeta Editor de texto, y dentro de esta la carpeta Basic, que contendrá la configuración para el editor de texto correspondiente a este lenguaje. Haciendo clic en el elemento Tabulaciones se mostrarán las propiedades de indentado, que podemos modificar para adaptarlas a nuestras preferencias, tal y como vemos en la Figura 48.

Figura 48. Propiedades de indentado en el IDE de Visual Studio .NET.

Indentación del código - I

La indentación o sangría es una técnica para escribir el código de un programa, consistente en situar las líneas de código a diferentes niveles de tabulación o profundidad, de forma que se facilite su lectura al ser revisado. 

Al crear una aplicación con VS.NET, podemos comprobar como el propio editor de código fuente indenta el código según lo escribimos, siendo una práctica muy ligada a las estructuras de control, que veremos próximamente, ya que nos permite ver rápidamente las instrucciones contenidas dentro de estas estructuras y situarnos en las líneas necesarias. En el Código fuente 21 se muestran unas líneas en pseudocódigo que contienen estructuras y código dentro de las mismas, de forma que pueda comprobar el lector el modo en que se realiza la tabulación.

comienzo
' líneas con indentación al mismo nivel
instrucción1
instrucción2
' comienzo de estructura
EstructuraA <expresión>
' líneas indentadas a un nivel de profundidad
instrucciónA1
instrucciónA2
' comienza estructura anidada
EstructuraB <expresión>
' líneas indentadas a segundo nivel de profundidad
instrucciónB1
instrucciónB2
FinEstructuraB
' según salimos de las estructuras
' volvemos a subir niveles de indentación
instrucciónA3
instrucciónA4
FinEstructuraA
instrucción3
instrucción4
final
Código fuente 21

Comentarios

Es una buena costumbre incluir comentarios aclaratorios en el código del programa, que sirvan como documentación posterior a la hora de revisar el código para realizar una posible corrección debido a un mal funcionamiento, o porque tengamos que ampliar la funcionalidad del programa. En VB.NET se utiliza el carácter de comilla simple ( ' ) para poder escribir anotaciones dentro del código del programa. Una vez incluida la comilla, todo lo que vaya a continuación será tenido en cuenta como comentario y no como instrucciones ejecutables. Ver Código fuente 20.

Module Module1
Sub Main()
' vamos a comenzar a ver el código
instrucción1
instrucción2 ' este comentario va a continuación de una línea
' esta es la última instrucción
instrucción3
End Sub
End Module

Código fuente 20

Ubicación del código en el programa

El código de un programa se sitúa en rutinas de código o procedimientos, en los cuales escribimos las instrucciones necesarias para resolver un determinado problema. 

Dependiendo de la complejidad y la cantidad de situaciones a resolver, un programa tendrá un número determinado de procedimientos. Los procedimientos serán tratados con profundidad en un próximo tema, de momento basta saber que para declarar un procedimiento utilizaremos la palabra clave Sub, seguida del nombre del procedimiento, escribiendo a continuación las instrucciones necesarias y finalizando el procedimiento con End Sub, como vemos en el Código fuente 19, en el que creamos un procedimiento con el nombre Calcular( ).

Sub Calcular()
instrucción1
instrucción2
instrucción3
instrucción4
instrucción5
....
....
....
instrucción

End Sub
Código fuente 19

Cuando creamos una aplicación VB.NET de tipo consola usando VS.NET, es el propio IDE quién se encarga de crear por nosotros la estructura básica del programa: crea un archivo de código conteniendo un módulo que tiene el procedimiento de entrada, sólo falta el código del programador. Todos los elementos que componen una aplicación VB.NET, son organizados por VS.NET bajo el concepto de proyecto. Un proyecto aglutina los archivos de código de la aplicación, recursos, referencias a clases globales de la plataforma .NET, etc. Consulte el lector el tema dedicado a la implementación de programas en .NET para una descripción general de estos tipos de archivo. Para las pruebas de los siguientes apartados crearemos desde el IDE un nuevo proyecto de tipo consola.

Estructura de un programa

Como ya explicamos en el tema que describía la escritura de la primera aplicación en VB.NET, los elementos mínimos que debe tener toda aplicación escrita en este lenguaje (y en general, la mayoría de lenguajes) son un módulo de código, y un procedimiento de entrada o inicio del programa, que en VB.NET tendrá el nombre Main( ), todo ello contenido en un archivo de código con extensión .VB. En la Figura 47 podemos ver en un diagrama, la estructura en niveles de un programa. 

Si el programa a ejecutar es de pequeño tamaño, el procedimiento de entrada al mismo contendrá todo el código necesario. Sin embargo esta situación no es muy frecuente, lo habitual es que los programas tengan una cantidad de código considerable, que obligue a separarlo en diferentes rutinas. Por este motivo el procedimiento Main( ) contiene generalmente código para inicializar valores en el programa, y hacer llamadas a otros procedimientos entre los que está repartido el resto del código. Debido a que los próximos ejemplos mostrados en el texto estarán basados en programas sencillos, por el momento sólo precisaremos usar el procedimiento Main( ).

Figura 47. Estructura en niveles de los elementos de un programa en VB.NET.

Palabras reservadas

Son todos aquellos nombres que forman parte integrante del lenguaje de programación, como puedan ser instrucciones, estructuras de código, funciones propias del lenguaje, objetos, etc. Este tipo de palabras no las podemos utilizar como identificadores, debido a que son empleadas internamente por el lenguaje. Algunas palabras reservadas en Visual Basic .NET son: Dim, Sub, Function, Public, For, Integer.

Identificadores

Un identificador es un nombre que el programador asigna a ciertos elementos del programa, como variables, constantes, rutinas de código, etc., para poder reconocerlos durante el desarrollo del mismo. 

Dicho nombre debe comenzar por una letra y no puede ser una palabra reservada del lenguaje, ni contener caracteres especiales como operadores aritméticos, de relación, etc. 

Aunque podemos utilizar cualquiera de nuestra elección, es muy recomendable que el nombre del identificador esté relacionado con su contenido, de forma que durante la revisión del código del programa, sepamos rápidamente lo que contiene simplemente con ver su nombre.

Definidos por el programador

En esta categoría se encuentran la estructura (Structure), que consiste en un tipo especial de dato compuesto por varios de los tipos existentes en el lenguaje; y el tipo enumerado (Enum), consistente en una lista de valores numéricos a los que asociamos un descriptor literal. Ambos tipos nos permiten combinar un conjunto de datos de forma más compleja que los tipos compuestos. 

Tanto los tipos compuestos como los definidos por el usuario serán tratados más adelante con mayor profundidad, ya que es recomendable conocer algunos aspectos previos sobre el lenguaje antes de ahondar en estos tipos.