Perché ReSharper desidera utilizzare “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 MVC ASP.NET. Una delle prime e più frequenti cose che ho notato suggerisce è di cambiare la maggior parte / tutte le mie dichiarazioni esplicite in 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 , bool , ecc.

Perché viene raccomandato? Non vengo da un computer o da un background .NET, avendo recentemente avuto uno sviluppo .NET, quindi mi piacerebbe davvero capire cosa sta succedendo e se è di beneficio o meno.

Una ragione è migliorata la leggibilità. Che è migliore?

 Dictionary dictionary = new Dictionary(); 

o

 var dictionary = new Dictionary(); 

Quello 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 scriverlo:

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

Personalmente preferisco distriggersre questo suggerimento. L’utilizzo di var può 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 var e quando no. Ma di nuovo, sono solo io.

var può aumentare la leggibilità del codice riducendo al contempo la comprensione immediata del codice. Allo stesso modo, può diminuire la leggibilità del codice per altre situazioni. A volte l’uso di esso è neutro. La misura della leggibilità alla comprensione non è proporzionale ma dipende dalla situazione. A volte entrambi sono aumentati o diminuiti insieme.

Il fattore è ciò che viene applicato alla variabile e quanto bene l’objective supporta l’offuscamento immediato del suo tipo di dati al lettore, o se il suo tipo di informazioni è necessario per comprendere la parte del programma in questione.

Ad esempio, una ctriggers denominazione può portare a var causando una diminuzione della comprensione del codice. Questa non è la colpa di var 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 usare var per semplici tipi di dati 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 var può essere utile per hide le informazioni sul tipo di dati a cui non tieni necessariamente a vedere le complessità di:

  IEnumerable>>> 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 var quando è presente un tipo anonimo perché non esiste un nome di tipo per chiamarlo da:

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

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

In sintesi sulla base degli esempi di cui sopra, suggerirei che l’applicazione di carta bianca di var non è una buona idea, perché la maggior parte delle cose è meglio fare con moderazione e in base alle circostanze a portata di mano, come mostrato qui.

Perché Resharper lo usa in modo predefinito? 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 la dichiarazione delle variabili locali tipizzate implicitamente” può essere regolata in base alle proprie preferenze , qualunque cosa sia, aprendo prima il menu delle opzioni per ReSharper:

Menu Opzioni ReSharper

Quindi, in “Controllo codice” regolando la “Severità di ispezione” della lingua scelta, nel mio caso c #:

Disattiva suggerimento di variabile locale implicitamente tipizzato

Come puoi vedere, ci sono opzioni per regolare tutti i suggerimenti che ReSharper fa. Spero che questo aiuti qualcuno come me che ha già una strategia di utilizzo “var” e vuole solo che ReSharper rispetti 🙂

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

 AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments ); 

è una forma di ripetizione . Se voglio modificare AVeryLongTypeName in una delle sue classi derivate, devo solo cambiarlo una volta quando uso var e ancora posso accedere ai metodi delle classi figlie.

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

‘var’ vuol dire essere chiari

Il dibattito principale sull’opportunità di utilizzare la parola chiave var o no riguarda il grado di leggibilità del codice per te e altri sviluppatori.

Proprio come se stessimo scrivendo una storia non c’è una risposta definitiva definitiva. Ma vediamo alcuni esempi di questo in inglese semplice.

Jake salutò Bill. Non gli piaceva, così 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 parola chiave var . In questo caso potrebbe essere più specifico. Il seguente esempio è molto più chiaro.

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

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

A Bill piacciono i libri, così Bill è andato in biblioteca e Bill ha tirato fuori un libro che Bill ha sempre amato.

In questo caso, sarebbe più facile leggere la frase se usassimo “lui” e in alcuni casi lasciassero fuori il suo nome tutti insieme, che è l’equivalente dell’uso della parola chiave var .

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

Questi esempi coprono l’essenza, ma non raccontano tutta la 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 in cui possiamo contribuire ad aggiungere chiarezza. Il tipo, il nome della variabile e il compito. Prendi questa riga di codice per esempio:

 Person p = GetPerson(); 

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

Che mi dici della seguente riga di codice? Sapresti ancora cosa significa p in questo caso:

 var p = GetPerson(); 

Che ne dici di adesso:

 var p = Get(); 

O ora:

 var person = Get(); 

O questo:

 var t = GetPerson(); 

O questo:

 var u = Person.Get(); 

Se la parola chiave var funziona in un determinato scenario dipende molto dal contesto del codice, come il modo in cui le variabili, le classi e i metodi sono denominati. Dipende anche dalla complessità del codice e dal resto del codice che lo circonda.

Personalmente mi piace usare la parola chiave var è più completo per me la maggior parte del tempo. Ma tendo anche a nominare le mie variabili dopo il tipo, quindi non sto davvero perdendo nessuna informazione.

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

Non mi piaceva 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 per qualsiasi standard di codifica che si desidera.

Modifica: ReSharper e var

La mia regola è questa:

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

     string myStr = "foo"; int[] myIntArray = [123, 456, 789]; double? myDouble = 123.3; 
  • Stai dichiarando un tipo complesso (ad es. List , Dictionary , MyObj )? -> Usa var :

     var myList = List(); var myDictionary = Dictionary(); var myObjInstance = new MyObj(); 

Vorrei solo sottolineare che l’uso di “var” è raccomandato nelle Convenzioni di codifica C # “quando il tipo di variabile è ovvio dal lato destro del compito, o quando il tipo preciso non è importante”, quindi questo è probabilmente perché il suggerimento è attivo per impostazione predefinita in ReSharper. Forniscono anche alcuni casi in cui non migliorerebbe la leggibilità di seguito nello stesso documento.

Vedo molte risposte corrette, ma manca quella completa.

È vero che Resharper esagera var di default. Penso che molte persone sarebbero d’accordo con questo. È anche più facile da leggere quando viene utilizzato var e il tipo è ovvio, ad esempio quando si utilizza una nuova istruzione. Ho visto un post che mostrava come aggiornare la severità dell’ispezione per mostrare solo suggerimenti per l’uso di var.

Avevo cercato di commentare altri post prima di aggiungere dove impostare questi, ma non avevo la reputazione per questo. Apparentemente anche io non avevo la reputazione di pubblicare il mio screenshot delle impostazioni.

Avrò spiegato come arrivarci.

In Visual Studio -> Menu principale -> Resharper -> Opzioni -> Modifica codice -> C # -> Stile codice -> Utilizzo var in dichiarazioni

  • Per i tipi built-in Usa il tipo esplicito
  • Per i tipi semplici Usa ‘var’ quando è evidente
  • Altrove Use’var ‘

inserisci la descrizione dell'immagine qui

ReSharper consiglia var perché tende a rendere meno complessa la creazione dell’object.

Confronta questi due esempi:

 StringBuilder bld = new StringBuilder(); var bld = new StringBuilder(); 

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

Penso che sia bello quando si creano nuovi oggetti in modo esplicito con “nuovo”. Tuttavia, nel tuo esempio, potrebbe non essere ovvio se le classi non fossero state denominate correttamente.

A proposito, ReSharper fa una distinzione tra “potresti voler applicare questo suggerimento al tuo codice” e “il tuo codice è rotto, vuoi che lo aggiusti?”. La parola chiave var è nella categoria dei suggerimenti, insieme a cose come “inverti se ridurre il nesting”; non devi seguirlo.

Puoi configurare quanto fastidiosi sono i loro avvisi attraverso la finestra di dialogo Opzioni, o direttamente attraverso il menu popup per quell’avviso. Puoi eseguire il downgrade di cose come il suggerimento var modo che siano meno importanti, oppure puoi aggiornare cose come l’avviso ‘use extension method’ in modo che si presenti come un errore reale.

La funzionalità var di .Net 3.0 è solo l’ inferenza di tipo , che è sicura dal tipo e spesso rende il tuo codice più facile da leggere. Ma non devi, e puoi distriggersre questa raccomandazione nel programma di ricerca, se vuoi.

Non c’è alcuna differenza tecnica, se usi var, il tipo è implicito dal compilatore. Se hai un codice come questo:

 var x = 1; 

x è implicito come 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 parola chiave var stata introdotta in C # 3.0 – ci permette di dimenticare di specificare esplicitamente il nostro tipo.

Non c’è una vera differenza se usi

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 di cliché, ma le seguenti affermazioni possono aiutarti a capire:

 var myInt = 23; 

restituisce un tipo int , mentre

 var myInt = "23"; 

restituisce un tipo di string .

Riferimento MSDN

La specifica di un tipo di object esplicito è in qualche modo ridondante. Anche tradotto in inglese, suona ridondante: “metti un object di tipo X in una variabile di tipo X” vs “Metti un object di tipo X in una variabile”.

Tuttavia, l’uso di “var” ha i suoi limiti . Impedisce l’uso inferiore del polimorfismo che è pura bellezza :

Assume che un cane estenda l’animale; Cat estende la gerarchia delle classi di 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’. 🙂

Var è incredibile! Ho incontrato molti sviluppatori che hanno l’impressione che var sia legato a un tipo dinamico, non lo è. È ancora tipizzato staticamente, è deciso dal compilatore.

Ecco alcuni aspetti positivi dell’utilizzo di var

Meno typing var è più breve e più facile da leggere, per esempio

Dictionary> postcodes = new Dictionary>() Yuk.

var postcodes = new Dictionary>() \ o / \ o /

Nomi di variabili più descrittivi – tenui, ma penso che sia importante lasciare qui la natura fluida di var . Poiché 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 di ritorno di una chiamata al metodo cambia. Devi solo cambiare la chiamata al metodo, non ogni posto in cui viene utilizzata.

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

A volte tuttavia è utile dichiarare esplicitamente i tipi e lo trovo molto utile in primitive o struct. Ad esempio, personalmente non trovo questa syntax molto utile:

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

vs

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

Tutto dipende dalle preferenze personali, ma l'utilizzo di var velocizzerà il tuo sviluppo e sbloccherà un intero mondo di qualità anonima.

Per coloro che non amano l’uso costante di “var”:

NOTA: puoi anche interrompere il resharper da default a var quando fai “introduce variabile”. Questo è stato qualcosa che mi ha frustrato per molto tempo, è sempre stato predefinito in var, e lo stavo cambiando ogni volta.

Queste impostazioni sono in Modifica codice -> C # -> Stile codice

inserisci la descrizione dell'immagine qui

A mio avviso, var dovrebbe 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 è una string .

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

Esempio:

 Dictionary>> dict = new Dictionary>>(); // This is a little easier to read than the above statement var dict = new Dictionary>>(); 

Oltre a questi scenari, non vedo alcun GAIN da utilizzare usando var , ma posso pensare ad alcuni scenari in cui può essere dannoso:

Ad esempio, un tipo monouso il cui valore di variabile sul lato destro non mostra chiaramente il tipo. Lo smaltimento di 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. 

Non c’è alcuna differenza tecnica (come sottolineato da eWolf). È ansible utilizzare uno o l’altro, il codice CLR generato sarà lo stesso.

A mio parere, il vantaggio principale è che questo tende a forzare l’utilizzo di una migliore denominazione delle variabili. Nel tuo esempio “pippo” è una scelta piuttosto scadente per un nome di variabile.

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

Dal loro sito web :

L’uso di variabili locali implicitamente tipizzate (noto anche come parola chiave var) introdotto in C # 3.0 è diventato molto popolare grazie alla leggibilità migliorata del codice risultante. Per impostazione predefinita, ReSharper incoraggia anche l’uso della parola chiave var, ma le preferenze del suo utilizzo sono configurabili in modo flessibile. Ad esempio, puoi scegliere di utilizzare tipi espliciti in casi specifici o ovunque.