var (Referencia de C#)

A partir de C# 3, las variables que se declaran en el ámbito de método pueden tener un "tipo" var implícito. Una variable local con tipo implícito es fuertemente tipada exactamente igual que si hubiera declarado el tipo, solo que en este caso es el compilador el que lo determina. Las dos declaraciones siguientes de i tienen una función equivalente:

var i = 10; // Implicitly typed.
int i = 10; // Explicitly typed.

Importante

Cuando var se usa con tipos de referencia que aceptan valores NULL, siempre implica un tipo de referencia que acepta valores NULL, aunque el tipo de expresión no los acepte. El análisis de null-state del compilador protege frente a la desreferenciación de un posible valor null. Si la variable nunca se asigna a una expresión que pueda ser NULL, el compilador no emitirá ninguna advertencia. Si asigna la variable a una expresión que podría ser NULL, debe probar que no sea NULL antes de desreferenciarla para evitar advertencias.

Un uso común de la palabra clave var es con las expresiones de invocación del constructor. El uso de var permite no repetir un nombre de tipo en una declaración de variable y una creación de instancias de objeto, como se muestra en el ejemplo siguiente:

var xs = new List<int>();

A partir de C# 9.0, se puede usar una expresión new de con tipo de destino como alternativa:

List<int> xs = new();
List<int>? ys = new();

En la coincidencia de patrones, la palabra clave var se usa en un patrón var.

Ejemplo

En el siguiente ejemplo se muestran dos expresiones de consulta. En la primera expresión, el uso de var se permite pero no es necesario, ya que el tipo del resultado de la consulta se puede indicar explícitamente como IEnumerable<string>. En cambio, en la segunda expresión, var permite que el resultado sea una colección de tipos anónimos y solo el compilador puede tener acceso al nombre de ese tipo. El uso de var elimina la necesidad de crear una nueva clase para el resultado. Tenga en cuenta que, en el ejemplo 2, la variable de iteración foreach``item también debe tener tipo implícito.

// Example #1: var is optional when
// the select clause specifies a string
string[] words = { "apple", "strawberry", "grape", "peach", "banana" };
var wordQuery = from word in words
                where word[0] == 'g'
                select word;

// Because each element in the sequence is a string,
// not an anonymous type, var is optional here also.
foreach (string s in wordQuery)
{
    Console.WriteLine(s);
}

// Example #2: var is required because
// the select clause specifies an anonymous type
var custQuery = from cust in customers
                where cust.City == "Phoenix"
                select new { cust.Name, cust.Phone };

// var must be used because each item
// in the sequence is an anonymous type
foreach (var item in custQuery)
{
    Console.WriteLine("Name={0}, Phone={1}", item.Name, item.Phone);
}

Vea también