Variáveis locais digitadas implicitamente (Guia de Programação em C#)

  • Artigo

As variáveis locais podem ser declaradas sem fornecer um tipo explícito. A var palavra-chave instrui o compilador a inferir o tipo da variável a partir da expressão no lado direito da instrução de inicialização. O tipo inferido pode ser um tipo interno, um tipo anônimo, um tipo definido pelo usuário ou um tipo definido na biblioteca de classes .NET. Para obter mais informações sobre como inicializar matrizes com varo , consulte Matrizes digitadas implicitamente.

Os exemplos a seguir mostram várias maneiras pelas quais as variáveis locais podem ser declaradas com 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>();

É importante entender que a var palavra-chave não significa "variante" e não indica que a variável é vagamente digitada, ou tardia. Isso significa apenas que o compilador determina e atribui o tipo mais apropriado.

A var palavra-chave pode ser utilizada nos seguintes contextos:

Para obter mais informações, consulte Como usar matrizes e variáveis locais digitadas implicitamente em uma expressão de consulta.

var e tipos anónimos

Em muitos casos, o uso de var é opcional e é apenas uma conveniência sintática. No entanto, quando uma variável é inicializada com um tipo anônimo, você deve declarar a variável como var se precisasse acessar as propriedades do objeto em um ponto posterior. Este é um cenário comum em expressões de consulta LINQ. Para obter mais informações, consulte Tipos anônimos.

Do ponto de vista do seu código-fonte, um tipo anônimo não tem nome. Portanto, se uma variável de consulta tiver sido inicializada com var, a única maneira de acessar as propriedades na sequência retornada de objetos é usar var como o tipo da variável de iteração na foreach instrução.

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
 */

Observações

As seguintes restrições aplicam-se a declarações de variáveis digitadas implicitamente:

  • var só pode ser usado quando uma variável local é declarada e inicializada na mesma instrução; A variável não pode ser inicializada como null, ou para um grupo de métodos ou uma função anônima.

  • var não pode ser usado em campos no escopo da classe.

  • As variáveis declaradas usando var não podem ser usadas na expressão de inicialização. Em outras palavras, esta expressão é legal: int i = (i = 20); mas esta expressão produz um erro em tempo de compilação: var i = (i = 20);

  • Várias variáveis digitadas implicitamente não podem ser inicializadas na mesma instrução.

  • Se um tipo nomeado var estiver no escopo, a var palavra-chave será resolvida para esse nome de tipo e não será tratada como parte de uma declaração de variável local digitada implicitamente.

A digitação implícita com a palavra-chave só pode ser aplicada a variáveis no escopo do var método local. A digitação implícita não está disponível para campos de classe, pois o compilador C# encontraria um paradoxo lógico ao processar o código: o compilador precisa saber o tipo do campo, mas não pode determinar o tipo até que a expressão de atribuição seja analisada, e a expressão não pode ser avaliada sem conhecer o tipo. Considere o seguinte código:

private var bookTitles;

bookTitles é um campo de classe dado o tipo var. Como o campo não tem expressão para avaliar, é impossível para o compilador inferir que tipo bookTitles deve ser. Além disso, adicionar uma expressão ao campo (como faria para uma variável local) também é insuficiente:

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

Quando o compilador encontra campos durante a compilação de código, ele registra o tipo de cada campo antes de processar quaisquer expressões associadas a ele. O compilador encontra o mesmo paradoxo tentando analisar bookTitles: ele precisa saber o tipo do campo, mas o compilador normalmente determinaria varo tipo de 's analisando a expressão, o que não é possível sem conhecer o tipo de antemão.

Você pode achar que var isso também pode ser útil com expressões de consulta nas quais o tipo exato construído da variável de consulta é difícil de determinar. Isso pode ocorrer com operações de agrupamento e ordenação.

A var palavra-chave também pode ser útil quando o tipo específico da variável é tedioso de digitar no teclado, ou é óbvio, ou não aumenta a legibilidade do código. Um exemplo em que var é útil dessa maneira é com tipos genéricos aninhados, como aqueles usados com operações de grupo. Na consulta a seguir, o tipo da variável de consulta é IEnumerable<IGrouping<string, Student>>. Contanto que você e outras pessoas que devem manter seu código entendam isso, não há problema em usar a digitação implícita por conveniência e brevidade.

// 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;

O uso de var ajuda a simplificar seu código, mas seu uso deve ser restrito aos casos em que é necessário, ou quando torna seu código mais fácil de ler. Para obter mais informações sobre quando usar var corretamente, consulte a seção Variáveis locais digitadas implicitamente no artigo Diretrizes de codificação em C#.

Consulte também