Lo nuevo de punto NET 3.0 α (preview)

C# 3.0: Tipos implícitos

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

En este artículo veremos cómo maneja C# 3.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.

Introducción:

Al igual que ocurre con Visual Basic 9.0, en C# 3.0 también podemos usar tipos implícitos, es decir, tipos de datos que el compilador se encargará de averiguar de que tipo es. Para poder usar este tipo de datos, el lenguaje C# añade una nueva instrucción: var, (esta instrucción la podemos comparar con el Dim de VB), y es la que permite indicar a C# de que estamos usando un tipo de datos que debe "averiguarse" en el momento de la compilación.
El uso de esta instrucción en C# es mucho más impactante que en Visual Basic, no porque tenga un rendimiento diferente, sino porque los programadores de C# no están acostumbrados a usar variables sin que se haya indicado explícitamente el tipo, a diferencia de algunos programadores de VB que "por comodidad", y erróneamente pensando que es más fácil, no indican los tipos de datos de las variables, aunque, afortunadamente esto en la plataforma .NET ya no es tan habitual como lo era en VB6 y anteriores... pero bueno, dejemos las batallitas del Guille y veamos algunos ejemplos de cómo usar los tipos implícitos en C# 3.0.

Empecemos viendo cómo declarar variables "normales", es decir, las definidas en el propio lenguaje o, mejor dicho, en .NET:

var i = 10;
var d = 10.5;
var s = "Hola, Mundo";
//
Console.WriteLine("El tipo de i es: {0} ({1})", i.GetType().Name, i);
Console.WriteLine("El tipo de d es: {0} ({1})", d.GetType().Name, d);
Console.WriteLine("El tipo de s es: {0} ({1})", s.GetType().Name, s);
Console.WriteLine();
//
var n = i * d;
Console.WriteLine("El tipo de n es: {0} ({1})", n.GetType().Name, n);
var j = i * 3;
var k = s + " (el típico)";
Console.WriteLine("El tipo de k es: {0} ({1})", k.GetType().Name, k);
//
var variable = "el Guille";

 

En todos estos ejemplos, el compilador de C# averiguará el tipo de datos que debe tener cada variable y le aplicará ese tipo, esto lo podemos comprobar viendo la salida del código, en el que además del valor, nos muestra el tipo de cada variable.
La salida de ese código es la siguiente:

Figura 1. Salida del código de ejemplo de tipos "normales" implícitos

 

Además de los tipos definidos en el propio .NET, también podemos crear variables que usa el tipo implícito a partir de un tipo definido por nosotros mismos, por ejemplo, una clase:

class Colega
{
    public string Nombre;
    public string Correo;
    public DateTime FechaNacimiento;
}

Teniendo esta clase, podemos crear tipos simples indicando el tipo de datos en el constructor y los valores que queremos asignarles:

var c1 = new Colega {Nombre = "Pepe", Correo = "[email protected]"};

Al crear esta variable, podemos usar IntelliSense en el IDE de C# para acceder a los miembros de la variable c1, tal como vemos en la siguiente figura:

Figura 2. En el IDE de C# podemos usar IntelliSense con los tipos implícitos

 

También podemos crear nuevos objetos sin necesidad de "avisar" de cual es, ya que el compilador de C# se encargará de averiguar el tipo de datos, en este caso, el IntelliSense de C# no "sabe" de que tipo es, ya que será en tiempo de compilación cuando lo averigüe:

var c2 = new {Nombre = "Luis", Correo = "[email protected]"};
Console.WriteLine("{0}, {1}", c2.Nombre, c2.GetType().Name);

Si bien, el tipo que "pretende" ser es el que el compilador de C# crea internamente a partir del constructor y en realidad no será un tipo Colega.

 

También podemos definir e inicializar colecciones a partir de tipos implícitos, si la colección es generic, debemos indicar de que tipo será la colección y cada elemento lo debemos crear usando el nombre de la clase, ya que de no hacerlo así recibiremos un error, por la sencilla razón de que si no indicamos el tipo de datos, es el propio C# el que crea uno interno para usar con esa colección, por tanto la forma recomendable de hacerlo sería así:

var colegas = new List<Colega>{ 
    new Colega {Nombre = "pepe"}, new Colega {Nombre = "luisa"}
    };

 

Para recorrer los elementos de esa colección podemos usar un bucle foreach, en el que la variable que obtendrá cada uno de los valores no tiene porqué estar expresamente definida con un tipo de datos, ese tipo se averigua al indicar la colección que va después de la instrucción in, y aunque mientras escribimos el código el IntelliSense no nos muestra los miembros de esa variable, al mostrar el nombre del tipo de datos, nos dirá que es Colega, ya que la colección colegas es una colección de tipo List<Colegas>.

foreach(var c in colegas){
    Console.WriteLine("Nombre: {0}", c.Nombre);
}

 

También podemos crear arrays e inicializarlos usando los constructores "automáticos", pero al igual que ocurre con las colecciones, debemos indicar que tipo de datos contendrá ese array:

Colega[] mascolegas = { new Colega {Nombre = "ana"}, new Colega {Nombre = "benito"} };

 

Por supuesto, este array lo podemos recorrer indistintamente con un bucle foreach o con un bucle for normal, de los que usan índices para acceder a los elementos, como es de suponer, la variable usada para el índice no tenemos porque definirla de un tipo concreto, el compilador se encargará de usar el tipo que crea conveniente:

for(i = 0; i < mascolegas.Length; i++){
    Console.WriteLine("{0} - Nombre: {1}", i, mascolegas[i].Nombre);
}

 

Pues esto es todo lo que veremos hoy sobre los tipos implícitos en C# 3.0, pero en otros artículos iremos viendo más cosillas, que seguramente te "encandilarán" más que esto... (pues sí que eres difícil de impresionar...)

 

Nos vemos.
Guillermo

P.S.
Pulsa este link para ver esta misma característica en Visual Basic 9.0