ATENCIÓN: este contenido tiene más de 2 años de antigüedad y, debido a su temática, podría contener información desactualizada o inexacta en la actualidad.
En C# es posible dejar al compilador la tarea de determinar el tipo de una variable que hayamos inicializado de manera explícita.
El tipo se deduce a partir de la expresión de inicialización. De este modo nos evitamos tener que declarar el tipo correcto, sobre todo en casos en los que no lo tenemos claro de antemano, como por ejemplo en consultas de LINQ, o en funciones polimórficas que devuelven diversos tipos que implementan la misma interfaz.
Así, por ejemplo, en el siguiente ejemplo el compilador infiere que la variable n es de tipo int y que s es de tipo string por el tipo de las constantes que se intenta asignar a cada una:
var n = 5; // equivale a int n = 5;
var s = "Hola"; // equivale a string s = "Hola";
Por supuesto, se mantienen en vigor las reglas del lenguaje para determinar el tipo de las expresiones:
var m = 3 * n; // m es de tipo int
var dosPi = 2 * Math.PI; // dosPi es de tipo double
El mecanismo también funciona para otros tipos cualesquiera:
var p1 = new Persona("Ana", 24); // p1 es de tipo Persona
var p2 = p1; // p2 también
var enteros = new List(); // enteros es de tipo List
var f1 = DateTime.Now.AddMonths(1); // f1 es de tipo DateTime
Los siguientes son ejemplos de usos incorrectos de var:
var p; // la inicialización es obligatoria
var q = null; // imposible inferir el tipo de q
var z1 = 3, z2 = 5; // no se admiten declaraciones múltiples
var r = { 1, 2, 3 };
// un inicializador de array no está permitido
Es importante destacar que esta característica no tiene nada que ver con la que ofrecen algunos lenguajes dinámicos, en los que una variable puede almacenar valores de distintos tipos a lo largo de su tiempo de vida. En este caso el compilador simplemente nos libera de la necesidad de especificar el tipo de una variable inicializada e infiere el tipo de la variable declarada mediante el identificador “especial” var a partir del tipo de la expresión que se le asigna.
La verificación estricta de tipos, uno de los pilares del lenguaje, sigue por supuesto en vigor, y la mejor manera de comprobarlo es, nuevamente, utilizando una herramienta como Reflector o DotPeek, que nos dejarán ver claramente que esas variables tienen un tipo concreto asignado por el compilador:
En este caso se muestra cómo el compilador detecta el tipo correcto para cada variable en el primero de los ejemplos, más arriba.
La declaración implícita del tipo de una variable puede utilizarse también en otras construcciones del lenguaje, como el bucle foreach o la sentencia using:
foreach (var k in listaEnteros) // k es de tipo int
Console.WriteLine(k);
using (var con = new SqlConnection(cadenaConexion))
// con es de tipo SqlConnection
{
con.Open();
// interactuar con la base de datos...
}
Mucha gente tiene miedo de utilizar esta construcción por creer que va a perder la comprobación estricta de tipos que ofrece el lenguaje. Como has podido ver, nada más lejos de la realidad, así que anímate a usarlo :-)
Fecha de publicación: