Curso de iniciación a la programación con Visual Basic .NET

Entrega número trece, (30/Abr/2003)
Publicada el 30/Abr/2003 (Actualizada: 27/Sep/2004)

Pues no, no ha sido para Semana Santa y por poco ni para el mes de abril... pero, lo importante es que ya está publicada, aunque no haya sido en el plazo que yo tenía planeado... y no es por justificarme, ya que al fin y al cabo lo mismo a ti te da igual... o puede que no te de igual, sobre todo si lees esto algún tiempo después de que esté publicado y ni siquiera sepas a que va todo este rollo que me está contando el Guille, pero... te lo cuento por si eres de los lectores fieles que está pendientes de que publique una nueva entrega y sigues esta serie de entregas en el momento (o casi) en que se publica, que también hay algunos que se incorporan pasado un tiempo desde su publicación y después hasta se quejan...
Pues eso, que si ves que las entregas no las publico muy a menudo, piensa que el Guille está "liado" con algunas cosillas que no le dejan tiempo para escribir...

Y ya, después de este rollo introductorio, vamos a ver qué tendremos en esta entrega número trece, que puede que a algunos les hubiese gustado que se llamara doce bis o algo así, (por aquello de que para los supersticiosos el trece trae mala suerte).

Como te comenté en la entrega anterior, en esta entrega veremos más cosas relacionadas con los procedimientos, así que... despeja tu mente y ¡empecemos!

Parámetros opcionales

Como vimos, en un procedimiento podemos indicar parámetros, en el caso de que el procedimiento necesite más de un parámetro, tendremos que indicarlos todos y cada uno de ellos, además hay que hacerlo en el mismo orden en el que se han declarado dichos parámetros. Por ejemplo, si tenemos la siguiente declaración de un procedimiento:
Sub Prueba(ByVal uno As Integer, ByVal dos As Integer)
Para poder usarlo hay que hacerlo de esta forma:
Prueba(10, 20)
El parámetro "uno" recibirá el valor 10, mientras que el parámetro "dos" recibirá el valor 20. Es decir, el primer valor indicado para el primer parámetro, el segundo valor indicado será para el segundo parámetro y así sucesivamente.
Por otro lado, si sólo quisiéramos indicar el primer parámetro, pero no el segundo, podríamos intentar hacer algo como esto:
Prueba(10)
Pero... ¡no se puede hacer! ya que produciría un error por la sencilla razón de que hay que indicar los dos parámetros "forzosamente".
Entonces... ¿cómo lo hago si en ocasiones quiero que sólo se indique un parámetro?
La respuesta es: indicando parámetros opcionales.

Para poder indicarle al Visual Basic .NET que un parámetro es opcional debemos indicarlo usando la instrucción Optional antes de la declaración del parámetro en cuestión, aunque la cosa no acaba aquí, ya que además tenemos que indicar el valor que tendrá por defecto, es decir, si no se indica ese parámetro, éste debe tener un valor predeterminado. Pero tampoco debemos creernos que haciendo esto de la forma que queramos podemos indicar que un parámetro es opcional. Bueno, si, lo dicho hasta ahora es válido, pero también debemos tener en cuenta que sólo podemos especificar parámetros opcionales después de todos los parámetros obligatorios.
Dicho esto, veamos cómo declarar el procedimiento Prueba para indicar que el segundo parámetro es opcional y que el valor predeterminado (si no se indica) es cinco:
Sub Prueba(ByVal uno As Integer, Optional ByVal dos As Integer = 5)
Con esta declaración podemos usar este procedimiento de estas dos formas:
Prueba(10, 20)
En este caso se indicará un 10 para el parámetro uno y 20 para el parámetro dos.
Prueba(10)
Si no indicamos el segundo parámetro, el valor que se usará dentro del procedimiento será el valor indicado en la declaración, es decir: 5.

Si quisiéramos que los dos parámetros fueran opcionales, tendríamos que declarar el procedimiento de esta forma:
Sub Prueba(Optional ByVal uno As Integer = 3, Optional ByVal dos As Integer = 5)
En este caso podemos llamar al procedimiento de estas formas:
1- Prueba()
2- Prueba(10)
3- Prueba(10, 20)
4- Prueba(,20)
5- Prueba(uno:=4)
6- Prueba(dos:=7)
7- Prueba(dos:=8, uno:=6)
8- Prueba(6, dos:=8)

Las tres primeras formas creo que son fácilmente compresibles.

En la cuarta sólo se indica el segundo parámetro, en este caso para "no" indicar el primero, dejamos el hueco, por eso se pone la coma y a continuación el segundo parámetro.
Esto está bien, y es la forma que "antes" se solía usar, pero en el caso de que haya muchos parámetros opcionales, puede ser algo "lioso" eso de tener que usar la coma para separar los parámetros que no se indican, ya que en el caso de que alguno de los parámetros opcionales no se vaya a indicar hay que "dejar" el hueco... imagínate que tenemos un procedimiento con 5 parámetros opcionales y sólo queremos indicar el tercero y el quinto, usando este mismo sistema lo haríamos así:
Prueba5(,,3,,5)
Y como puedes comprobar, es fácil olvidarse de alguna coma intermedia.

En las cuatro últimas formas de usar el procedimiento Prueba, usamos las variables de los parámetros opcionales para indicar el que queramos y el valor que le vamos a asignar, en estos casos usamos el nombre de la variable del parámetro opcional seguida de := y el valor a asignar.
Usando este sistema, podemos indicar los parámetros que queramos y además en el orden que queramos, ya que no habrá ningún problema de confusión, por la sencilla razón de que se especifica el nombre de la variable y el valor que tendrá. Fíjate que incluso se puede cambiar el orden de los parámetros...
¡Efectivamente! por la sencilla razón de que se indica el nombre de la variable del parámetro. No, no es que pienses que no te enteras, es que ¡quiero que no te quede ninguna duda!

La octava forma es como para rizar el rizo, ya que sería lo mismo que: Prueba(6, 8), pero nos sirve para que sepamos que también podemos hacerlo así, aunque esto sólo sería efectivo si en lugar de sólo dos parámetros tenemos más de dos parámetros. En estos casos en los que se mezclan valores "por posición" con valores "por variable" hay que tener presente que si no se indica el nombre de la variable del parámetro, los parámetros indicados explícitamente deben estar en el mismo orden en el que están declarados en el procedimiento.
Por ejemplo, esto daría error: Prueba(uno:=6, 8) por la sencilla razón de que si se indica un valor usando el nombre de uno de los parámetros los siguientes deben también indicarse usando el nombre del parámetro.

Si quieres saber más sobre parámetros opcionales, puedes usar este link de la ayuda de Visual Studio .NET:
ms-help://MS.VSCC/MS.MSDNVS.3082/vbcn7/html/vaconOptionalArgs.htm
ms-help://MS.VSCC.2003/MS.MSDNQTR.2003FEB.3082/vbcn7/html/vaconOptionalArgs.htm

 

Nota: Lo resaltado con negrita puede que sea diferente en tu instalación. En el caso anterior, el primer link sería para la ayuda de Visual Studio .NET 2002 en español, en el segundo, sería el mismo link para la ayuda de Visual Studio .NET 2003 en español, si te fijas, el final es el mismo en ambos casos: /vbcn7/html/vaconOptionalArgs.htm. Te comento que esos links también funcionarán desde el navegador, no sólo desde el Visual Studio, por supuesto si tienes instalada la ayuda de Visual Studio .NET. También puedes probar con el link que te muestre, pero "ajustándolo" a la dirección de internet de la MSDN Library de Microsoft, fíjate que en lugar de acabar con .htm acaba con .asp http://msdn.microsoft.com/library/en-us/vbcn7/html/vaconOptionalArgs.asp   Desde mayo de 2004, también puedes acceder a la documentación de Visual Studio .NET en español desde el sitio de MSDN: http://msdn.microsoft.com/library/spa/ Por tanto, los links mostrados puedes convertirlos para que se muestren en nuestro idioma, simplemente siguiendo los pasos indicados anteriormente, para el ejemplo mostrado sería: http://msdn.microsoft.com/library/spa/vbcn7/html/vaconOptionalArgs.asp   En futuros links a la documentación de Visual Studio .NET, la parte resaltada en negrita simplemente estará indicada con tres puntos suspensivos, ya que lo que realmente interesa, y es común, es la parte final.

 

Sobrecarga de procedimientos

Pero aunque esto de usar Optional está muy bien, hay que tener en cuenta de que esta instrucción existe "por compatibilidad" con las versiones anteriores de Visual Basic... o casi.
¿Por qué digo esto? Porque ahora, gracias a que Visual Basic .NET permite la sobrecarga de procedimientos, podemos hacer lo mismo de una forma más intuitiva y menos "liante" al menos de cara al que vea nuestro código (en ese "alguien" también nos incluimos nosotros, los autores del código).

Veamos lo que nos dice la documentación de Visual Studio .NET sobre la sobrecarga de propiedades y métodos (o lo que es lo mismo, sobre la sobrecarga de procedimientos):

La sobrecarga consiste en crear más de un procedimiento, constructor de instancias o propiedad en una clase con el mismo nombre y distintos tipos de argumento.

La sobrecarga es especialmente útil cuando un modelo de objeto exige el uso de nombres idénticos para procedimientos que operan en diferentes tipos de datos.

Es decir, que si necesitamos un procedimiento que utilice distinto número de parámetros o parámetros de distintos tipos, podemos usar la sobrecarga de procedimientos.
Sabiendo esto, podríamos hacer lo mismo que con el procedimiento Prueba mostrado anteriormente con estas declaraciones:
Prueba()
Prueba(ByVal uno As Integer)
Prueba(ByVal uno As Integer, ByVal dos As Integer)
Lo único es que no podríamos usar las formas 4 a 8. Pero esto no sería un inconveniente, ya que esas formas no son "lógicas" o intuitivas, como prefieras llamarlo.

La pregunta que seguramente te harás (o deberías hacerte) es:
Si escribo tres procedimientos con diferente número de parámetros ¿debo repetir el código tres veces, uno para cada uno de los procedimientos?
La respuesta es: si o no... depende. Es decir, si quieres, puedes escribir tres veces o tres códigos distintos, uno para cada procedimiento. Pero si no quieres no...
Vale... muy bien, pero ¿cómo puedo hacer que los tres procedimientos sean operativos sin tener que repetir prácticamente lo mismo en los tres procedimientos?
Pues... imagínate que quieres que funcione como en el primer ejemplo, el que usaba los parámetros opcionales. Es decir, si no se indicaba uno de los parámetros tomara un valor por defecto.
Podríamos hacerlo de la siguiente forma:

Sub Prueba2()
    ' Si no se indica ninguno de los dos parámetros,
    ' usar los valores "por defecto"
    Prueba2(3, 5)
End Sub
Sub Prueba2(ByVal uno As Integer)
    ' Si no se indica el segundo parámetro,
    ' usar el valor "por defecto"
    Prueba2(uno, 5)
End Sub
Sub Prueba2(ByVal uno As Integer, ByVal dos As Integer)
    Console.WriteLine("uno = {0}, dos = {1}", uno, dos)
    Console.WriteLine()
End Sub

Es decir, si no se indica ningún parámetro, se usará la primera declaración, desde la que se llama a la tercera declaración que recibe los dos valores que nosotros queremos que tenga por defecto.
Si se usa la segunda declaración, se usará como primer valor el que se ha indicado y como segundo el predeterminado.
Y por último, si indicamos los dos parámetros se llamará a la tercera declaración.

Nota:
Cuando se usan procedimientos sobrecargados, es el propio compilador de Visual Basic .NET el que decide cual es el procedimiento que mejor se adecua a los parámetros que se han indicado al llamar a ese procedimiento.

Otra de las ventajas de la sobrecarga de procedimientos, es que además de poder indicar un número diferente de parámetros, es que podemos indicar parámetros de distintos tipos.
Esto es útil si queremos tener procedimientos que, por ejemplo, reciban parámetros de tipo Integer o que reciba parámetros de tipo Double, por poner sólo dos ejemplos.
Incluso podemos hacer que una función devuelva valores de tipos diferentes, aunque en este caso el número o tipo de los parámetros debe ser diferente, ya que no se pueden sobrecargar procedimientos si sólo se diferencian en el tipo de datos devuelto.
Tampoco se pueden sobrecargar Propiedades con métodos (Sub o Function), es decir, sólo podemos sobrecargar propiedades con otras propiedades o procedimientos (Sub o Function) con otros procedimientos (Sub o Function).

Para más información, puedes consultar la ayuda de Visual Studio .NET:
ms-help://.../vbcn7/html/vaconOverloadingInVisualBasicNET70.htm
ms-help://.../vbcn7/html/vaconoverridingexistingmethods.htm
 

 

Sobrecargar el constructor de las clases

Una de las utilidades más prácticas de la sobrecarga de procedimientos es sobrecargar el constructor de una clase.

Sí, ya se que no te he explicado de que va eso del constructor de una clase, así que aquí tienes un pequeño adelanto:
El constructor de una clase es un procedimiento de tipo Sub llamado New, dicho procedimiento se ejecuta cada vez que creamos un nuevo objeto basado en una clase.
Si al declarar una clase no escribimos el "constructor", será el compilador de Visual Basic .NET el que se encargará de escribir uno genérico.

Nota:
De esto del constructor de las clases hablaremos más en otra ocasión, por ahora sólo quiero que sepas que existe y para que se usa.

Como te decía, esto es útil si queremos que al crear un objeto (o instancia) de una clase podamos hacerlo de varias formas, por ejemplo, sin indicar ningún parámetro o bien indicando algo que nuestra clase necesite a la hora de crear una nueva instancia de dicha clase.

Por ejemplo, si tenemos una clase llamada Cliente, puede sernos útil crear nuevos objetos indicando el nombre del cliente que contendrá dicha clase.
Veámoslo con un ejemplo:

Class Cliente
    Public Nombre As String
    Public email As String
    '
    Sub New()
        '
    End Sub

    Sub New(ByVal elNombre As String)
        Nombre = elNombre
    End Sub
End Class

Esta clase nos permite crear nuevos objetos del tipo Cliente de dos formas.
Por ejemplo si tenemos una variable llamada cli, declarada de esta forma:
Dim cli As Cliente
podemos crear nuevas instancias sin indicar ningún parámetro:
cli = New Cliente()
o indicando un parámetro, el cual se asignará a la propiedad Nombre de la clase:
cli = New Cliente("Guillermo")

Nota:
Como te dije en la nota anterior, de esto del constructor hablaremos en otra ocasión con algo de más detalle o profundidad.

 

Array de parámetros opcionales

También puede ser que necesitemos que un procedimiento reciba una cantidad no predeterminada de parámetros, en esos casos podemos usar un array (o matriz) de parámetros opcionales.
Para poder indicar esta clase de parámetros, debemos usar la instrucción ParamArray seguida de una matriz, por ejemplo si tenemos un procedimiento declarado de esta forma:

Sub Prueba3(ByVal uno As Integer, ByVal ParamArray otros() As Integer)

Podemos llamarlo usando uno o más parámetros:
Prueba3(1)
Prueba3(1, 2, 3, 4, 5, 6, 7)
Prueba3(1, 2)

Lo único que debemos tener presente es que el array de parámetros indicados con ParamArray debe ser el último parámetro indicado en la declaración del procedimiento y que no es necesario usar la palabra Optional, ya que estos parámetros son opcionales de forma predeterminada.

Para más información, consulta la ayuda de Visual Studio .NET:
ms-help://.../vbcn7/html/vaconUnderstandingParamArrays.htm

 

 

Bueno, creo que vamos a dejarlo aquí, para que digieras todo lo que hemos visto, que aunque no haya sido muy extenso es algo que deberías probar, además de consultar la documentación de Visual Studio .NET, aunque sea en los temas relacionados con esto de la sobrecarga de procedimientos y los parámetros opcionales... que tampoco es plan de que te lo leas todo, ya que entonces... no tendré que contarte nuevas cosas...

En la siguiente entrega seguiremos tratando el tema de los procedimientos, entre las cosas que tengo previstas explicarte están la forma de indicar el ámbito o "cobertura" de los procedimientos y seguramente entraremos en detalle de cómo declarar y usar los procedimientos de tipo Property.
Pero eso será en la próxima entrega, mientras tanto... que disfrutes.

Nos vemos.
Guillermo
Nerja, 29, 30 de Abril de 2003