Perché ReSharper vuole usare 'var' per tutto?

Ho appena iniziato a utilizzare ReSharper con Visual Studio (dopo i numerosi consigli su SO). Per provarlo ho aperto un recente progetto ASP.NET MVC. Una delle prime e più frequenti cose che ho notato suggerire è invece cambiare la maggior parte delle mie dichiarazioni esplicite var. Per esempio:

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

e così via, anche con tipi semplici come int, boolecc

Perché questo è raccomandato? Non vengo da un computer o da un background .NET, essendo stato "caduto" nello sviluppo di .NET di recente, quindi mi piacerebbe davvero capire cosa sta succedendo e se è di beneficio o no.

Uno dei motivi è una migliore leggibilità. Che è migliore?

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

o

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

Ciò che ReSharper suggerisce è chiaramente un uso eccessivo della parola chiave var. Puoi usarlo dove il tipo è ovvio:

var obj = new SomeObject();

Se il tipo non è ovvio, dovresti piuttosto scriverlo:

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

Personalmente preferisco disattivare questo suggerimento. L'uso varpuò spesso migliorare la leggibilità; ma come hai detto, a volte lo riduce (con tipi semplici o quando il tipo risultante è oscuro ).

Preferisco scegliere quando uso vare quando non lo faccio. Ma di nuovo, sono solo io.

varpuò aumentare la leggibilità del codice riducendo al contempo la comprensione immediata del codice. Allo stesso modo, può ridurre la leggibilità del codice per altre situazioni. A volte il suo utilizzo è neutro. La misura della leggibilità alla comprensione non è proporzionale ma dipende dalla situazione. A volte entrambi sono aumentati o diminuiti insieme.

Il fattore è ciò a cui varviene applicato e quanto bene il target supporta l'immediata offuscamento del suo tipo di dati al lettore, o se le informazioni sul suo tipo sono necessarie per comprendere la parte del programma a portata di mano.

Ad esempio, una cattiva denominazione può portare a varuna riduzione della comprensione del codice. Questo non varè colpa però:

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

A volte non ha senso utilizzare varper tipi di dati semplici quando il codice è più leggibile in sua assenza:

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

A volte varpuò essere utile nascondere informazioni sul tipo di dati che non ti interessano necessariamente per vedere le complessità di:

    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; 

È necessario utilizzare varquando è presente un tipo anonimo perché non esiste un nome di tipo per chiamarlo come:

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

Quando si dispone di Visual Studio Intellisense che fornisce informazioni sul tipo a dispetto di var, è quindi necessario fare meno affidamento sulla comprensione tramite una lettura rigorosa del codice senza un aiuto. Probabilmente è saggio supporre che non tutti possano avere o usare Intellisense.

In sintesi, basato sugli esempi di cui sopra, suggerirei che l'applicazione della carta bianca varnon è una buona idea perché la maggior parte delle cose sono fatte con moderazione e basate sulle circostanze a portata di mano, come mostrato qui.

Perché Resharper lo usa dappertutto di default? Suggerirei per facilità, perché non può analizzare le sfumature delle situazioni per decidere quando è meglio non usarlo.

In ReSharper (8.02, ma probabilmente altre versioni), l'opzione per il suggerimento "Usa dichiarazione variabile locale tipizzata in modo implicito" può essere adattata alle tue preferenze , qualunque essa sia, aprendo prima il menu delle opzioni per ReSharper:

Quindi, in "Controllo codice" modificando la "Livello di controllo" della lingua scelta, nel mio caso c #:

Come puoi vedere, ci sono opzioni per adattare tutti i suggerimenti che ReSharper propone. Spero che questo aiuti qualcuno come me che ha già una strategia di utilizzo 'var' e vuole solo che ReSharper la rispetti :)

Sono sorpreso che nessuno abbia menzionato che è anche più facile cambiare il tipo di oggetto istanziato, perché

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

è una forma di ripetizione . Se voglio passare AVeryLongTypeNamea una delle sue classi derivate, devo solo cambiarlo una volta quando uso vare posso ancora accedere ai metodi delle classi figlio.

A parte questo, la migliore leggibilità è un punto importante, ma come altri hanno detto, var non dovrebbe essere abusato, quindi penso che disattivare il suggerimento in Resharper sia assolutamente ok.

'var' significa essere chiari

Il dibattito principale sull'uso varo meno della parola chiave riguarda la leggibilità del codice per te e gli altri sviluppatori.

Proprio come se stessi scrivendo una storia non esiste una risposta giusta definitiva. Ma diamo un'occhiata ad alcuni esempi di questo in un inglese semplice.

Jake salutò Bill. Non gli piaceva, quindi si voltò e andò dall'altra parte.

Chi è andato dall'altra parte? Jake o Bill? In questo caso usare i nomi "Jake" e "Bill" è come usare il nome del tipo. E "Lui" e "lui" è come usare la varparola chiave. In questo caso potrebbe essere utile essere più specifici. Quanto segue ad esempio è molto più chiaro.

Jake salutò Bill. A Jake non piaceva Bill, quindi si girò e andò dall'altra parte.

In questo caso, essere più specifici ha reso la frase più chiara. Ma non sarà sempre così. In alcuni casi, essere specifici rende più difficile la lettura.

A Bill piacciono i libri, quindi Bill è andato in biblioteca e Bill ha tirato fuori un libro che a Bill è sempre piaciuto.

In questo caso sarebbe più semplice leggere la frase se usassimo "lui" e in alcuni casi tralasciassimo il suo nome, il che equivale a usare la varparola chiave.

A Bill piacciono i libri, quindi è andato in biblioteca e ha tirato fuori un libro che gli è sempre piaciuto.

Questi esempi descrivono l'essenza, ma non raccontano l'intera storia. In quegli esempi c'era solo un modo per riferirsi alla persona. O usando il loro nome o usando un termine più generale come "lui" e "lui".

Nel caso del codice abbiamo 3 modi per aiutare ad aggiungere chiarezza. Il tipo, il nome della variabile e l'assegnazione. Prendi questa riga di codice per esempio:

Person p = GetPerson();

La domanda ora diventa: ci sono abbastanza informazioni in quella riga di codice per aiutarti a capire cosa sta succedendo?

E la seguente riga di codice? Sapresti ancora cosa psignifica in questo caso:

var p = GetPerson();

Che ne dici ora:

var p = Get();

O ora:

var person = Get();

O questo:

var t = GetPerson();

O questo:

var u = Person.Get();

Se la parola chiave var funzioni in un determinato scenario dipende molto dal contesto del codice, ad esempio come vengono denominate le variabili, le classi e i metodi. Dipende anche dalla complessità del codice e dal resto del codice che lo circonda.

Personalmente mi piace usare la varparola chiave per me è più completa per la maggior parte del tempo. Ma tendo anche a nominare le mie variabili in base al tipo, quindi non sto davvero perdendo alcuna informazione.

Detto questo a volte a seconda del contesto in cui faccio eccezioni, tale è la natura di qualcosa di complesso e il software non è nulla se non complesso.

Non mi è piaciuto anche questo.

Non voglio che questo si trasformi in un dibattito sull'uso di var, ha i suoi usi ma non dovrebbe essere usato ovunque.

La cosa fondamentale da ricordare è che ReSharper è configurato secondo gli standard di codifica desiderati.

Modifica: ReSharper e var

Vedo molte risposte corrette, ma manca quella completa.

È vero che ReSharper utilizza eccessivamente varper impostazione predefinita. Penso che molte persone sarebbero d'accordo. È anche più facile da leggere quando varviene utilizzato e il tipo è ovvio, ad esempio quando si utilizza newun'istruzione. Ho visto un post che mostrava come aggiornare la gravità dell'ispezione per mostrare solo suggerimenti per l'uso di var.

Avevo provato a commentare prima altri post per aggiungere dove impostarli, ma non ne avevo la reputazione. Apparentemente, non avevo nemmeno la reputazione di pubblicare il mio screenshot delle impostazioni.

Spiegherò come arrivarci.

In Visual Studio> Menu principale> Resharper> Opzioni> Modifica codice> C #> Stile codice> Uso var nelle dichiarazioni

• Per i tipi predefiniti Utilizzare il tipo esplicito
• Per tipi semplici Usa 'var' quando è evidente
• Altrove Usa'var '

Documentazione della guida di ReSharper: Stile della sintassi del codice: Digitazione implicita / esplicita (parola chiave 'var') - Configurare le preferenze di utilizzo della parola chiave 'var'

La mia regola è questa:

• Stai dichiarando un tipo primitivo (cioè byte, char, string, int[], double?, decimal, etc.)? -> Usa il tipo:

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

• Stai dichiarando un tipo complesso (cioè List<T>, Dictionary<T, T>, MyObj)? -> Usa var:

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

Vorrei solo sottolineare che l'uso di "var" è raccomandato nelle Convenzioni di codifica C #

quando il tipo di variabile è evidente dal lato destro dell'assegnazione o quando il tipo preciso non è importante

quindi è probabilmente per questo che il suggerimento è attivo di default in ReSharper. Forniscono anche alcuni casi in cui non migliorerebbe la leggibilità proprio sotto nello stesso documento.

ReSharper consiglia varperché tende a disordinare la creazione di oggetti.

Confronta questi due esempi:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

È solo una scorciatoia che dovrebbe essere più facile da leggere.

Penso che vada bene quando si creano esplicitamente nuovi oggetti con "nuovo". Nel tuo esempio, tuttavia, potrebbe non essere ovvio se le classi non sono state nominate correttamente.

A proposito, ReSharper distingue tra "potresti voler applicare questo suggerimento al tuo codice" e "il tuo codice è rotto, vuoi che lo ripari?". La varparola chiave è nella categoria dei suggerimenti, insieme a cose come "inverti se ridurre l'annidamento"; non devi seguirlo.

Puoi configurare quanto fastidioso sia ciascuno dei suoi avvisi attraverso la finestra di dialogo Opzioni o direttamente dal menu a comparsa per quell'avviso. Puoi eseguire il downgrade di elementi come il varsuggerimento in modo che siano meno importanti oppure puoi aggiornare elementi come l'avviso "usa il metodo di estensione" in modo che venga visualizzato come un errore reale.

La varfunzionalità di .Net 3.0 è solo l' inferenza del tipo , che è sicura e spesso rende il codice più facile da leggere. Ma non è necessario e, se lo desideri, puoi disattivare quella raccomandazione in riaccensione.

Il Var è fantastico! Mi sono imbattuto in molti sviluppatori che hanno l'impressione chevar essere legati a un tipo dinamico, non lo è. È ancora tipizzato staticamente, è appena deciso dal compilatore.

Ecco alcuni incredibili aspetti positivi dell'utilizzo di var

Una quantità minore di var è più breve e più facile da leggere, ad esempio

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

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

Nomi di variabili più descrittivi - tenui ma penso che sia importante lasciare varrisplendere la natura fluida di qui. Come varè un po 'vago, incoraggia davvero un nome di variabile più descrittivo piuttosto che lasciare che il tipo parli da solo.

Meno modifiche al codice : se il tipo restituito di una chiamata di metodo cambia. Devi solo cambiare il metodo di chiamata, non tutti i posti in cui viene utilizzato.

Tipi anonimi: i tipi anonimi sono un concetto davvero potente, specialmente in settori come le risorse parziali WebApi . Senza var, non possono essere utilizzati.

A volte, tuttavia, è utile dichiarare esplicitamente i tipi e lo trovo molto utile nelle primitive o nelle strutture. Ad esempio, non trovo personalmente questa sintassi molto utile:

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

}

vs

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

}

Dipende tutto dalle preferenze personali, ma l'utilizzo varaccelera davvero il tuo sviluppo e sblocca un intero mondo di bontà di tipo anonimo.

Non vi è alcuna differenza tecnica, se si utilizza var, il tipo è implicito dal compilatore. Se hai un codice come questo:

var x = 1;

x è implicito come un int e nessun altro valore può essere assegnato ad esso.

La parola chiave var è utile se si modifica il tipo di variabile; devi solo fare una modifica invece di due:

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

La varparola chiave è stata introdotta in C # 3.0: ci consente di dimenticare di specificare esplicitamente il nostro tipo.

Non c'è alcuna reale differenza se si utilizza

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

o

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

tranne pura leggibilità e meno possibilità di errore.

Sembra un esempio cliché, ma dire quanto segue può aiutarti a capire:

var myInt = 23;

restituisce un inttipo, mentre

var myInt = "23";

restituisce un stringtipo.

Riferimento MSDN

Specificare un tipo di oggetto esplicito è in qualche modo ridondante. Anche tradotto in inglese, sembra ridondante: "metti un oggetto di tipo X in una variabile di tipo X" vs "Metti un oggetto di tipo X in una variabile".

Tuttavia, l'uso di 'var' ha i suoi limiti . Previene il seguente uso del polimorfismo che è pura bellezza :

Supponiamo che un cane prolunghi l'animale; Cat estende la gerarchia delle classi animali:

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

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

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

Lo stesso codice, con x dichiarato con 'var' non verrà compilato .

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){}

Comunque, tornando alla domanda originale, non uso Resharper, ma presumo che sia abbastanza intelligente da rilevare quando non usare 'var'. :-)

A mio avviso, vardovrebbe essere usato solo quando è immediatamente chiaro quale sia il tipo quando si definisce il valore della variabile.

Esempio:

var s = "string value";

È ovvio che sè un string.

Ritengo sia appropriato anche quando il nome del tipo di variabile è molto complesso.

Esempio:

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>>>();

A parte questi scenari, non vedo alcun GAIN da fare usando var, ma posso pensare ad alcuni scenari in cui può essere dannoso:

Ad esempio, un tipo usa e getta il cui valore della variabile sul lato destro non mostra chiaramente il tipo. Lo smaltimento dell'IDisposable può essere facilmente dimenticato

Esempio:

// 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' aggiunge una sorta di elemento "dinamico" al tuo codice (sebbene il codice rimanga ovviamente rigorosamente digitato). Sconsiglio di usarlo nei casi in cui il tipo non è chiaro. Considera questo esempio:

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

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

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

Se il tipo restituito di GetTheObjectFromDatabase () viene modificato da Tipo A a B, non lo noteremo, poiché entrambe le classi implementano DoSomething (). Il codice, tuttavia, ora può effettivamente fare qualcosa di completamente diverso.

Questo può essere sottile come entrambi scrivere cose diverse in un registro, quindi potresti non notare che è troppo tardi.

Il seguente uso di var dovrebbe sempre andare bene:

var abc = new Something();

Per coloro a cui non piace l'uso costante di "var", è anche possibile impedire a ReSharper di passare a var in modo predefinito quando si fa "introduce variabile". Questo è stato qualcosa che mi ha frustrato per molto tempo, è sempre stato insoluto var, e lo cambiavo ogni volta.

Queste impostazioni si trovano in Modifica codice> C #> Stile codice

Non c'è alcuna differenza tecnica (come sottolineato da eWolf). È possibile utilizzare l'uno o l'altro, il codice CLR generato avrà lo stesso aspetto.

A mio avviso, il vantaggio principale è che ciò tende a costringerti a utilizzare una denominazione variabile migliore. Nel tuo esempio "pippo" è una scelta piuttosto scadente per un nome variabile.

Secondo JetBrains (l'autore di ReSharper), incoraggiano l'uso di var di default.

Dal loro sito Web :

L'uso di variabili locali tipizzate in modo implicito (noto anche come varparola chiave) introdotto in C # 3.0 è diventato piuttosto popolare in quanto migliora la leggibilità in molti scenari. Per impostazione predefinita, ReSharper incoraggia anche l'uso della varparola chiave, ma le preferenze del suo utilizzo sono configurabili in modo flessibile - ad esempio, puoi scegliere di utilizzare tipi espliciti in casi specifici o ovunque e ReSharper ti aiuterà a far rispettare le tue preferenze.