Variables locales con asignación implícita de tipos (Guía de programación de C#)Implicitly typed local variables (C# Programming Guide)

Las variables locales pueden declararse sin proporcionar un tipo explícito.Local variables can be declared without giving an explicit type. La palabra clave var indica al compilador que infiera el tipo de la variable a partir de la expresión de la derecha de la instrucción de inicialización.The var keyword instructs the compiler to infer the type of the variable from the expression on the right side of the initialization statement. El tipo inferido puede ser un tipo integrado, un tipo anónimo, un tipo definido por el usuario o un tipo definido en la biblioteca de clases .NET Framework.The inferred type may be a built-in type, an anonymous type, a user-defined type, or a type defined in the .NET Framework class library. Para obtener más información sobre cómo inicializar las matrices con var, vea Matrices con tipo implícito.For more information about how to initialize arrays with var, see Implicitly Typed Arrays.

Los ejemplos siguientes muestran distintas formas en que se pueden declarar variables locales con var:The following examples show various ways in which local variables can be declared with var:

// i is compiled as an int
var i = 5;

// s is compiled as a string
var s = "Hello";

// a is compiled as int[]
var a = new[] { 0, 1, 2 };

// expr is compiled as IEnumerable<Customer>
// or perhaps IQueryable<Customer>
var expr =
    from c in customers
    where c.City == "London"
    select c;

// anon is compiled as an anonymous type
var anon = new { Name = "Terry", Age = 34 };

// list is compiled as List<int>                             
var list = new List<int>();

Es importante comprender que la palabra clave var no significa "variant" ni indica que la variable esté débilmente tipada o esté enlazada en tiempo de ejecución.It is important to understand that the var keyword does not mean "variant" and does not indicate that the variable is loosely typed, or late-bound. Solo significa que el compilador determina y asigna el tipo más adecuado.It just means that the compiler determines and assigns the most appropriate type.

La palabra clave var se puede usar en los contextos siguientes:The var keyword may be used in the following contexts:

  • En variables locales (variables declaradas en el ámbito del método), tal y como se muestra en el ejemplo anterior.On local variables (variables declared at method scope) as shown in the previous example.

  • En una instrucción de inicialización for.In a for initialization statement.

    for(var x = 1; x < 10; x++)
    
  • En una instrucción de inicialización foreach.In a foreach initialization statement.

    foreach(var item in list){...}
    
  • En una instrucción using.In a using statement.

    using (var file = new StreamReader("C:\\myfile.txt")) {...}
    

Para obtener más información, vea Cómo: Usar matrices y variables locales con tipo implícito en expresiones de consulta.For more information, see How to: Use Implicitly Typed Local Variables and Arrays in a Query Expression.

var y tipos anónimosvar and anonymous types

En muchos casos, el uso de var es opcional y es simplemente una comodidad sintáctica.In many cases the use of var is optional and is just a syntactic convenience. Pero cuando una variable se inicializa con un tipo anónimo, la variable se debe declarar como var si necesita acceder más adelante a las propiedades del objeto.However, when a variable is initialized with an anonymous type you must declare the variable as var if you need to access the properties of the object at a later point. Se trata de un escenario común en expresiones de consulta LINQLINQ.This is a common scenario in LINQLINQ query expressions. Para obtener más información, consulte Anonymous Types (Tipos anónimos [Guía de programación de C#]).For more information, see Anonymous Types.

Desde el punto de vista del código fuente, un tipo anónimo no tiene nombre.From the perspective of your source code, an anonymous type has no name. Por lo tanto, si una variable de consulta se ha inicializado con var, la única manera de tener acceso a las propiedades de la secuencia de objetos devuelta consiste en usar var como el tipo de la variable de iteración en la instrucción foreach.Therefore, if a query variable has been initialized with var, then the only way to access the properties in the returned sequence of objects is to use var as the type of the iteration variable in the foreach statement.

class ImplicitlyTypedLocals2
{
    static void Main()
    {
        string[] words = { "aPPLE", "BlUeBeRrY", "cHeRry" };

        // If a query produces a sequence of anonymous types, 
        // then use var in the foreach statement to access the properties.
        var upperLowerWords =
             from w in words
             select new { Upper = w.ToUpper(), Lower = w.ToLower() };

        // Execute the query
        foreach (var ul in upperLowerWords)
        {
            Console.WriteLine("Uppercase: {0}, Lowercase: {1}", ul.Upper, ul.Lower);
        }
    }
}
/* Outputs:
    Uppercase: APPLE, Lowercase: apple
    Uppercase: BLUEBERRY, Lowercase: blueberry
    Uppercase: CHERRY, Lowercase: cherry        
 */

ComentariosRemarks

Las siguientes restricciones se aplican a las declaraciones de variable con tipo implícito:The following restrictions apply to implicitly-typed variable declarations:

  • var solo se puede usar cuando una variable local se declara e inicializa en la misma instrucción; la variable no se puede inicializar en null ni en un grupo de métodos o una función anónima.var can only be used when a local variable is declared and initialized in the same statement; the variable cannot be initialized to null, or to a method group or an anonymous function.

  • var no se puede usar en campos en el ámbito de clase.var cannot be used on fields at class scope.

  • Las variables declaradas con var no se pueden usar en la expresión de inicialización.Variables declared by using var cannot be used in the initialization expression. En otras palabras, esta expresión es válida : int i = (i = 20);, pero esta expresión genera un error en tiempo de compilación: var i = (i = 20);In other words, this expression is legal: int i = (i = 20); but this expression produces a compile-time error: var i = (i = 20);

  • No se pueden inicializar varias variables con tipo implícito en la misma instrucción.Multiple implicitly-typed variables cannot be initialized in the same statement.

  • Si en el ámbito se encuentra un tipo con nombre var, la palabra clave var se resolverá en ese nombre de tipo y no se tratará como parte de una declaración de variable local con tipo implícito.If a type named var is in scope, then the var keyword will resolve to that type name and will not be treated as part of an implicitly typed local variable declaration.

El establecimiento de tipos implícitos con la palabra clave var solo puede aplicarse a variables en el ámbito del método local.Implicit typing with the var keyword can only be applied to variables at local method scope. El establecimiento de tipos implícitos no está disponible para los campos de clase ya que el compilador C# encontraría una paradoja lógica al procesar el código: el compilador necesita conocer el tipo de campo, pero no puede determinar el tipo hasta que se analiza la expresión de asignación, y no se puede evaluar la expresión sin conocer el tipo.Implicit typing is not available for class fields as the C# compiler would encounter a logical paradox as it processed the code: the compiler needs to know the type of the field, but it cannot determine the type until the assignment expression is analyzed, and the expression cannot be evaluated without knowing the type. Observe el código siguiente:Consider the following code:

private var bookTitles;

bookTitles es un campo de clase dado el tipo var.bookTitles is a class field given the type var. Como el campo no tiene ninguna expresión que evaluar, es imposible que el compilador pueda inferir el tipo bookTitles que se supone que es.As the field has no expression to evaluate, it is impossible for the compiler to infer what type bookTitles is supposed to be. Además, agregar una expresión al campo (como se haría con una variable local) también es suficiente:In addition, adding an expression to the field (like you would for a local variable) is also insufficient:

private var bookTitles = new List<string>();

Cuando el compilador encuentra campos durante la compilación de código, registra el tipo de cada campo antes de procesar las expresiones asociadas a él.When the compiler encounters fields during code compilation, it records each field's type before processing any expressions associated with it. El compilador encuentra la misma paradoja intentando analizar bookTitles: necesita saber el tipo de campo, pero el compilador normalmente determinaría el tipo de var analizando la expresión, lo que no es posible sin conocer de antemano el tipo.The compiler encounters the same paradox trying to parse bookTitles: it needs to know the type of the field, but the compiler would normally determine var's type by analyzing the expression, which isn't possible without knowing the type beforehand.

Es posible que var también pueda resultar útil con expresiones de consulta en las que es difícil determinar el tipo construido exacto de la variable de consulta.You may find that var can also be useful with query expressions in which the exact constructed type of the query variable is difficult to determine. Esto puede ocurrir con las operaciones de agrupamiento y ordenación.This can occur with grouping and ordering operations.

La palabra clave var también puede ser útil cuando resulte tedioso escribir el tipo específico de la variable en el teclado, o sea obvio o no aumente la legibilidad del código.The var keyword can also be useful when the specific type of the variable is tedious to type on the keyboard, or is obvious, or does not add to the readability of the code. Un ejemplo en el que var resulta útil de esta manera es cuando se usa con tipos genéricos anidados, como los que se emplean con las operaciones de grupo.One example where var is helpful in this manner is with nested generic types such as those used with group operations. En la siguiente consulta, el tipo de la variable de consulta es IEnumerable<IGrouping<string, Student>>.In the following query, the type of the query variable is IEnumerable<IGrouping<string, Student>>. Siempre que usted y otras personas que deban mantener el código comprendan esto, no hay ningún problema con el uso de tipos implícitos por comodidad y brevedad.As long as you and others who must maintain your code understand this, there is no problem with using implicit typing for convenience and brevity.

// Same as previous example except we use the entire last name as a key.
// Query variable is an IEnumerable<IGrouping<string, Student>>
var studentQuery3 =
    from student in students
    group student by student.Last;

Pero el uso de var supone al menos la posibilidad de que el código sea más difícil de comprender para otros programadores.However, the use of var does have at least the potential to make your code more difficult to understand for other developers. Por ese motivo, la documentación de C# por lo general solo usa var cuando es necesario.For that reason, the C# documentation generally uses var only when it is required.

Vea tambiénSee also