var - Variables Locales de Tipo Deducido Implícitamente en C#

Tabla de Contenido

0. Introducción
1. Deducción de tipos - var
2. var y los Tipos Anónimos
3. Consideraciones e Implicaciones del Uso de var
4. Conclusiones
5. Glosario
6. Referencias

0. Introducción

En muchas oportunidades sea por conveniencia, comodidad, sobre el código fuente, el programador puede solicitar al compilador de C# que en tiempo de ejecución se encargue de deducir o inferir los tipos de una variable a partir de la evaluación de la expresión, el tipo de dato que se le ha de asignar a la parte izquierda de la instrucción: el identificador. Es aquí donde el lenguaje C# cuenta con una construcción propia para llevar a cabo toda esta tarea 'mágica': var.

1. Deducción de Tipos - var

Comúnmente, estamos acostumbrados a ser explícitos en la especificación de tipos a las variables que declaramos en el código fuente de nuestros programas. Esto ocurre, por supuesto, en lenguajes de programación fuertemente tipeados (en Seguridad de Tipos en C# se puede profundizar aún más en este tema); al contrastar con lenguajes débilmente tipeados (como puede ser el caso de PHP [1]), éstos dan mucha flexibilidad al programador en la tarea declaración de variables, dado que no es necesario especificar el tipo de la variable a declarar (al igual, también trae consigo algunos bugs inherentes al código relacionados con la conversión de tipos, evaluación de expresiones que generan valores de tipos diferentes, etc).

Continuando, desde la versión 3.0 de C# [2] nuevas características fueron introducidas, entre ellas la de deducción de tipos (a través de var), que en un principio consiste en una regla simple:

sí el compilador es capaz de inferir el tipo a partir del tipo del valor de la evaluación de una pressión, entonces la construcción var puede ser utilizada en ese lugar.

A través de los siguientes ejemplos en código fuente se puede ilustrar con más detalle el concepto de var:

var x = "OrtizOL";

var y = new System.Text.StringBuilder();

var z = (float)Math.PI;

La parte derecha de la instrucción de cada uno de estos ejemplos, a simple vista, nos informa del tipo de dato a declarar a cada uno de los identificadores (esta es la tarea del compilador).

Las instrucciones anteriores son equivalantes a estas:

string x = "OrtizOL";

System.Text.StringBuilder y = new System.Text.StringBuilder();

float z = (float)Math.PI;

Evidentemente, en las instrucciones recientes el programador ha hecho uso directo o explícito del tipo a declarar cada uno de los tres identificadores ( x:string, y:System.Text.StringBuilder, y z:float).

Otros ejemplos útiles

// a es compilado como un arreglo de enteros (int[])

var a = new[] { 0, 1, 2 };

En una instrucción de inicialización de la estructura repetiva for [3]:

for(var x = 1; x < 10; x++);

En una instrucción de inicialización foreach [3]:

foreach(var item in lista)

{

//...

}

También, en una instrucción using:

using (var archivo = new StreamReader("X:\\MiArchivo.txt")) {...}

2. var y los Tipos Anónimos

[3]: El uso de var puede ser asunto simplemente de comodidad sintáctica, o en la mayoría de casos opcional. Sin embargo, en situaciones que el tipo de dato no es conocido ni por el programador ni el compilador, estamos hablando de los tipos anónimos; en este escenario usar var es mandatorio. Un escenario donde se presenta, según [3], esta situación es en el uso de de expresiones de consulta LINQ [4]. Aquí está un ejemplo (tomado de [3]):

Archivo C# ImplicitlyTypedLocals.cs [enlace alternativo]:

► Prueba de ejecución.

En la línea 16 gracias al uso de var podemos acceder a las propiedadese del tipo anónimo (que es aquel que se instancia (sin conocer su tipo) en las líneas 9-11).

3. Consideraciones e Implicaciones del Uso de var

En [5] se declara que a pesar de la flexibilidad o comodidad sintáctica que ofrece C# a través de var, existe la siguiente restricción:

var x = 5;
x = "OrtizOR"; // Error en tiempo de compilación, x es de tipo int

Esto se debe a que las variables deducidas implícitamente son tipos estáticos, es decir (para este caso), que una vez inferido su tipo, éste no puede ser cambiado por cualquier otro: en el caso anterior se pretende pasar de int a string (lo cual es imposible debido a la razón anterior. {Lectura recomendad: [6]}.

Restricciones sobre var:

• Un variable var no puede inicializar con null.
• var no se puede utilizar en campos de instancia.
• Sólo está permitido su uso en la misma instrucción donde se declara y se inicializa la variable.
• No está permitida la inicialización de tipos implícitos, en una misma instrucción:
  
  Permitido:
  int x = y = z = 0;
  
  No permitido:
  var x = y = y = 0;

Por otro lado en [5]:

var can decrease code readability in the case when you can't deduce the type purely by looking at the variable declaration. For example: 

Random r = new Random();

var x = r.Next();

What type is x?

4. Conclusiones

Podemos optar por el uso de var en muchos escenarios (casi cualquiera) pero debemos tener en cuenta aspectos de legibilidad del código, compatibilidad hacia atrás (versiones anteriores a la 3.0 de C#). No deberíamos decantarnos por el uso de var por el siemple hecho de comodidad sintáctica. Para resaltar una vez más, el uso sobresaliente de var se da en el manejo de Tipos Anónimos (tema que trataré en varios artículos futuros). 

5. Glosario

- Comodidad sintáctica
- Débilmente tipeado
- Fuertamente tipeado
- Tipo anónimo

6. Referencias

[1]: PHP - Wikipedia, the free encyclopedia - http://en.wikipedia.org/wiki/PHP
[2]: Overview of C# 3.0 - http://msdn.microsoft.com/en-us/library/bb308966.aspx
[3]: Variables locales con asignación implícita de tipos (Guía de programación de C#) - http://msdn.microsoft.com/es-es/library/bb384061.aspx
[4]: Language Integrated Query - Wikipedia, the free encyclopedia - http://en.wikipedia.org/wiki/Language_Integrated_Query
[5]: C# 5.0 in a Nutshell by Joseph Albahari and Ben Albahari. Copyright 2012 Joseph Albahari and Ben Albahari, 978-1-449-32010-2.
[6] Introduction to Static and Dynamic Typing - SitePoint - http://www.sitepoint.com/typing-versus-dynamic-typing/

O