O que usar: var ou objeto tipo de nome? [duplicado]

StackOverflow https://stackoverflow.com/questions/236878

Pergunta

Esta questão já tem uma resposta aqui:

Esta é uma pergunta que ao programar Eu sempre me pergunto: O que usar quando estamos escrevendo código: 

var myFiles = Directory.GetFiles(fullPath);

ou 

string[] myFiles = Directory.GetFiles(fullPath);

var é novo e é uma Variáveis ??Implicitamente digitado locais , por isso só podemos usar localmente e tem regras como não pode ser null, etc., mas me pergunto se nós temos toda a vantagem de utilizá-lo "normalmente".

O "normalmente" parte diz, não em Anonymous Tipos , Objeto e inicializadores de coleção e Expressões de consulta em que essa era a intenção de uso o objeto anônimo var, então o que eu quero dizer é ... apenas como o exemplo acima.

quais são seus pensamentos?

Foi útil?

Solução

Além da óbvia utilização de var com LINQ, eu também usá-lo para abreviar declarações de variáveis ??peludas para facilitar a leitura, por exemplo:. 

var d = new Dictionary<string, Dictionary<string, Queue<SomeClass>>>();

Em geral, eu recebo um tipo de conforto (por falta de uma palavra melhor) de tipagem estática que me faz relutantes em desistir. Gosto da sensação que eu sei o que estou fazendo quando eu estou declarando uma variável. Declarando uma variável não é apenas dizer o compilador algo, ele está dizendo a pessoa que lê o seu código de alguma coisa.

Deixe-me dar um exemplo. Suponha que eu tenho um método que retorna um List<string>. Este código é certamente correta, e eu acho que é como 90% dos desenvolvedores de C # provavelmente escrevê-lo: 

List<string> list = MyMethod();

Obviamente, certo? Na verdade, aqui é um lugar que você poderia facilmente usar var.

É verdade. Mas este versão do código não é apenas declarar uma variável, ele está me dizendo o que a pessoa que o escreveu está pretendendo fazer: 

IEnumerable<string> list = MyMethod();

O desenvolvedor que escreveu que o código está me dizendo "Eu não vou estar a mudar nesta lista, nem vou usar um índice para acessar seus membros. Tudo o que eu vou fazer é iterar através dele." Isso é um monte de informações para atravessar em uma única linha de código. É algo que você desista se você usar var.

É claro, você não está dando-lo se você não estava usando-lo em primeiro lugar. Se você é o tipo de desenvolvedor que iria escrever essa linha de código, você já sabe que você não usaria var lá.

Editar:

Eu só reler o post de Jon Skeet, e esta citação de Eric Lippert saltou fora de mim:

locals Implicitamente digitadas são apenas uma pequena maneira em que você pode deemphasize o como e, assim, enfatizar o quê.

Eu acho que, na verdade, em muitos casos usando digitação implícita está deixando o que implícito. É apenas OK para me debruçar sobre o quê. Por exemplo, eu vou casualmente escrever uma consulta LINQ como: 

var rows = from DataRow r in parentRow.GetChildRows(myRelation)
           where r.Field<bool>("Flag")
           orderby r.Field<int>("SortKey")
           select r;

Quando li esse código, uma das coisas que eu penso quando estou lendo é "rows é um IEnumerable<DataRow>." Porque eu sei que o que LINQ consulta de retorno é IEnumerable<T>, e eu posso ver o tipo de objeto que está sendo selecionado ali mesmo.

Isso é um caso em que o que não se explícita. Ele foi deixado para mim inferir.

Agora, em cerca de 90% dos casos em que eu uso LINQ, este não importa um pouquinho pouco. Porque 90% do tempo, a próxima linha de código é: 

foreach (DataRow r in rows)

Mas não é difícil de código enVision em que seria muito útil para rows declarar como IEnumerable<DataRow> - código onde um monte de diferentes tipos de objetos foram sendo consultado, não foi possível colocar a declaração consulta junto à iteração , e seria útil poder inspecionar rows com IntelliSense. E isso é uma coisa que, não um como coisa.

Outras dicas

Você vai ter uma enorme variedade de opiniões sobre este - a partir de "uso var em todos os lugares" para "única var uso com tipos anônimos, onde você basicamente tem que." I como take Eric Lippert nele :

Todo o código é uma abstração. É o que o código é “realmente” fazendo é manipulação de dados? No. números? Bits? Não. As tensões? Não. Os elétrons? Sim mas a compreensão do código no nível de elétrons é uma má idéia! A arte de codificação é descobrir o que a direita nível de abstração é para o público.

Em uma linguagem de alto nível, há sempre esta tensão entre o QUE código faz (semanticamente) e como o código realiza-lo. Manutenção programadores precisam entender tanto o que e o como se eles estão indo para ser bem sucedido em fazer mudanças.

O ponto inteiro de LINQ é que ele maciçamente de-enfatiza o "como" e maciçamente enfatiza o "o quê". De usando uma compreensão consulta, o programador está dizendo para o futuro audiência "Eu acredito que você deve não conhecem nem se importa exatamente como isso conjunto de resultados está sendo calculado, mas você deve se preocupar muito sobre o que a semântica do conjunto resultante é." Eles fazem o código mais perto do processo de negócio que está sendo implementado e mais longe a partir dos bits e electrões que torná-lo ir.

locals Implicitamente digitadas são apenas um pequena maneira em que você pode deemphasize como e, assim, enfatizar a o que. Se isso é a coisa certa para fazer em um caso particular, é um chamada de julgamento. Então eu digo às pessoas que se o conhecimento do tipo é relevante e sua escolha é crucial para o continuação do funcionamento do método, então não use digitação implícita. digitação explícita diz: "Eu estou dizendo a você como isso funciona por uma razão, pay atenção "digitação implícita diz que" Não importa um pouco se este coisa é uma lista ou um Cliente [], o que importa é que ele é uma coleção de clientes. "

Pessoalmente eu não tendem para usá-lo se o tipo não é razoavelmente óbvio - onde eu incluem consultas LINQ como sendo "razoavelmente óbvio". Eu não faria isso por Directory.GetFiles por exemplo, como não é realmente óbvio que que retorna um string[] em vez de (digamos) um FileInfo[] (ou algo completamente diferente) - e que faz uma grande diferença para o que você faz depois

Se houver uma chamada do construtor no lado direito do operador de atribuição, eu sou muito mais propensos a ir com var: é por demais evidente que o tipo será. Isto é particularmente útil com tipos genéricos complexos, por exemplo, Dictionary<string,List<int>>.

Pessoalmente eu só uso var em dois locais:

  1. Com tipos anônimos, ie. relacionados com o LINQ (onde var é necessária em alguns casos)
  2. Quando a instrução declara e constrói um tipo específico ao mesmo tipo

ie. este é um exemplo do ponto 2: 

var names = new List<String>();

Editado :. Isto em resposta à pergunta de Jon Skeet

A resposta acima foi na verdade simplificada. Basicamente, eu uso var , onde o tipo é:

  1. desnecessário conhecer (não que muitos lugares embora)
  2. Impossível saber (LINQ, tipos anônimos)
  3. Caso contrário conhecido, ou claro a partir do código

No caso de um método de fábrica, onde tudo que você precisa saber no lugar onde você escreve o código é que o objeto que você voltar é um descendente de algum tipo, e que algum tipo tem um método de fábrica estático, então gostaria de usar var . Como esta: 

var connection = DatabaseConnection.CreateFromConnectionString("...");

O exemplo acima é um exemplo real do meu código. É claro, pelo menos para mim e para as pessoas que usam esse código, que conexão é um descendente conexão de banco de dados, mas o tipo exato não é necessário para não entender o código, nem usá-lo.

Eu tentei o "uso var em todos os lugares" estilo ... e aqui é por isso que eu não continuar a usá-lo.

  1. legibilidade Degradadas às vezes
  2. Limites Intellisense depois =
  3. Typing "var" realmente não era muito menor do que escrever "int", "string", etc., especialmente com intellisense.

Com que disse, eu ainda usá-lo com LINQ.

Vindo da terra de programação funcional, onde tipo de inferência governa o dia, eu uso var para todos os moradores, sempre que possível.

No Visual Studio, se você está sempre querendo saber o que o tipo de qualquer local é, tudo que você tem a fazer é passar o mouse sobre ele com o mouse.

Este pós ter algumas boas guidlines sobre quando usar tipos de interface ou tipo de objeto var.

I tendem a usar var em todos os lugares, mas meus colegas de trabalho disse parada, é menos legível para nós. Então eu agora eu uso var apenas em tipos, consultas LINQ anônimos e onde é construtor no lado direito.

Eu acho que é interessante notar como isso geralmente é tratada em Haskell. Graças à isomorfismo Curry-Howard , do tipo (mais geral) de qualquer expressão em Haskell pode ser inferida, e, portanto, declarações de tipo essencialmente não são necessários em qualquer lugar, com algumas exceções; por exemplo, às vezes você deliberadamente querer limitar o tipo de algo mais específico do que seria inferida.

É claro que o que é necessário eo que é recomendado não são a mesma coisa; na prática, a convenção parece ser que as definições de nível superior sempre têm declarações de tipo, enquanto as definições localizadas ter as declarações de tipo deixados de fora. Isto parece um bom equilíbrio entre a explicitação-for-a legibilidade da definição como um todo, em contraste com brevidade-for-legibilidade do "ajudante" local ou definições "temporários". Se bem entendi, você não pode usar var para definições de "alto nível" (como um método ou função global), em primeiro lugar, então eu acho que isso se traduz em "uso var em todos os lugares que puder" em C # mundo. É claro que, ao digitar "int" é o mesmo número de teclas como "var", mas a maioria dos exemplos será mais longo do que isso.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top