Por que o ReSharper deseja usar 'var' para tudo?

Acabei de começar a usar o ReSharper com o Visual Studio (depois das muitas recomendações sobre SO). Para testar, abri um projeto recente do ASP.NET MVC. Uma das primeiras e mais frequentes coisas que notei sugerir é mudar a maioria / todas as minhas declarações explícitas para var. Por exemplo:

//From This:
MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);
//To This:
var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

e assim por diante, mesmo com tipos simples, como int, bool, etc.

Por que isso está sendo recomendado? Eu não sou formado em ciência da computação ou .NET, tendo "caído" no desenvolvimento .NET recentemente, então eu realmente gostaria de entender o que está acontecendo e se é ou não benéfico.

Um dos motivos é a legibilidade aprimorada. Qual é melhor?

Dictionary<int, MyLongNamedObject> dictionary = new Dictionary<int, MyLongNamedObject>();

ou

var dictionary = new Dictionary<int, MyLongNamedObject>();

O que o ReSharper sugere é claramente o uso excessivo da palavra-chave var. Você pode usá-lo onde o tipo é óbvio:

var obj = new SomeObject();

Se o tipo não for óbvio, você deve escrever:

SomeObject obj = DB.SomeClass.GetObject(42);

Pessoalmente, prefiro desativar essa sugestão. O uso vargeralmente pode melhorar a legibilidade; mas, como você mencionou, algumas vezes o reduz (com tipos simples ou quando o tipo resultante é obscuro ).

Prefiro escolher quando uso vare quando não uso. Mas, novamente, sou apenas eu.

varpode aumentar a legibilidade do código enquanto diminui a compreensão imediata do código. Da mesma forma, pode diminuir a legibilidade do código para outras situações. Às vezes, o uso é neutro. A medida da legibilidade para a compreensão não é proporcional, mas depende da situação. Às vezes, ambos aumentam ou diminuem juntos.

O fator é o que varestá sendo aplicado e quão bem o destino suporta a ofuscação imediata de seu tipo de dados para o leitor, ou se suas informações de tipo são necessárias para compreender a parte do programa em questão.

Por exemplo, a nomeação incorreta pode levar à vardiminuição da compreensão do código. varPorém, isso não é culpa de:

var value1 = GetNotObviousValue(); //What's the data type? 
//vs. 
var value2 = Math.Abs(-3); // Obviously a numeric data type. 

Às vezes, não faz sentido usar vartipos de dados simples quando o código é mais legível na sua ausência:

var num = GetNumber(); // But what type of number?
// vs. 
double num = GetNumber(); // I see, it's a double type. 

Às vezes, varpode ser útil ocultar informações de tipo de dados das quais você não se importa necessariamente em ver as complexidades de:

    IEnumerable<KeyValuePair<string,List<Dictionary<int,bool>>>> q = from t in d where t.Key == null select t; // OMG! 
    //vs. 
    var q = from t in d where t.Key == null select t;

    // I simply want the first string, so the last version seems fine.  
    q.First().Key; 

Você deve usar varquando houver um tipo anônimo presente, porque não há um nome de tipo para chamá-lo:

var o = new { Num=3, Name="" };

Apesar de o Visual Studio Intellisense fornecer informações de tipo var, você precisa confiar menos no seu entendimento por meio da leitura estrita de código sem ajuda. Provavelmente, é aconselhável supor que nem todos podem ter ou usar o Intellisense.

Em resumo, com base nos exemplos acima, sugiro que a aplicação de carta branca varnão seja uma boa idéia, porque a maioria das coisas é melhor feita com moderação e com base nas circunstâncias em questão, como mostrado aqui.

Por que o Resharper usa tudo por padrão? Eu sugeriria com facilidade, porque não é possível analisar as nuances das situações para decidir quando é melhor não usá-las.

No ReSharper (8.02, mas provavelmente em outras versões), a opção da sugestão "Usar declaração de variável local digitada implicitamente" pode ser ajustada conforme sua preferência , seja o que for, abrindo primeiro o menu de opções do ReSharper:

Então, em "Inspeção de código", ajustando a "Severidade da inspeção" do idioma escolhido, no meu caso c #:

Como você pode ver, existem opções para ajustar todas as sugestões que o ReSharper faz. Espero que isso ajude alguém como eu, que já tem uma estratégia de uso 'var' e só quer que o ReSharper a respeite :)

Surpreende-me que ninguém tenha mencionado que também é mais fácil alterar o tipo do objeto instanciado, porque

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

é uma forma de repetição . Se eu quiser mudar AVeryLongTypeNamepara uma de suas classes derivadas, preciso mudar isso apenas uma vez ao usar vare ainda pode acessar os métodos das classes filho.

Além disso, a legibilidade aprimorada é um ponto importante, mas como outros disseram, o var não deve ser usado em excesso, por isso acho que desligar a dica no Resharper é absolutamente aceitável.

'var' é sobre ser claro

O principal debate sobre o uso varou não da palavra - chave é sobre a legibilidade do código para você e outros desenvolvedores.

Como se você estivesse escrevendo uma história, não há resposta certa definitiva. Mas vamos ver alguns exemplos disso em inglês simples.

Jake disse olá para Bill. Ele não gostou dele, então ele se virou e foi para o outro lado.

Quem foi para o outro lado? Jake ou Bill? Nesse caso, usar os nomes "Jake" e "Bill" é como usar o nome do tipo. E "Ele" e "ele" é como usar a varpalavra - chave. Nesse caso, pode ser mais específico. O exemplo a seguir é muito mais claro.

Jake disse olá para Bill. Jake não gostava de Bill, então ele se virou e foi para o outro lado.

Nesse caso, ser mais específico tornou a frase mais clara. Mas isso nem sempre será o caso. Em alguns casos, ser específico torna mais difícil a leitura.

Bill gosta de livros, então Bill foi à biblioteca e Bill pegou um livro que Bill sempre gostou.

Nesse caso, seria mais fácil ler a frase se usássemos "he" e, em alguns casos, deixássemos seu nome todo junto, o que equivale a usar a varpalavra - chave.

Bill gosta de livros, então ele foi à biblioteca e pegou um livro que ele sempre gostou.

Esses exemplos cobrem a essência, mas não contam a história toda. Nesses exemplos, havia apenas uma maneira de se referir à pessoa. Ou usando seu nome ou usando um termo mais geral como "ele" e "ele".

No caso do código, temos três maneiras de ajudar a adicionar clareza. O tipo, o nome da variável e a atribuição. Pegue esta linha de código, por exemplo:

Person p = GetPerson();

A questão agora é: existem informações suficientes nessa linha de código para ajudá-lo a descobrir o que está acontecendo?

E a seguinte linha de código? Você ainda saberia o que psignifica neste caso:

var p = GetPerson();

Que tal agora:

var p = Get();

Ou agora:

var person = Get();

Ou este:

var t = GetPerson();

Ou isto:

var u = Person.Get();

Se a palavra-chave varfunciona em um determinado cenário depende muito do contexto do código, como o nome das variáveis, classes e métodos. Também depende da complexidade do código e do restante do código ao seu redor.

Pessoalmente, gosto de usar a varpalavra-chave que é mais abrangente para mim na maioria das vezes. Mas também tendem a nomear minhas variáveis ​​após o tipo, para não perder realmente nenhuma informação.

Dito isto, às vezes, dependendo do contexto em que faço exceções, essa é a natureza de qualquer coisa complexa e o software não é nada senão complexo.

Eu não gostei disso também.

Eu não quero que isso se transforme em um debate sobre o uso de var, tem seus usos, mas não deve ser usado em qualquer lugar.

O importante a lembrar é que o ReSharper está configurado para os padrões de codificação que você deseja.

Edit: ReSharper e var

Eu vejo muitas respostas corretas, mas faltando a completa.

É verdade que o ReSharper faz uso excessivo varpor padrão. Eu acho que a maioria das pessoas concorda com isso. Também é mais fácil ler quando varé usado e o tipo é óbvio, como quando você usa uma newinstrução. Vi um post que mostrava como atualizar a gravidade da inspeção para mostrar apenas dicas para o uso de var.

Eu tentei comentar em outras postagens primeiro para adicionar onde colocá-las, mas não tinha reputação. Aparentemente, eu também não tinha reputação de postar minha captura de tela das configurações.

Vou explicar como chegar lá.

No Visual Studio> Menu Principal> Recarregador> Opções> Edição de Código> C #> Estilo de Código> Uso de Var nas declarações

• Para tipos internos Use tipo explícito
• Para tipos simples Use 'var' quando evidente
• Em outros lugares Use'var '

Documentação de ajuda do ReSharper: Estilo da sintaxe do código: digitação implícita / explícita (palavra-chave 'var') - Configure as preferências do uso da palavra-chave 'var'

Minha regra é esta:

• Você está declarando um tipo primitivo (ie byte, char, string, int[], double?, decimal, etc.)? -> Use o tipo:

  string myStr = "foo";
  int[] myIntArray = [123, 456, 789];
  double? myDouble = 123.3;

• Você está declarando um tipo complexo (ou seja List<T>, Dictionary<T, T>, MyObj)? -> Uso var:

  var myList = List<string>();
  var myDictionary = Dictionary<string, string>();
  var myObjInstance = new MyObj();

Gostaria apenas de salientar que o uso de "var" é recomendado nas Convenções de codificação C #

quando o tipo da variável é óbvio do lado direito da atribuição ou quando o tipo preciso não é importante

provavelmente é por isso que a dica está ativada por padrão no ReSharper. Eles também fornecem alguns casos em que isso não melhoraria a legibilidade logo abaixo no mesmo documento.

O ReSharper recomenda varporque tende a desorganizar a criação do objeto.

Compare estes dois exemplos:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

É apenas uma abreviação que deveria ser mais fácil de ler.

Eu acho que é bom quando você cria novos objetos explicitamente com "new". No seu exemplo, no entanto, pode não ser óbvio se as classes não foram nomeadas corretamente.

BTW, o ReSharper faz uma distinção entre 'você pode aplicar esta sugestão ao seu código' e 'seu código está quebrado, quer que eu conserte?'. A varpalavra-chave está na categoria de sugestão, junto com itens como "inverter se reduzir o aninhamento"; você não precisa segui-lo.

Você pode configurar o quão irritante cada um de seus alertas é através da caixa de diálogo Opções ou diretamente através do menu pop-up desse alerta. Você pode fazer o downgrade de coisas como a varsugestão, para que sejam menos proeminentes, ou atualizar o alerta 'usar método de extensão' para que apareça como um erro real.

O varrecurso do .Net 3.0 é apenas uma inferência de tipo , que é do tipo seguro e geralmente facilita a leitura do seu código. Mas você não precisa fazê-lo e pode desativar essa recomendação novamente, se desejar.

Var é incrível! Já deparei com muitos desenvolvedores que têm a impressão de que varestão vinculados a um tipo dinâmico, não estão. Ele ainda é digitado estaticamente, é apenas decidido pelo compilador.

Aqui estão alguns pontos positivos surpreendentes do uso de var

Menos var de digitação é mais curto e fácil de ler, por exemplo,

Dictionary<int,IList<string>> postcodes = new Dictionary<int,IList<string>>()Yuk.

var postcodes = new Dictionary<int,IList<string>>()\ o / \ o /

Nomes de variáveis ​​mais descritivos - um tênue, mas acho importante deixar aqui a natureza fluida do varbrilho. Como varé um pouco vago, ele realmente incentiva um nome de variável mais descritivo, em vez de deixar o tipo falar por si.

Menos alterações de código - se o tipo de retorno de uma chamada de método for alterado. Você só precisa alterar a chamada do método, nem todos os lugares em que é usada.

Tipos anônimos - tipos anônimos são um conceito realmente poderoso, especialmente em áreas como recursos parciais da WebApi . Sem var, eles não podem ser usados.

Às vezes, porém, é útil declarar explicitamente tipos e acho isso mais útil em primitivas ou estruturas. Por exemplo, eu pessoalmente não acho essa sintaxe muito útil:

for(var i = 0; i < 10; i++) 
{

}

vs

for(int i = 0; i < 10; i++) 
{

}

Tudo vardepende da preferência pessoal, mas o uso realmente acelerará o seu desenvolvimento e desbloqueará um mundo inteiro de bens do tipo anônimo.

Não há diferença técnica, se você usar var, o tipo é implícito pelo compilador. Se você tem um código como este:

var x = 1;

x está implícito como int e nenhum outro valor pode ser atribuído a ele.

A palavra-chave var é útil se você alterar o tipo da variável; você só precisa fazer uma alteração em vez de duas:

var x = 1; --> var x = "hello";
int x = 1; --> string x = "hello";

A varpalavra-chave foi introduzida no C # 3.0 - permite esquecer a especificação explícita do nosso tipo.

Não há diferença real se você usa

MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

ou

var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

exceto pura legibilidade e menos chance de erro.

Parece um exemplo clichê, mas digamos que o seguinte possa ajudar sua compreensão:

var myInt = 23;

retorna um inttipo, enquanto

var myInt = "23";

retorna um stringtipo.

Referência MSDN

A especificação de um tipo de objeto explícito é de alguma forma redundante. Mesmo traduzido em inglês, parece redundante: "coloque um objeto do tipo X em uma variável do tipo X" vs "Coloque um objeto do tipo X em uma variável".

No entanto, o uso de 'var' tem suas limitações . Impede o uso abaixo do polimorfismo, que é pura beleza :

Suponha que um cão estenda Animal; Cat estende a hierarquia de classes Animal:

Animal x = new Dog();
DoStuffWithDog(x as Dog);

x = new Cat();
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

O mesmo código, com x declarado com 'var' , não será compilado .

var x = new Dog(); // from this point, x is a Dog
DoStuffWithDog(x as Dog);

x = new Cat(); // cannot assign a Cat instance to a Dog
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

De qualquer forma, voltando à pergunta original, eu não uso o Resharper, mas presumo que seja inteligente o suficiente para detectar quando não usar 'var'. :-)

Na minha opinião, varsó deve ser usado quando for imediatamente claro qual é o tipo ao definir o valor da variável.

Exemplo:

var s = "string value";

É óbvio que sé um string.

Eu acredito que também é apropriado quando o nome do tipo de variável é muito complexo.

Exemplo:

Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>> dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

// This is a little easier to read than the above statement
var dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

Além desses cenários, não vejo nenhum GANHO a ser feito usando var, mas consigo pensar em alguns cenários nos quais isso pode ser prejudicial:

Por exemplo, um tipo descartável cujo valor da variável do lado direito não mostra claramente o tipo. A eliminação do IDisposable pode ser facilmente esquecida

Exemplo:

// returns some file writer
var wr = GetWriter();

wr.add("stuff");
wr.add("more stuff");

//...
//...

// Now `wr` needs to be disposed, 
// but there is no clear indication of the type of `wr`,
// so it will be easily overlooked by code writer and code reviewer.

'var' adiciona um tipo de elemento "dinâmico" ao seu código (embora o código permaneça, é claro, estritamente digitado). Eu aconselho a não usá-lo nos casos em que o tipo não é claro. Considere este exemplo:

var bar = GetTheObjectFromDatabase();
bar.DoSomething();

ClassA {
  void DoSomething() {
  //does something
  }
}

ClassB {
  void DoSomething() {
  //does something entirely different
  }
}

Caso o tipo de retorno GetTheObjectFromDatabase () seja alterado do tipo A para B, não perceberemos, pois ambas as classes implementam DoSomething (). O código, no entanto, agora pode realmente fazer algo completamente diferente.

Isso pode ser tão sutil quanto escrever coisas diferentes em um log, portanto você pode não perceber que é tarde demais.

O seguinte uso de var deve sempre ser bom:

var abc = new Something();

Para aqueles que não gostam do uso constante de "var", também é possível parar o ReSharper de usar o padrão para var ao fazer "introduzir variável". Isso foi algo que me frustrou por um longo tempo, sempre foi padrão para var, e eu estava mudando o tempo todo.

Essas configurações estão em Edição de código> C #> Estilo de código

Não há diferença técnica (como o eWolf apontou). Você pode usar um ou outro, o código CLR gerado terá a mesma aparência.

Na minha opinião, o principal benefício é que isso tende a forçá-lo a usar uma melhor nomeação de variáveis. No seu exemplo, 'foo' é uma péssima escolha para um nome de variável.

De acordo com JetBrains (o autor do ReSharper), eles incentivam o uso de var por padrão.

No site deles :

O uso de variáveis ​​locais de tipo implícito (também conhecidas como varpalavra-chave) introduzidas no C # 3.0 tornou-se bastante popular, pois melhora a legibilidade em muitos cenários. Por padrão, o ReSharper também incentiva o uso de varpalavras-chave, mas as preferências de seu uso são configuráveis ​​de forma flexível - por exemplo, você pode optar por usar tipos explícitos em casos específicos ou em qualquer lugar, e o ReSharper ajudará a reforçar suas preferências.