Buscador

Constantes

En este caso seguiremos el mismo formato de notación que para las variables en lo que respecta al ámbito y tipo de dato. El cuerpo de la constante sin embargo, lo escribiremos en mayúsculas, separando las distintas palabras utilizando el carácter de guión bajo ( _ ) en vez de WordMixing. Código fuente 174.

' constante a nivel de proyecto de tipo integer
piTIPO_IVA
' constante a nivel de módulo de tipo string
msCOLOR_INICIAL
Código fuente 174

Variables - IV

En el caso de objetos creados por el programador, utilizaremos como prefijo para el tipo de dato, el carácter “o”, o bien tres caracteres indicativos de la clase. Ver el Código fuente 173.

' variable local cuyo tipo es un objeto creado por el programador
Dim loEmpleado As Empleado
Dim lempEmpleado As Empleado
Código fuente 173

Variables - III

Para el cuerpo de la variable se utilizará WordMixing, que consiste en una técnica en la cual empleamos, si es necesario, varias palabras juntas para describir mejor el contenido de la variable. Veamos unos ejemplos en el Código fuente 172.

' variable local de tipo integer
liCodAcceso
' variable a nivel de módulo de tipo string
msNombreUsuario
' variable a nivel de proyecto de tipo fecha
pdtDiaAlta
Código fuente 172

Variables - I

El formato empleado para la notación de variables se basa en utilizar un carácter para indicar el ámbito de la variable, a continuación uno o dos caracteres para especificar el tipo de dato, y finalmente el resto del nombre que daremos a la variable, que llamaremos cuerpo de la variable. Ver el Código fuente 171.

<Ámbito><TipoDato><Cuerpo>
Código fuente 171

Convenciones de notación

Las convenciones de notación consisten en una serie de normas no oficiales a la hora de declarar identificadores en el código, que facilitan su interpretación y mantenimiento. Si bien esto no es inicialmente necesario, ni la herramienta de programación obliga a ello, en la práctica se ha demostrado que una serie de normas a la hora de escribir el código redundan en una mayor velocidad de desarrollo y facilidad de mantenimiento de la aplicación. 
Siendo útil no sólo en grupos de trabajo, sino también para programadores independientes. Seguidamente describiremos una serie de normas de codificación para variables y constantes, que no son en absoluto obligatorias a la hora de escribir el código del programa, pero si pretenden concienciar al lector de la necesidad de seguir unas pautas comunes a la hora de escribir dicho código, de manera que al compartirlo entre programadores, o cuando tengamos que revisar una aplicación desarrollada tiempo atrás, empleemos el menor tiempo posible en descifrar lo que tal o cual variable significa en el contexto de un procedimiento.

Variables Static - IV

Las variables Static por lo tanto, tienen un periodo de vida que abarca todo el tiempo de ejecución del programa, mientras que su ámbito es a nivel de procedimiento o bloque, ya que también pueden crearse dentro de una estructura de control.

Variables Static - III

Pero cambiemos el modo de declaración de la variable Importe, añadiéndole Static. En este caso, la primera vez que se ejecuta el procedimiento, se inicializa la variable con el valor 5, pero al terminar la ejecución, la variable no se destruye, sino que en la siguiente ejecución conserva el valor, que podemos ir incrementando en cada llamada. Ver Código fuente 170.

Public Sub Main()
Verificar("Primera") ' en esta llamada se muestra 7
Verificar("Segunda") ' en esta llamada se muestra 9
Verificar("Tercera") ' en esta llamada se muestra 11
Console.ReadLine()
End Sub
Public Sub Verificar(ByVal OrdenLlamada As String)
' declarar variable con el modificador Static,
' en la primera llamada toma el valor inicial de 5,
' las sucesivas llamadas no ejecutarán esta línea
Static Dim Importe As Integer = 5
Importe += 2
Console.WriteLine("{0} llamada al procedimiento, la variable contiene {1}", _
OrdenLlamada, Importe)
End Sub
Código fuente 170

Variables Static - II

Cuando declaramos una variable normal dentro de un procedimiento, cada vez que llamamos al procedimiento, dicha variable es inicializada. El ejemplo del Código fuente 169, en cada llamada al procedimiento, se inicializa la variable y le sumamos un número, por lo que la variable siempre muestra el mismo valor por la consola.

Public Sub Main()
Verificar("Primera") ' en esta llamada se muestra 7
Verificar("Segunda") ' en esta llamada se muestra 7
Verificar("Tercera") ' en esta llamada se muestra 7
Console.ReadLine()
End Sub
Public Sub Verificar(ByVal OrdenLlamada As String)
' cada vez que se ejecuta este procedimiento
' la variable Importe se inicializa a 5
Dim Importe As Integer = 5
Importe += 2
Console.WriteLine("{0} llamada al procedimiento, la variable contiene {1}", _
OrdenLlamada, Importe)
End Sub
Código fuente 169

Variables Static - I

Este tipo de variables se caracterizan por el hecho de que conservan su valor después de finalizar el procedimiento en el que han sido declaradas. Se deben declarar utilizando la palabra clave Static, pudiendo opcionalmente omitir la palabra clave Dim. El Código fuente 168 muestra su sintaxis.

Static [Dim] Importe As Integer
Código fuente 168

Periodo de vida o duración de las variables

El periodo de vida de una variable es el tiempo durante el cual la variable está activa, ocupando el espacio de memoria que le ha asignado el entorno de ejecución de .NET Framework, y disponible para ser utilizada. El periodo de vida de una variable depende de su ámbito, de forma que podemos clasificarlos como se muestra a continuación. 
• Ámbito de bloque. El periodo de vida de estas variables se desarrolla desde el momento en que son declaradas dentro del bloque y hasta que dicho bloque finaliza. 
• Ámbito de procedimiento. Para estas variables, su periodo de vida está comprendido entre el momento en que son declaradas y hasta que la ejecución del procedimiento termina. 
• Ámbito a nivel de módulo y proyecto. En este caso, el periodo de vida de la variable va desde el comienzo de la ejecución de la aplicación y hasta que esta termina.

Ámbito a nivel de proyecto

Una variable declarada en la zona de declaraciones de un módulo utilizando la palabra clave Public, se dice que tiene ámbito a nivel del proyecto, es decir, que es accesible por cualquier procedimiento de cualquier módulo que se encuentre dentro del proyecto. Si tomamos el fuente anterior y declaramos como Public la variable Nombre, ahora sí podremos manipularla desde cualquier punto de la aplicación. Ver Código fuente 167.

Module General
' esta variable será accesible
' desde cualquier lugar del proyecto
Public Nombre As String
Public Sub Main()
Console.WriteLine("Procedimiento Main()")
Console.WriteLine("Asignar valor a la variable")
Nombre = Console.ReadLine()
Console.WriteLine("El valor de la variable en Main() es: {0}", Nombre)
Manipular()
MostrarValor()
Console.ReadLine()
End Sub
Public Sub Manipular()
Console.WriteLine("Procedimiento Manipular()")
Console.WriteLine("Asignar valor a la variable")
Nombre = Console.ReadLine()
Console.WriteLine("El valor de la variable en Manipular() es: {0}", Nombre)
End Sub
End Module
Module Calculos
Public Sub MostrarValor()
' al haber declarado la variable Nombre
' como Public en el módulo General, podemos acceder a ella
' desde un módulo distinto al que se ha declarado
Console.WriteLine("Procedimiento MostrarValor()")
Nombre = "Antonio"
Console.WriteLine("Valor de la variable Nombre: {0}", Nombre)
End Sub
End Module
Código fuente 167

Ámbito a nivel de módulo - II

Para comprobar el valor de estas variables a través del depurador, tenemos que utilizar la ventana Automático, que podemos abrir con el menú Depurar + Ventanas + Automático, o las teclas [CTRL + ALT + V, A]. Ver Figura 80.
Figura 80. Ventana Automático, del Depurador.

Ámbito a nivel de módulo - I

Una variable declarada en la zona de declaraciones de un módulo, es decir, fuera de cualquier procedimiento, pero dentro de las palabras clave Module...End Module, y utilizando como palabra clave Dim o Private, se dice que tiene ámbito a nivel de módulo. Aunque tanto Dim como Private son perfectamente válidas para declarar variables a nivel de módulo, se recomienda usar exclusivamente Private; de este modo facilitamos la lectura del código, reservando las declaraciones con Dim para las variables con ámbito de procedimiento, y las declaraciones con Private para el ámbito de módulo. En el ejemplo del Código fuente 166 declaramos la variable Nombre dentro del módulo, pero fuera de cualquiera de sus procedimientos, esto hace que sea accesible desde cualquiera de dichos procedimientos, pero no desde un procedimiento que se halle en otro módulo.

Module General
'Dim Nombre As String <--- esta declaración es perfectamente válida...
Private Nombre As String ' ...pero se recomienda declarar con Private
Public Sub Main()
Console.WriteLine("Procedimiento Main()")
Console.WriteLine("Asignar valor a la variable")
Nombre = Console.ReadLine()
Console.WriteLine("El valor de la variable en Main() es: {0}", Nombre)
Manipular()
MostrarValor()
Console.ReadLine()
End Sub
Public Sub Manipular()
Console.WriteLine("Procedimiento Manipular()")
Console.WriteLine("Asignar valor a la variable")
Nombre = Console.ReadLine()
Console.WriteLine("El valor de la variable en Manipular() es: {0}", Nombre)
End Sub
End Module
Module Calculos
Public Sub MostrarValor()
' error, no se puede acceder desde este módulo
' a la variable Nombre, que está declarada Private
' en el módulo General
Console.WriteLine("Procedimiento MostrarValor()")
Nombre = "Antonio"
Console.WriteLine("Valor de la variable Nombre: {0}", Nombre)
End Sub
End Module
Código fuente 166

Ámbito a nivel de bloque - II

En este punto debemos aclarar que el ámbito dentro de un bloque se entiende como la parte de la estructura en la que ha sido declarada la variable. Por ejemplo, en una estructura If...End If con Else, si declaramos una variable a continuación de If, dicha variable no será accesible desde el bloque de código que hay a partir de Else. Ver Código fuente 165.

If MiNumero > 0 Then
' variable con un ámbito a nivel de bloque
' sólo es accesible dentro de esta estructura If
Dim Calculo As Integer
' ......
Else
' la variable Calculo no es accesible desde aquí
' ......
End If
Código fuente 165

Ámbito a nivel de bloque - I

Una variable declarada dentro de una estructura de control se dice que tiene ámbito local a nivel de bloque, siendo accesible sólo dentro del código que está contenido en la estructura. Ver Código fuente 164.

Public Sub Main()
' variables con ámbito a nivel de procedimiento
Dim MiNumero As Integer
Dim Total As Integer
Console.WriteLine("Introducir un número")
MiNumero = Console.ReadLine()
If MiNumero > 0 Then
' variable con un ámbito a nivel de bloque
' sólo es accesible dentro de esta estructura If
Dim Calculo As Integer
Console.WriteLine("Introducir otro número para sumar")
Calculo = Console.ReadLine()
MiNumero += Calculo
End If
Console.WriteLine("El resultado total es: {0}", MiNumero)
' error, la variable Calculo no es accesible desde aquí
Total = 150 + Calculo
Console.ReadLine()
End Sub
Código fuente 164

Ámbito a nivel de procedimiento

Una variable declarada dentro del cuerpo de un procedimiento se dice que tiene un ámbito local o a nivel de procedimiento, no pudiendo ser accedida por otro código que no sea el de dicho procedimiento. Ver Código fuente 163.

Public Sub Main()
' declaramos una variable que tiene ámbito
' a nivel de este procedimiento
Dim Nombre As String
Nombre = "Hola"
Console.WriteLine("Introducir un valor")
Nombre &= " " & Console.ReadLine()
End Sub
Public Sub Manipular()
' si intentamos desde este procedimiento
' acceder a la variable Nombre del
' procedimiento Main(), se produce un error
Nombre = "nuevo valor"
End Sub
Código fuente 163

En el ejemplo anterior, la variable Nombre puede ser manipulada dentro del procedimiento Main( ), y cualquier intento de acceder a ella desde otro procedimiento provocará un error.

Ámbito de variables

El ámbito de variables consiste en la capacidad de acceso que tenemos hacia una variable, de forma que podamos obtener su valor, así como asignarlo. 
Para determinar su nivel de accesibilidad, aquí intervienen, además de los modificadores de ámbito, el lugar o nivel de emplazamiento de la variable dentro del código. Respecto a los modificadores de ámbito, disponemos de las mismas palabras clave que para los procedimientos: Public y Private, y su sintaxis de uso la vemos en el Código fuente 162.


ModificadorÁmbito [Dim] NombreVariable As TipoDato
Código fuente 162


En función del punto de código en el que sea declarada una variable, podremos omitir el uso de la palabra clave Dim para realizar dicha declaración. A continuación se describen los diferentes tipos de ámbito para variables, en función de su lugar de declaración.

Privado - II

En el anterior fuente, desde Main( ) no podemos llamar a la función ObtenerNumero( ), ya que dicha función tiene ámbito Private y reside en un módulo distinto. Sin embargo, sí podemos llamarla desde el procedimiento Totales( ), ya que en ese caso, la llamada se realiza dentro del mismo módulo de código.

Privado - I

Un procedimiento con ámbito privado sólo puede ser llamado desde el propio módulo en el que se ha declarado. La palabra clave utilizada como modificador de ámbito en este caso es Private. Veamos un ejemplo en el Código fuente 161.

Module General
Public Sub Main()
' podemos ejecutar el procedimiento Totales()
' ya que tiene ámbito público
Totales(400)
Dim MiNumero As Integer
' error, la función ObtenerNumero tiene ámbito privado,
' dentro del módulo Calculos,
' por lo que no es accesible desde este módulo
MiNumero = ObtenerNumero()
Console.ReadLine()
End Sub
End Module
Module Calculos
Public Sub Totales(ByVal Importe As Integer)
Dim Resultado As Integer
Console.WriteLine("Estamos en el módulo Calculos, procedimiento Totales")
' podemos llamar desde aquí a la función ObtenerNumero
' ya que estamos en el mismo módulo
Resultado = Importe + ObtenerNumero()
Console.WriteLine("El total obtenido es: {0}", Resultado)
End Sub
Private Function ObtenerNumero() As Integer
Console.WriteLine("Estamos en el módulo Calculos," & _
" procedimiento ObtenerNumero")
Return 18
End Function
End Module
Código fuente 161

Público - III

Veamos un ejemplo en el Código fuente 160.

Module General
Public Sub Main()
' en esta llamada, se ejecutará el procedimiento Totales()
' que está en este mismo módulo
Totales(400)
' en esta llamada, como especificamos el nombre del módulo
' en primer lugar, se ejecuta el procedimiento Totales()
' que está en el módulo Calculos
Calculos.Totales(280)
Console.ReadLine()
End Sub
Public Sub Totales(ByVal Importe As Integer)
' en esta versión del procedimiento,
' multiplicamos el parámetro por un valor
Dim Resultado As Integer
Console.WriteLine("Estamos en el módulo General, procedimiento Totales")
Resultado = Importe * 4
Console.WriteLine("El total obtenido es: {0}", Resultado)
End Sub
End Module
Module Calculos
Public Sub Totales(ByVal Importe As Integer)
' en esta versión del procedimiento,
' sumamos un valor al parámetro
Dim Resultado As Integer
Console.WriteLine("Estamos en el módulo Calculos, procedimiento Totales")
Resultado = Importe + 1000
Console.WriteLine("El total obtenido es: {0}", Resultado)
End Sub
End Module
Código fuente 160

Público - II

Public es el modificador de ámbito por defecto para procedimientos, lo que quiere decir que si no lo utilizamos, al crear un procedimiento, su ámbito será público por defecto. Es posible escribir varios procedimientos con el mismo nombre y ámbito público en distintos módulos. 
Cuando esto ocurra, al llamar al procedimiento se ejecutará por defecto el que más próximo esté desde el módulo que ha sido llamado. En el caso de que necesitemos ejecutar el procedimiento que se encuentre en otro módulo deberemos hacer la llamada utilizando la sintaxis descrita en el Código fuente 159.

NombreModulo.NombreProcedimiento( )
Código fuente 159

Público - I

Un procedimiento con ámbito público puede ser llamado desde cualquier punto del módulo en el que se ha declarado, o desde cualquier otro módulo del proyecto. La palabra clave utilizada como modificador de ámbito en este caso es Public. En el Código fuente 158 tenemos dos módulos: General y Calculos, que contienen respectivamente los procedimientos Main( ) y Totales( ). Desde Main( ) podemos perfectamente llamar al procedimiento Totales( ), ya que al haber sido declarado como Public, es accesible desde otro módulo.

Module General
Public Sub Main()
Console.WriteLine("Estamos en el módulo General, procedimiento Main")
' llamar al procedimiento Totales() que está en otro módulo
Totales(400)
Console.ReadLine()
End Sub
End Module
Module Calculos
Public Sub Totales(ByVal Importe As Integer)
Dim Resultado As Integer
Console.WriteLine("Estamos en el módulo Calculos, procedimiento Totales")
Resultado = Importe + 1000
Console.WriteLine("El total obtenido es: {0}", Resultado)
End Sub
End Module
Código fuente 158

Ámbito de procedimientos

El ámbito de procedimientos consiste en la capacidad de poder llamar a un procedimiento desde un punto determinado del programa, en función del nivel de acceso definido para dicho procedimiento en el momento de su declaración. Para especificar el ámbito de un procedimiento, lo haremos mediante una palabra clave o modificador de ámbito, anteponiéndolo al tipo de procedimiento (Sub o Function) dentro de la declaración. El Código fuente 157 muestra la sintaxis a utilizar.

ModificadorÁmbito Sub | Function NombreProcedimiento([ListaParámetros])
Código fuente 157

Veamos a continuación, los ámbitos de procedimiento disponibles.

Reglas de ámbito

El ámbito o accesibilidad de un elemento declarado en el código, consiste en la capacidad que tenemos para utilizar dicho elemento desde otro punto cualquiera del código, ya sea desde el interior del propio programa o desde un proyecto externo compilado como librería de clases (archivo .DLL).
Las reglas de ámbito se aplican por un lado a procedimientos y variables, visto el lenguaje desde el prisma de la programación estructurada; y por otro lado, estas normas también se aplican a métodos y propiedades, visto el lenguaje desde el punto de vista de la programación orientada a objetos. En este tema realizaremos una revisión de las cuestiones de ámbito aplicadas a procedimientos y variables, dejando el ámbito de métodos y propiedades para los temas sobre objetos.

Excluir y eliminar ficheros de código del proyecto

Figura 79. Excluir un fichero del proyecto.
Si no queremos que un determinado fichero (con el módulo o módulos que incluye) siga formando parte del proyecto, podemos separarlo del mismo abriendo la ventana Explorador de soluciones, y haciendo clic derecho sobre el nombre del procedimiento, elegir la opción de menú Proyecto + Excluir del proyecto. Esta acción quita el fichero del proyecto pero no lo elimina físicamente. Ver Figura 79
. Para eliminar físicamente el fichero de código, debemos realizar la misma operación descrita antes, pero seleccionando en este caso en el menú contextual, la opción Eliminar.

Lista desplegable “Nombre de clase”, en el editor de código

La lista desplegable Nombre de clase, situada en la parte superior izquierda del editor de código, tiene dos finalidades principales que describimos a continuación. 
• Mostrar el nombre del módulo sobre el que actualmente trabajamos. Esta información es útil cuando estamos escribiendo código en un fichero que tiene varios módulos, de forma que siempre podemos saber sobre qué módulo estamos posicionados. 
• Cambiar a otro módulo dentro del mismo fichero de código. Esta operación la realizamos en dos pasos. En primer lugar abriremos esta lista desplegable y seleccionaremos el nombre del módulo al que vamos a cambiar. Por último, abriremos la lista Nombre de método, y elegiremos uno de los procedimientos del módulo sobre el que acabamos de posicionarnos, el editor de código cambiará entonces a dicho procedimiento. La Figura 78 muestra una imagen de esta lista de módulos
Figura 78. Lista Nombre de clase, en el editor de código del IDE.
.
El motivo de usar el término clase en lugar de módulo para esta lista, se debe, como veremos en los temas sobre programación con objetos, a que todo lo que haremos habitualmente en nuestra labor de programación será crear clases, objetos, métodos, propiedades, etc. Por ello la terminología empleada en general se aproxima más a las técnicas de programación con objetos que a la programación estructurada.