Continuando con las series de nuevas características con C# 3.0, veré un ejemplo de la inicialización implícita para variables locales y arreglos de tipo.
En C# 3.0 es posible que el desarrollador no necesite declarar el tipo de la variable cuando inicia su valor, esto se conoce como iniciación implícita. En su lugar el compilador toma el tipo de dato de la variable declarada mediante el tipo de dato de la expresión de inicialización. Para poder utilizar una variable local implícita es necesario declarar la variable como var. Esto nos recuerda al uso de VB, cuando se utilizaba variable de tipo var (variant), pero en este caso NO es lo mismo, solo es la simplicidad de evitar líneas de código, ya que la validación entre tipos de datos se sigue respetando.
Para mayor claridad un ejemplo:
class Program
{
static void Main(string[] args)
{
ImplicitTypes types = new ImplicitTypes();
types.Test();
}
}
public class ImplicitTypes
{
public void Test()
{
int i = 200;
string s = "Variable para la prueba";
int[] array = new int[] { 10, 20, 30 };
SortedList<String, List<StringBuilder>> complexList =
new SortedList<string, List<StringBuilder>>();
i = 400;
s = "New value";
array[2] = 40;
complexList.Add("A", new List<StringBuilder>
{ new StringBuilder("AA"),
new StringBuilder("AB")
});
Console.WriteLine(i);
Console.WriteLine(s);
Console.WriteLine(array[2]);
foreach (StringBuilder item in complexList["A"])
{
Console.WriteLine(item);
}
}
}
El ejemplo anterior tenemos la declaración de diferentes variables locales dentro de un método, esta sería la implementación tradicional, ahora con C# 3.0 podríamos sustituir estas variable por variables locales implícitas, lo que arrojaría exactamente el mismo resultado.
public class ImplicitTypes
{
public void Test()
{
var i = 200;
var s = "Variable para la prueba";
var array = new [] { 10, 20, 30 };
var complexList =
new SortedList<string, List<StringBuilder>>();
i = 400;
s = "New value";
array[2] = 40;
complexList.Add("A", new List<StringBuilder>
{ new StringBuilder("AA"),
new StringBuilder("AB")
});
Console.WriteLine(i);
Console.WriteLine(s);
Console.WriteLine(array[2]);
foreach (var item in complexList["A"])
{
Console.WriteLine(item);
}
}
}
Cabe destacar que existen restricciones para la utilización de variables implícitas que evitan problemas de utilización de tipos diferentes. Veamos:
Debido a que las variables toman su tipo de la sentencia de inicialización, NO es posible declarar variables implícitas sin iniciar.
var i; //Error se debe inicializar siempre una variable implícita
i = 200;
El compilador arroja el mensaje de "Implicity-typed local variables must be initialized"
var array = { 10, 20, 30 };
La inicialización de un arreglo sin definir su tipo de dato no esta permitido.
El compilador arrojará el mensaje "Cannot initialize an implicitly-typed local variable with an array initializer" y "Can only use array initializer expressions to assign to array types. Try using a new expression instead."
En este caso el problema se resuelve indicando que se esta iniciando un arreglo.
var array = new [] { 10, 20, 30 };
Si tratamos de asignar dos variables implícitas pero de diferente tipo de inicialización, el compilador verifica los tipos de datos de la misma manera que si hubiéramos definiendo el tipo de la variable.
var i = 200;
var s = "Variable para la prueba";
i = s; //Error
Cannot implicitly convert type 'string' to 'int'
Esta característica esta pensada para simplificar las líneas de código que el desarrollador utiliza para el uso de variables locales.