var (Referencia de C#)var (C# Reference)

A partir de Visual C# 3.0, las variables que se declaran en el ámbito de método pueden tener un "tipo" var implícito.Beginning in Visual C# 3.0, variables that are declared at method scope can have an implicit "type" var. 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.An implicitly typed local variable is strongly typed just as if you had declared the type yourself, but the compiler determines the type. Las dos declaraciones siguientes de i tienen una función equivalente:The following two declarations of i are functionally equivalent:

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

Para obtener más información, vea Implicitly typed local variables (Variables locales con tipo implícito) y Type relationships in LINQ query operations (Relaciones entre tipos en las operaciones de consulta de LINQ).For more information, see Implicitly Typed Local Variables and Type Relationships in LINQ Query Operations.

EjemploExample

En el siguiente ejemplo se muestran dos expresiones de consulta.The following example shows two query expressions. 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>.In the first expression, the use of var is permitted but is not required, because the type of the query result can be stated explicitly as an 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.However, in the second expression, var allows the result to be a collection of anonymous types, and the name of that type is not accessible except to the compiler itself. El uso de var elimina la necesidad de crear una nueva clase para el resultado.Use of var eliminates the requirement to create a new class for the result. Tenga en cuenta que, en el ejemplo 2, la variable de iteración foreach item también debe tener tipo implícito.Note that in Example #2, the foreach iteration variable item must also be implicitly typed.

// Example #1: var is optional because
// 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 when
// 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énSee Also

Referencia de C#C# Reference
Guía de programación de C#C# Programming Guide
Variables locales con asignación implícita de tiposImplicitly Typed Local Variables