Warum möchte ReSharper 'var' für alles verwenden?

Ich habe gerade angefangen, ReSharper mit Visual Studio zu verwenden (nach den vielen Empfehlungen zu SO). Zum Ausprobieren habe ich ein aktuelles ASP.NET MVC-Projekt geöffnet. Eines der ersten und häufigsten Dinge, die mir aufgefallen sind, ist, die meisten / alle meine expliziten Erklärungen varstattdessen zu ändern . Beispielsweise:

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

und so weiter, auch mit einfachen Typen wie int, boolusw.

Warum wird dies empfohlen? Ich komme nicht aus der Informatik oder dem .NET-Hintergrund, da ich kürzlich in die .NET-Entwicklung "hineingefallen" bin, daher würde ich gerne verstehen, was los ist und ob es von Nutzen ist oder nicht.

Ein Grund ist die verbesserte Lesbarkeit. Welches ist besser?

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

oder

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

Was ReSharper vorschlägt, ist eine deutliche Überbeanspruchung des Schlüsselworts var. Sie können es verwenden, wenn der Typ offensichtlich ist:

var obj = new SomeObject();

Wenn der Typ nicht offensichtlich ist, sollten Sie ihn lieber aufschreiben:

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

Ich persönlich ziehe es vor, diesen Vorschlag auszuschalten. Die Verwendung varkann häufig die Lesbarkeit verbessern. Aber wie Sie bereits erwähnt haben, wird es manchmal reduziert (bei einfachen Typen oder wenn der resultierende Typ dunkel ist ).

Ich wähle lieber, wann ich benutze varund wann nicht. Aber das bin nur ich.

varkann die Lesbarkeit des Codes verbessern und gleichzeitig das sofortige Verständnis des Codes verringern. Trotzdem kann es die Lesbarkeit des Codes für andere Situationen beeinträchtigen. Manchmal ist die Verwendung neutral. Das Maß für die Lesbarkeit zum Verständnis ist nicht proportional, sondern hängt von der Situation ab. Manchmal werden beide zusammen erhöht oder verringert.

Der Faktor ist, worauf varangewendet wird und wie gut das Ziel die sofortige Verschleierung seines Datentyps für den Leser unterstützt oder ob seine Typinformationen benötigt werden, um den vorliegenden Programmteil zu verstehen.

Beispielsweise kann eine schlechte Benennung dazu führen, vardass das Codeverständnis abnimmt. Dies ist jedoch nicht vardie Schuld:

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

Manchmal ist es nicht sinnvoll, varfür einfache Datentypen zu verwenden, wenn Code in Abwesenheit besser lesbar ist:

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

Manchmal varkann es nützlich sein, Datentypinformationen auszublenden, bei denen Sie nicht unbedingt die Komplexität von:

    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; 

Sie müssen verwenden, varwenn ein anonymer Typ vorhanden ist, da kein Typname zum Aufrufen vorhanden ist:

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

Wenn Visual Studio Intellisense trotz allem Typinformationen bereitstellt var, müssen Sie sich weniger auf Ihr Verständnis durch striktes Lesen des Codes ohne Hilfe verlassen. Es ist wahrscheinlich ratsam anzunehmen, dass nicht jeder Intellisense hat oder verwendet.

Zusammenfassend würde ich anhand der obigen Beispiele vorschlagen, dass die Anwendung von Carte Blanche varkeine gute Idee ist, da die meisten Dinge am besten in Maßen und basierend auf den hier gezeigten Umständen erledigt werden.

Warum verwendet Resharper es standardmäßig überall? Ich würde es zur Vereinfachung vorschlagen, da es die Nuancen von Situationen nicht analysieren kann, um zu entscheiden, wann es am besten nicht verwendet werden soll.

In ReSharper (8.02, aber wahrscheinlich auch in anderen Versionen) kann die Option für den Vorschlag "Implizit typisierte lokale Variablendeklaration verwenden" an Ihre Präferenz angepasst werden, indem Sie zuerst das Optionsmenü für ReSharper öffnen:

Dann unter "Code Inspection" durch Anpassen des "Inspection Severity" Ihrer gewählten Sprache, in meinem Fall c #:

Wie Sie sehen, gibt es Optionen zum Anpassen aller Vorschläge von ReSharper. Hoffe, das hilft jemandem wie mir, der bereits eine 'var'-Nutzungsstrategie hat und nur möchte, dass ReSharper diese respektiert :)

Ich bin überrascht, dass niemand erwähnt hat, dass es auch einfacher ist, den Typ des instanziierten Objekts zu ändern, weil

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

ist eine Form der Wiederholung . Wenn ich AVeryLongTypeNamein eine der abgeleiteten Klassen wechseln möchte , muss ich dies bei Verwendung nur einmal ändern varund kann weiterhin auf Methoden der untergeordneten Klassen zugreifen.

Abgesehen davon ist die verbesserte Lesbarkeit ein wichtiger Punkt, aber wie andere sagten, sollte var nicht überbeansprucht werden, daher denke ich, dass es absolut in Ordnung ist, den Hinweis in Resharper auszuschalten.

Bei 'var' geht es darum, klar zu sein

Die Hauptdebatte darüber, ob das varSchlüsselwort verwendet werden soll oder nicht, besteht darin, wie lesbar der Code für Sie und andere Entwickler ist.

Als ob Sie eine Geschichte schreiben würden, gibt es keine endgültige richtige Antwort. Aber schauen wir uns einige Beispiele dafür im Klartext an.

Jake sagte Hallo zu Bill. Er mochte ihn nicht, also drehte er sich um und ging in die andere Richtung.

Wer ist den anderen Weg gegangen? Jake oder Bill? In diesem Fall entspricht die Verwendung der Namen "Jake" und "Bill" der Verwendung des Typnamens. Und "Er" und "Ihn" ist wie das Verwenden des varSchlüsselworts. In diesem Fall kann es hilfreich sein, genauer zu sein. Das Folgende ist zum Beispiel viel klarer.

Jake sagte Hallo zu Bill. Jake mochte Bill nicht, also drehte er sich um und ging in die andere Richtung.

In diesem Fall machte eine genauere Darstellung den Satz klarer. Aber das wird nicht immer der Fall sein. In einigen Fällen ist es schwieriger zu lesen, wenn man spezifisch ist.

Bill mag Bücher, also ging Bill in die Bibliothek und Bill holte ein Buch heraus, das Bill immer gefallen hat.

In diesem Fall wäre es einfacher, den Satz zu lesen, wenn wir "er" verwenden und in einigen Fällen seinen Namen alle zusammen weglassen würden, was der Verwendung des varSchlüsselworts entspricht.

Bill mag Bücher, also ging er in die Bibliothek und holte ein Buch heraus, das er immer gemocht hat.

Diese Beispiele decken den Kern ab, aber sie erzählen nicht die ganze Geschichte. In diesen Beispielen gab es nur einen Weg, sich auf die Person zu beziehen. Entweder durch Verwendung ihres Namens oder durch Verwendung eines allgemeineren Begriffs wie "er" und "ihn".

Im Fall von Code haben wir drei Möglichkeiten, um Klarheit zu schaffen. Der Typ, der Variablenname und die Zuordnung. Nehmen Sie zum Beispiel diese Codezeile:

Person p = GetPerson();

Es stellt sich nun die Frage, ob in dieser Codezeile genügend Informationen enthalten sind, um herauszufinden, was los ist.

Was ist mit der folgenden Codezeile? Würdest du noch wissen, was pin diesem Fall bedeutet:

var p = GetPerson();

Wie wäre es jetzt:

var p = Get();

Oder jetzt:

var person = Get();

Oder dieses:

var t = GetPerson();

Oder dieses:

var u = Person.Get();

Ob das Schlüsselwort varin einem bestimmten Szenario funktioniert, hängt stark vom Kontext des Codes ab, z. B. davon, wie die Variablen, Klassen und Methoden benannt werden. Dies hängt auch von der Komplexität des Codes und dem Rest des ihn umgebenden Codes ab.

Persönlich verwende ich gerne das varSchlüsselwort, das für mich die meiste Zeit umfassender ist. Aber ich neige auch dazu, meine Variablen nach dem Typ zu benennen, damit ich nicht wirklich Informationen verliere.

Das heißt, manchmal, abhängig vom Kontext, in dem ich Ausnahmen mache, ist dies die Natur von allem Komplexen, und Software ist nichts, wenn nicht komplex.

Ich mochte das auch nicht.

Ich möchte nicht, dass dies zu einer Debatte über die Verwendung von wird var, es hat seine Verwendung, sollte aber nicht überall verwendet werden.

Das Wichtigste ist, dass ReSharper nach den von Ihnen gewünschten Codierungsstandards konfiguriert ist.

Edit: ReSharper und var

Ich sehe viele richtige Antworten, aber es fehlt die vollständige.

Es ist wahr, dass ReSharper varstandardmäßig überbeansprucht wird. Ich denke, die meisten Leute würden dem zustimmen. Es ist auch einfacher zu lesen, wann vares verwendet wird, und der Typ ist offensichtlich, z. B. wenn Sie eine newAnweisung verwenden. Ich habe einen Beitrag gesehen, in dem gezeigt wurde, wie der Schweregrad der Inspektion aktualisiert wird, um nur Hinweise für die Verwendung von anzuzeigen var.

Ich hatte versucht, zuerst andere Beiträge zu kommentieren, um hinzuzufügen, wo diese gesetzt werden sollen, hatte aber nicht den Ruf dafür. Anscheinend hatte ich auch nicht den Ruf, meinen Screenshot der Einstellungen zu veröffentlichen.

Ich werde erklären, wie man dorthin kommt.

In Visual Studio> Hauptmenü> Resharper> Optionen> Codebearbeitung> C #> Codestil> Var-Verwendung in Deklarationen

• Für integrierte Typen Verwenden Sie einen expliziten Typ
• Für einfache Typen Verwenden Sie 'var', wenn dies offensichtlich ist
• Anderswo Use'var '

ReSharper-Hilfedokumentation: Codesyntaxstil: Implizite / Explizite Typisierung (Schlüsselwort 'var') - Konfigurieren Sie die Einstellungen für die Verwendung des Schlüsselworts 'var'

Meine Regel lautet:

• Deklarieren Sie eine primitive Art (dh byte, char, string, int[], double?, decimal, etc.)? -> Verwenden Sie den Typ:

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

• Deklarieren Sie einen komplexen Typ (dh List<T>, Dictionary<T, T>, MyObj)? -> Verwenden Sie var:

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

Ich möchte nur darauf hinweisen, dass die Verwendung von "var" in den C # -Codierungskonventionen empfohlen wird

wenn der Typ der Variablen auf der rechten Seite der Zuweisung ersichtlich ist oder wenn der genaue Typ nicht wichtig ist

Das ist wahrscheinlich der Grund, warum der Tipp in ReSharper standardmäßig aktiviert ist. Sie bieten auch einige Fälle, in denen die Lesbarkeit direkt im selben Dokument nicht verbessert wird.

ReSharper empfiehlt, varda es dazu neigt, die Objekterstellung übersichtlich zu gestalten.

Vergleichen Sie diese beiden Beispiele:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

Es ist nur eine Kurzschrift, die leichter zu lesen sein soll.

Ich denke, es ist in Ordnung, wenn Sie neue Objekte explizit mit "new" erstellen. In Ihrem Beispiel ist es jedoch möglicherweise nicht offensichtlich, ob die Klassen nicht richtig benannt wurden.

Übrigens unterscheidet ReSharper zwischen "Sie möchten diesen Vorschlag möglicherweise auf Ihren Code anwenden" und "Ihr Code ist fehlerhaft, soll ich ihn beheben?". Das varSchlüsselwort befindet sich in der Kategorie "Vorschläge", zusammen mit Dingen wie "Invertieren, wenn die Verschachtelung reduziert werden soll". du musst ihm nicht folgen.

Sie können konfigurieren, wie ärgerlich die einzelnen Warnungen sind, indem Sie das Dialogfeld "Optionen" oder direkt das Popup-Menü für diese Warnung verwenden. Sie können Dinge wie den varVorschlag herabstufen , damit sie weniger auffällig sind, oder Sie können Dinge wie die Warnung "Erweiterungsmethode verwenden" aktualisieren, damit sie als tatsächlicher Fehler angezeigt wird.

Die varFunktion von .Net 3.0 ist nur die Typinferenz , die typsicher ist und häufig das Lesen Ihres Codes erleichtert. Sie müssen dies jedoch nicht und können diese Empfehlung in Resharper deaktivieren, wenn Sie möchten.

Var ist unglaublich! Ich bin auf viele Entwickler gestoßen, die den Eindruck haben, varan einen dynamischen Typ gebunden zu sein, das ist es nicht. Es ist immer noch statisch typisiert, es wird nur vom Compiler entschieden.

Hier sind einige erstaunliche Vorteile der Verwendung von var

Weniger typing var ist kürzer und leichter zu lesen, zum Beispiel

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

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

Beschreibendere Variablennamen - dünn, aber ich denke, es ist wichtig, die fließende Natur des varLeuchten hier zum Leuchten zu bringen. Wie vares ein bisschen vage ist, ermutigt es wirklich einen eher beschreibenden Variablennamen, anstatt den Typ für sich selbst sprechen zu lassen.

Weniger Codeänderungen - wenn sich der Rückgabetyp eines Methodenaufrufs ändert. Sie müssen nur den Methodenaufruf ändern, nicht jeden Ort, an dem er verwendet wird.

Anonyme Typen - anonyme Typen sind ein wirklich leistungsfähiges Konzept, vor allem in Bereichen wie WebAPI Teilressourcen . Ohne var können sie nicht verwendet werden.

Manchmal ist es jedoch nützlich, Typen explizit zu deklarieren, und ich finde dies am nützlichsten in Grundelementen oder Strukturen. Zum Beispiel finde ich diese Syntax persönlich nicht sehr nützlich:

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

}

vs.

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

}

Es hängt alles varvon Ihren persönlichen Vorlieben ab, aber die Verwendung wird Ihre Entwicklung wirklich beschleunigen und eine ganze Welt anonymer Typgüte freischalten.

Es gibt keinen technischen Unterschied. Wenn Sie var verwenden, wird der Typ vom Compiler impliziert. Wenn Sie einen Code wie diesen haben:

var x = 1;

x ist ein int und es können keine anderen Werte zugewiesen werden.

Das Schlüsselwort var ist nützlich, wenn Sie den Typ der Variablen ändern. Sie müssen dann nur eine Änderung anstelle von zwei vornehmen:

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

Das varSchlüsselwort wurde in C # 3.0 eingeführt. Dadurch können wir vergessen, unseren Typ explizit anzugeben.

Es gibt keinen wirklichen Unterschied, ob Sie verwenden

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

oder

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

außer reine Lesbarkeit und geringere Fehlerwahrscheinlichkeit.

Es scheint ein klischeehaftes Beispiel zu sein, aber sagen Sie, dass Folgendes Ihrem Verständnis helfen kann:

var myInt = 23;

gibt einen intTyp zurück, während

var myInt = "23";

gibt einen stringTyp zurück.

MSDN-Referenz

Die Angabe eines expliziten Objekttyps ist irgendwie redundant. Sogar ins Englische übersetzt klingt das überflüssig: "Ein Objekt vom Typ X in eine Variable vom Typ X einfügen" vs "Ein Objekt vom Typ X in eine Variable einfügen".

Die Verwendung von 'var' hat jedoch ihre Grenzen . Es verhindert die folgende Verwendung von Polymorphismus, der reine Schönheit ist :

Angenommen, ein Hund erweitert das Tier. Katze erweitert Tierklassenhierarchie:

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

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

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

Derselbe Code, bei dem x mit 'var' deklariert ist, wird nicht kompiliert .

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

Zurück zur ursprünglichen Frage: Ich verwende Resharper nicht, aber ich gehe davon aus, dass dies klug genug ist, um zu erkennen, wann 'var' nicht verwendet werden soll. :-)

Meiner Ansicht nach varsollte nur verwendet werden, wenn sofort klar ist, um welchen Typ es sich bei der Definition des Werts der Variablen handelt.

Beispiel:

var s = "string value";

Es ist offensichtlich, dass sa string.

Ich halte es auch für angebracht, wenn der Variablentypname sehr komplex ist.

Beispiel:

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

Abgesehen von diesen Szenarien sehe ich keinen Gewinn, der durch die Verwendung erzielt werden varkann, aber ich kann mir einige Szenarien vorstellen, in denen dies nachteilig sein kann:

Zum Beispiel ein Einweg-Typ, dessen rechter Variablenwert den Typ nicht klar anzeigt. Die Entsorgung des IDisposable kann leicht vergessen werden

Beispiel:

// 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' fügt Ihrem Code eine Art "dynamisches" Element hinzu (obwohl der Code natürlich streng typisiert bleibt). Ich rate davon ab, es in Fällen zu verwenden, in denen der Typ nicht klar ist. Betrachten Sie dieses Beispiel:

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

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

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

Sollte der Rückgabetyp von GetTheObjectFromDatabase () von Typ A nach B geändert werden, werden wir dies nicht bemerken, da beide Klassen DoSomething () implementieren. Der Code kann jetzt jedoch tatsächlich etwas völlig anderes tun.

Dies kann so subtil sein, als würden beide verschiedene Dinge in ein Protokoll schreiben, sodass Sie möglicherweise nicht bemerken, dass es zu spät ist.

Die folgende Verwendung von var sollte immer in Ordnung sein:

var abc = new Something();

Für diejenigen, die die ständige Verwendung von "var" nicht mögen, können Sie ReSharper auch daran hindern, standardmäßig var zu verwenden, wenn Sie "Variable einführen" ausführen. Dies war etwas, das mich lange Zeit frustrierte, es war immer standardmäßig var und ich änderte es jedes Mal.

Diese Einstellungen finden Sie unter Codebearbeitung> C #> Codestil

Es gibt keinen technischen Unterschied (wie eWolf hervorhob). Sie können den einen oder anderen verwenden, der generierte CLR-Code sieht gleich aus.

Meiner Meinung nach besteht der Hauptvorteil darin, dass Sie dazu gezwungen werden, bessere Variablennamen zu verwenden. In Ihrem Beispiel ist 'foo' eine ziemlich schlechte Wahl für einen Variablennamen.

Laut JetBrains (dem Autor von ReSharper) empfehlen sie standardmäßig die Verwendung von var.

Von ihrer Website :

Die Verwendung implizit typisierter lokaler Variablen (auch als varSchlüsselwort bezeichnet), die in C # 3.0 eingeführt wurden, ist sehr beliebt geworden, da sie in vielen Szenarien die Lesbarkeit verbessert. Standardmäßig empfiehlt ReSharper auch die Verwendung von varSchlüsselwörtern. Die Einstellungen für die Verwendung sind jedoch flexibel konfigurierbar. Sie können beispielsweise in bestimmten Fällen oder überall explizite Typen verwenden, und ReSharper hilft Ihnen bei der Durchsetzung Ihrer Einstellungen.