Lo nuevo de punto NET 3.0 α (preview)

VB9: Tipos de proyectos y tipos implícitos

Publicado el 17/Ene/2006
Actualizado el 11/Abr/2007
Autor: Guillermo 'guille' Som

En este artículo veremos los tipos de proyectos que podemos crear con el LINQ VB Preview y cómo maneja el Visual Basic 9.0 los tipos de datos de forma implícita, además de ver cómo crear e inicializar objetos de un tipo de una clase y cómo inicializar arrays y colecciones usando esa forma de crear objetos.

Nota del 11/Abr/2007:
La forma de crear los tipos implícitos (con New) ha cambiado desde la fecha en que publiqué este artículo. Ahora los "nuevos" tipos implícitos se definen con New With { .Propiedad = valor }
Y si se quiere crear un tipo existente, hay que indicarlo entre New y With.
Además en este último caso, el tipo debe definir un constructor predeterminado (sin parámetros).

 

Introducción:

Para poder usar la versión preview de Visual Basic 9.0 (Orcas) primero debemos instalar el LINQ Preview para VB.
El proceso es muy simple, solo tenemos que ejecutar el instalador (.msi) y seguir las indicaciones (es decir, aceptar el contrato y pulsar en siguiente hasta finalizar).
Una vez instalado ya tendremos todo lo necesario para que podamos usarlo, recuerda que debes tener instalada la versión final (no una beta) del Visual Studio 2005 o Visual Basic 2005 Express Edition.

Lee esto si tienes problemas al instalar el LINQ para VB en un equipo que tiene instalado la versión normal de Visual Studio 2005 y la versión Express de Visual Basic 2005.

Al instalar el LINQ Preview se añade al VB actual lo necesario para que se utilicen las nuevas características y se coloreen las nuevas instrucciones, si bien, la forma en la que han hecho esta preview, que en realidad trabaja con el mismo IDE de Visual Basic 2005, no es sustituir el Visual Basic que tengamos actualmente instalado, sino usar solo la nueva versión cuando creamos proyectos de LINQ, por tanto se asegura que no afectará al funcionamiento de Visual Basic 2005, aunque, al ser una pre-beta, siempre es recomendable que se utilice en máquinas que no sean de producción, porque... en fin, si las versiones finales fallan, ¿qué crees que puede ocurrir con una versión que ni siquiera llega a la categoría de beta), por tanto cualquier tipo de precaución que tomes, siempre será buena, ya que lo que debes asegurarte es de que lo que de verdad debe funcionar, siga funcionando. Así que, si no quieres llevarte sorpresas: asegúrate. También debo decir, que desde la preview para la versión Release Candidate (RC) de Visual Studio 2005 no he tenido ningún problema después de instalar y desinstalar las versiones "preview" de VB9.
Cuando pulsamos en crear un nuevo proyecto tendremos tres nuevos tipos de proyectos: (ver la figura 1 para los tipos de proyectos de Visual Basic 2005 Express).

• LINQ Windows Application
• LINQ Class Library
• LINQ Console Application

En este primer ejemplo, crearemos una aplicación del tipo LINQ Console Application.

 

Figura 1. Crear un nuevo proyecto de LINQ para Visual Basic

 

Empecemos con el repaso a las novedades del lenguaje.

Variables con tipo implícito

Ahora podemos declarar variables sin indicar el tipo de datos, sí, ya se que Visual Basic siempre ha permitido hacer esto, pero como veremos no es lo mismo que si no usamos Option Explicit On ni Option Strict On.

En las versiones actuales, si declaramos una variable de esta forma:

Dim variable

En realidad estamos declarando una variable de tipo Object, que es el tipo de datos predeterminado, además de que todo lo que hagamos posteriormente con esa variable utilizará lo que se llama "late-binding" o compilación tardía, ya que hasta que no llegue el momento de asignar o usar el valor de esa variable no se sabrá de que tipo es.

Sin embargo en Visual Basic 9.0 (VB9 para abreviar), si hacemos esa declaración (así como te he mostrado antes), nos dará un aviso de que todas las variables deben declararse con la cláusula As, al menos si tenemos Option Strict conectado, (¿que tu no usas Option Strict On? pues ya puedes irte a otra parte, que ya deberías saber que el Guille siempre recomienda el uso de Option Strict On), pero si esa declaración la hacemos al asignar un valor, por ejemplo:

Dim variable = "el Guille"

El VB9 sabe que es de tipo String, por tanto no hace falta que lo indiquemos de forma expresa, aunque también podemos seguir usando el viejo estilo:

Dim variable As String = "el Guille"

Pero en ese caso, pues como que no tiene gracia... ¿no?, pues eso...

Los tipos que podemos asignar son TODOS, ya sean predefinidos en el lenguaje o en .NET o bien tipos que nosotros hayamos definido.

Por ejemplo, podemos hacer estas declaraciones:

Dim i = 10
Dim d = 10.5

Y si tenemos una clase de tipo Colega creada:

Class Colega
    Public Nombre As String
    Public Correo As String
    Public FechaNacimiento As Date
End Class

Podemos crear un nuevo objeto de esta forma:

Dim c1 = New Colega {Nombre := "Pepe", Correo := "[email protected]", FechaNacimiento := #1/31/1900#}

Es decir, podemos inicializarlo directamente, (esto seguramente te recordará a como se usan los atributos), sin necesidad de definir un constructor que reciba esos parámetros.

Al usar esa variable, (como podemos comprobar en la figura 2), el tipo es Colega:

Figura 2. Los tipos implícitos realmente son tipos del dato que contienen

 

Pero esto no es lo mejor, ya que Visual Basic 9 nos permite crear ese tipo de objetos sin siquiera tener que indicar que tipo de datos es, es el propio compilador el que se encarga de averiguarlo, y como el IDE utiliza la compilación en segundo plano mientras escribimos, incluso nos permite usar IntelliSense para acceder a los campos del nuevo objeto.
Por tanto, si escribimos el siguiente código y accedemos a los campos que tiene la variable c2, nos mostrará lo mismo que en la figura 2.

' En VB9, podemos crear el objeto y el compilador
' se encargará de averiguar el tipo, permitiendo incluso el uso de IntelliSense
Dim c2 = New {Nombre := "Luis", Correo := "[email protected]"}
Console.WriteLine("{0}, {1}", c2.Nombre, c2.Correo)

 

 

Incluso podemos hacer más, podemos definir y rellenar directamente una colección o un array del tipo Colega de esta forma:

Dim colegas = New List(Of Colega) { _
        New Colega {nombre := "pepe"}, _
        New Colega {nombre := "luisa"} _
        }

Y después usar un bucle For Each sin necesidad de indicar de que tipo es la variable:

For Each c In colegas
    Console.WriteLine("Nombre: {0}", c.Nombre)
Next

El propio Visual Basic "deducirá" el tipo por la colección, que al declararla como List(Of Colega) sabe que los elementos "tienen" que ser del tipo Colega, por tanto al escribir ese código, y después de pulsar el punto, el Intellisense nos mostrará los miembros del objeto c, siendo los mismos que vimos en la figura 2.

Además, como puedes comprobar por el código que define la colección, no tenemos porqué especificar todos los miembros de la clase, sino los que realmente queremos asignar, incluso lo podemos hacer en cualquier orden, ya que al usar el "estilo" de parámetros opcionales (indicando el nombre de la propiedad seguida de :=) no habrá confusión de que propiedad queremos usar y a la que por tanto queremos asignar el valor.

 

Cuando definimos arrays, lo tenemos más fácil, ya que el propio compilador detecta el tipo adecuado:

' Los arrays los creamos sin indicar el tipo
Dim mascolegas() = { _
        New Colega {nombre := "ana"}, _
        New Colega {nombre := "benito"} _
        }

Para mostrarlos, podemos usar el mismo código que para mostrar el contenido de la colección, ya que el For Each sigue funcionando igual, además podemos usar un bucle de tipo "normal" con acceso a los elementos por medio del índice, en el que por supuesto no tenemos porqué indicar de que tipo es la variable del bucle:

Console.WriteLine("Usando un For con índice:")
For i = 0 To mascolegas.Length - 1
    Console.WriteLine("{0} - Nombre: {1}", i, mascolegas(i).Nombre)
Next

 

 

Bueno, para ir abriendo boca, creo que ya está bien... otro día te voy contando cosas, que serán aún muchísimo más interesantes... ¡ya verás!

 

Nos vemos.
Guillermo

P.S.
Pulsa en este link para ver cómo se manejan los tipos implícitos en C# 3.0