Definindo explicitamente os tipos de dados variáveis ​​vs. usando a palavra-chave 'var'? [fechadas]

Em C #, sou incentivado a usar a palavra-chave var para todos os fins para todas as declarações de variáveis? Se sim, devo mencionar esses caracteres especiais para valores literais na declaração da variável, como M para decimal, na seguinte instrução:

var myDecimal = 14.5M;

Se isso faz diferença, estou tentando fazer algum desenvolvimento web com C #.

Tem havido muita disputa sobre o uso de var. Minhas regras gerais são as seguintes.

• Quando o tipo é óbvio, como quando a mão direita da atribuição é um construtor, use var.
• Quando o tipo é complexo para escrever, como uma consulta LINQ (o motivo da var em primeiro lugar), use var.
• Para tipos ambivalentes (seu decimal é um exemplo) em que você deseja garantir que sua variável seja digitada corretamente, soletre-a.
• Tipos anônimos precisam usar var.
• Nos demais casos, especifique o tipo.

Basicamente, o objetivo é facilitar a leitura do código. Se você acha que var é suficiente porque a atribuição é óbvia, use var. Use o nome completo do tipo como uma dica para o leitor quando achar necessário.

Quando usar varé uma programação "guerra santa". Há precisamente um lugar onde é necessário: quando o resultado de uma operação cria um tipo anônimo, como:

var result = new { Name = "John", Age = 35 };

Em qualquer outro lugar, é opcional e realmente depende do seu padrão de codificação usá-lo ou não em outras situações.

E sim, você precisará de caracteres especiais para literais para permitir que o compilador saiba o que é no lado direito. No seu exemplo, sem o M, o padrão é em doublevez de decimal.

Do MSDN :

No entanto, o uso de var tem pelo menos o potencial de tornar seu código mais difícil de entender para outros desenvolvedores. Por esse motivo, a documentação do C # geralmente usa var apenas quando necessário.

Eu realmente não gosto de digitar implícita. Na superfície, ele tende a tornar o código mais legível, mas pode levar a muitos problemas no caminho. Se um dev alterar um inicializador de variável, digamos, de

var myFloat=100f;

para

var myFloat=100;

ou

var myFloat=100.0;

O tipo será alterado, resultando em uma série de erros do compilador ou, se estiver em uma exibição da Web e você não estiver usando a etapa pós-compilação para pré-compilar suas exibições, uma série de erros de tempo de execução que não serão capturados sem eficácia teste de pré-implantação.

A digitação implícita também não funciona em qualquer lugar (do mesmo link do MSDN)

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 nula 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.

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

Várias variáveis ​​do tipo implicitamente não podem ser inicializadas na mesma instrução.

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

Manter seu código consistente (nesse caso, usar digitação explícita em qualquer lugar) é uma coisa muito, muito boa. Na minha opinião, varé preguiçoso e não oferece nenhum benefício real, além de apresentar outro ponto potencial de falha em um processo já complexo.

Atualização de 2017

Eu mudei completamente de idéia. Ao trabalhar em C #, uso a varmaior parte do tempo (exceto coisas como variáveis ​​do tipo interface). Ele mantém o código conciso, o que melhora a legibilidade. Ainda assim - preste atenção no que realmente é o tipo resolvido.

A Referência de C # mostra o seguinte para ilustrar o uso bom ou ruim desse construto:

O exemplo a seguir mostra duas expressões de consulta. Na primeira expressão, o uso de var é permitido, mas não é necessário, porque o tipo do resultado da consulta pode ser declarado explicitamente como um IEnumerable. No entanto, na segunda expressão, var deve ser usado porque o resultado é uma coleção de tipos anônimos e o nome desse tipo não está acessível, exceto no próprio compilador. Observe que no Exemplo 2, o item da variável de iteração foreach também deve ser digitado implicitamente.

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

A palavra-chave var solicita apenas que o compilador deduza o tipo da variável de tipo var automaticamente. Portanto, se você deseja armazenar uma variável do tipo decimal em uma variável var, é necessário usar m. Da mesma forma, se você estiver armazenando uma string, precisará colocá-la entre aspas.

Para mim, não uso var nos seguintes casos:

• Quando eu quero ter certeza do tipo da minha variável (por exemplo, para ter certeza de que o tipo usado é duplo e não decimal, e isso é muito importante, confie em mim!)
• Código polimórfico como Fruit foo = new Apple();. Nesse caso, acho que var é evitar e usar a classe pai (aqui Fruit) é melhor, permitindo uma melhor compreensão da lógica do código e limitação dos prováveis ​​erros (com var, nenhuma verificação do conceito polimórfico!)

Quanto ao resto, acho que depende do caso e do histórico do desenvolvedor. Algumas pessoas do mundo PHP preferem não cuidar dos tipos de variáveis, e algumas pessoas do mundo Java apenas pensam que var é uma heresia e quanto mais detalhado, melhor.

Você terá que fazer sua opinião pessoal :)