Verwendung des Schlüsselworts var in C #

Nach einer Diskussion mit Kollegen über die Verwendung des Schlüsselworts 'var' in C # 3 fragte ich mich, wie die Meinung der Leute zu den geeigneten Verwendungen der Typinferenz über var war.

Zum Beispiel habe ich var unter fragwürdigen Umständen eher faul benutzt, zB: -

foreach(var item in someList) { // ... } // Type of 'item' not clear.
var something = someObject.SomeProperty; // Type of 'something' not clear.
var something = someMethod(); // Type of 'something' not clear.

Weitere legitime Verwendungen von var sind: -

var l = new List<string>(); // Obvious what l will be.
var s = new SomeClass(); // Obvious what s will be.

Interessanterweise scheint LINQ eine Grauzone zu sein, z. B.: -

var results = from r in dataContext.SomeTable
              select r; // Not *entirely clear* what results will be here.

Es ist klar, welche Ergebnisse sich daraus ergeben werden, dass es sich um einen Typ handelt, der IEnumerable implementiert. Es ist jedoch nicht ganz so offensichtlich, wie es sich für eine var handelt, die ein neues Objekt deklariert.

Es ist noch schlimmer, wenn es um LINQ für Objekte geht, zB: -

var results = from item in someList
              where item != 3
              select item;

Dies ist nicht besser als das gleichwertige foreach (var item in someList) {// ...} equivilent.

Hier besteht ein echtes Problem hinsichtlich der Typensicherheit. Wenn wir beispielsweise die Ergebnisse dieser Abfrage in eine überladene Methode einfügen, die IEnumerable <int> und IEnumerable <double> akzeptiert, übergibt der Aufrufer möglicherweise versehentlich den falschen Typ.

var Die Typisierung ist zwar stark, aber die Frage ist wirklich, ob es gefährlich ist, wenn der Typ bei der Definition nicht sofort erkennbar ist. Dies wird vergrößert, wenn Überladungen dazu führen, dass Compilerfehler möglicherweise nicht ausgegeben werden, wenn Sie den falschen Typ unbeabsichtigt an eine Methode übergeben.

Ich denke varimmer noch, dass Code in einigen Fällen besser lesbar sein kann. Wenn ich eine Kundenklasse mit einer Orders-Eigenschaft habe und diese einer Variablen zuweisen möchte, gehe ich einfach so vor:

var orders = cust.Orders;

Ich interessiere mich nicht , wenn Customer.Orders ist IEnumerable<Order>, ObservableCollection<Order>oder BindingList<Order>- alles , was ich will , ist , dass die Liste im Speicher zu iterieren halten oder seine Zählung oder etwas bekommen später.

Vergleichen Sie die obige Erklärung mit:

ObservableCollection<Order> orders = cust.Orders;

Für mich ist der Typname nur Rauschen. Und wenn ich zurückgehe und mich entscheide, den Typ des Kunden zu ändern. Bestellungen später (etwa von ObservableCollection<Order>bis IList<Order>), dann muss ich auch diese Deklaration ändern - etwas, das ich nicht tun müsste, wenn ich in der ersten var verwendet hätte Ort.

Ich benutze varausgiebig. Es wurde kritisiert, dass dies die Lesbarkeit des Codes beeinträchtigt, aber kein Argument, um diese Behauptung zu stützen.

Zugegeben, es kann bedeuten, dass nicht klar ist, um welchen Typ es sich handelt. Na und? Dies ist eigentlich der Punkt eines entkoppelten Designs. Beim Umgang mit Schnittstellen interessiert Sie nachdrücklich nicht der Typ einer Variablen. vargeht zwar viel weiter, aber ich denke, dass das Argument unter dem Gesichtspunkt der Lesbarkeit dasselbe bleibt: Der Programmierer sollte eigentlich nicht am Typ der Variablen interessiert sein, sondern daran, was eine Variable tut . Aus diesem Grund nennt Microsoft die Typinferenz auch "Ententypisierung".

Was macht eine Variable, wenn ich sie mit deklariere var? Ganz einfach, es macht alles, was IntelliSense mir sagt. Alle Überlegungen zu C #, die die IDE ignorieren, bleiben hinter der Realität zurück. In der Praxis wird jeder C # -Code in einer IDE programmiert, die IntelliSense unterstützt.

Wenn ich eine vardeklarierte Variable verwende und verwirrt bin, wofür die Variable da ist, stimmt etwas grundlegend mit meinem Code nicht. varist nicht die Ursache, es macht nur die Symptome sichtbar. Beschuldige nicht den Boten.

Nun hat das C # Team eine Codierung Richtlinie veröffentlicht die besagt , dass varsollte nur das Ergebnis einer LINQ - Anweisung zu erfassen verwendet werden , die einen anonymen Typ erzeugt (weil hier, wir haben keine wirkliche Alternative zu var). Nun, scheiß drauf. Solange das C # -Team mir kein stichhaltiges Argument für diese Richtlinie gibt, werde ich sie ignorieren, da es meiner beruflichen und persönlichen Meinung nach reiner Quatsch ist. (Entschuldigung; ich habe keinen Link zu der fraglichen Richtlinie.)

Eigentlich gibt es einige (oberflächlich) gute Erklärungen, warum Sie sie nicht verwenden sollten, varaber ich glaube immer noch, dass sie größtenteils falsch sind. Nehmen Sie das Beispiel der „Suchbarkeit“: Der Autor behauptet, vardass es schwierig ist, nach Orten zu suchen, an denen sie MyTypeverwendet werden. Recht. Schnittstellen auch. Warum sollte ich eigentlich wissen wollen, wo die Klasse verwendet wird? Ich könnte mehr daran interessiert sein, wo es instanziiert wird, und dies wird immer noch durchsuchbar sein, da irgendwo sein Konstruktor aufgerufen werden muss (selbst wenn dies indirekt erfolgt, muss der Typname irgendwo erwähnt werden).

Var, meiner Meinung nach , in C # ist eine gute Sache ^tm . Jede so eingegebene Variable ist immer noch stark typisiert, aber ihr Typ wird von der rechten Seite der Zuweisung abgerufen, in der sie definiert ist. Da die Typinformationen auf der rechten Seite verfügbar sind, ist es in den meisten Fällen unnötig und übermäßig ausführlich, sie auch auf der linken Seite eingeben zu müssen. Ich denke, dies erhöht die Lesbarkeit erheblich, ohne die Typensicherheit zu beeinträchtigen.

Aus meiner Sicht ist die Verwendung guter Namenskonventionen für Variablen und Methoden aus Sicht der Lesbarkeit wichtiger als explizite Typinformationen. Wenn ich die Typinformationen benötige, kann ich immer mit der Maus über die Variable (in VS) fahren und sie abrufen. Im Allgemeinen sollten explizite Typinformationen für den Leser jedoch nicht erforderlich sein. Für den Entwickler erhalten Sie in VS immer noch Intellisense, unabhängig davon, wie die Variable deklariert ist. Trotzdem kann es immer noch Fälle geben, in denen es sinnvoll ist, den Typ explizit zu deklarieren - vielleicht haben Sie eine Methode, die a zurückgibt List<T>, aber Sie möchten sie als behandelnIEnumerable<T>in Ihrer Methode. Um sicherzustellen, dass Sie die Schnittstelle verwenden, kann dies durch Deklarieren der Variablen des Schnittstellentyps explizit gemacht werden. Oder Sie möchten eine Variable ohne Anfangswert deklarieren, da sie aufgrund einer bestimmten Bedingung sofort einen Wert erhält. In diesem Fall benötigen Sie den Typ. Wenn die Typinformationen nützlich oder notwendig sind, verwenden Sie sie. Ich bin jedoch der Meinung, dass dies normalerweise nicht erforderlich ist und der Code in den meisten Fällen ohne ihn leichter zu lesen ist.

Keines davon ist absolut wahr; varkann sowohl positive als auch negative Auswirkungen auf die Lesbarkeit haben. Sollte meiner Meinung nach varverwendet werden, wenn eine der folgenden Aussagen zutrifft:

1. Der Typ ist anonym (nun, Sie haben hier keine Wahl, wie es sein muss var in diesem Fall)
2. Der Typ ist offensichtlich basierend auf dem zugewiesenen Ausdruck (dh var foo = new TypeWithAReallyLongNameTheresNoSenseRepeating())

varhat keine Auswirkungen auf die Leistung, da es sich um syntaktischen Zucker handelt; Der Compiler leitet den Typ ab und definiert ihn, sobald er in IL kompiliert wurde. Es ist nichts wirklich Dynamisches daran.

Von Eric Lippert, einem Senior Software Design Engineer im C # -Team:

Warum wurde das varSchlüsselwort eingeführt?

Es gibt zwei Gründe, einen, der heute existiert, einen, der in 3.0 auftauchen wird.

Der erste Grund ist, dass dieser Code wegen der Redundanz unglaublich hässlich ist:

Dictionary<string, List<int>> mylists = new Dictionary<string, List<int>>();

Und das ist ein einfaches Beispiel - ich habe schlechter geschrieben. Jedes Mal, wenn Sie gezwungen sind, zweimal genau dasselbe einzugeben, können wir diese Redundanz entfernen. Viel schöner zu schreiben

var mylists = new Dictionary<string,List<int>>();

und lassen Sie den Compiler herausfinden, welcher Typ auf der Zuweisung basiert.

Zweitens führt C # 3.0 anonyme Typen ein. Da anonyme Typen per definitionem keine Namen haben, Sie müssen den Typ der Variable aus der Initialisierung Ausdruck ableiten zu können , wenn seine Art anonym.

Hervorhebung von mir. Der ganze Artikel, C # 3.0, ist immer noch statisch typisiert, ehrlich! und die folgenden Serien sind ziemlich gut.

Dafür ist da var. Andere Anwendungen werden wahrscheinlich nicht so gut funktionieren. Jeder Vergleich mit JScript, VBScript oder dynamischer Typisierung ist eine totale Koje. Hinweis wieder, varist erforderlich , um in .NET bestimmten anderen Merkmalen der Arbeit zu haben.

Ich denke, die Verwendung von var sollte mit weise ausgewählten Variablennamen gekoppelt werden.

Ich habe kein Problem damit, var in einer foreach-Anweisung zu verwenden, vorausgesetzt, es ist nicht so:

foreach (var c in list) { ... }

Wenn es eher so wäre:

foreach (var customer in list) { ... }

... dann würde jemand, der den Code liest, viel eher verstehen, was "Liste" ist. Wenn Sie die Kontrolle über den Namen der Listenvariablen selbst haben, ist dies sogar noch besser.

Gleiches kann für andere Situationen gelten. Das ist ziemlich nutzlos:

var x = SaveFoo(foo);

... aber das macht Sinn:

var saveSucceeded = SaveFoo(foo);

Jeder für sich, denke ich. Ich habe dies getan, was einfach verrückt ist:

var f = (float)3;

Ich brauche eine Art 12-Stufen-Var-Programm. Mein Name ist Matt und ich (ab) benutze var.

Wir haben das Ethos "Code für Menschen, nicht für Maschinen" übernommen, basierend auf der Annahme, dass Sie im Wartungsmodus mehrmals länger verbringen als bei Neuentwicklungen.

Für mich schließt dies das Argument aus, dass der Compiler "weiß", um welchen Typ es sich bei der Variablen handelt. Natürlich können Sie beim ersten Mal keinen ungültigen Code schreiben, da der Compiler das Kompilieren Ihres Codes verhindert, aber wenn der nächste Entwickler den Code liest In 6 Monaten müssen sie in der Lage sein, die korrekte oder falsche Funktion der Variablen abzuleiten und die Ursache der Probleme schnell zu identifizieren.

Somit,

var something = SomeMethod();

ist durch unsere Codierungsstandards verboten, aber in unserem Team wird Folgendes empfohlen, da dies die Lesbarkeit verbessert:

var list = new List<KeyValuePair<string, double>>();
FillList( list );
foreach( var item in list ) {
   DoWork( item ); 
}

Es ist nicht schlecht, es ist eher eine stilistische Sache, die eher subjektiv ist. Es kann zu Inkonsistenzen kommen, wenn Sie var verwenden und wenn Sie dies nicht tun.

Ein weiterer besorgniserregender Fall: Im folgenden Aufruf können Sie nicht anhand des Codes erkennen, von welchem ​​Typ er zurückgegeben wurde CallMe:

var variable = CallMe();

Das ist meine Hauptbeschwerde gegen var.

Ich verwende var, wenn ich anonyme Delegaten in Methoden deklariere. Irgendwie sieht var sauberer aus, als wenn ich es verwenden würde Func. Betrachten Sie diesen Code:

var callback = new Func<IntPtr, bool>(delegate(IntPtr hWnd) {
   ...
});

BEARBEITEN : Das letzte Codebeispiel wurde basierend auf Julians Eingabe aktualisiert

Var ist überhaupt keine Variante. Die Variable ist immer noch stark typisiert. Sie drücken lediglich keine Tasten, um dies zu erreichen. Sie können in Visual Studio mit der Maus darüber fahren, um den Typ anzuzeigen. Wenn Sie gedruckten Code lesen, müssen Sie möglicherweise ein wenig nachdenken, um herauszufinden, um welchen Typ es sich handelt. Es gibt jedoch nur eine Zeile, in der dies deklariert wird, und viele Zeilen, in denen es verwendet wird. Daher ist es immer noch der beste Weg, den Code einfacher zu befolgen, wenn Sie den Dingen anständige Namen geben.

Ist die Verwendung von Intellisense faul? Es ist weniger tippen als der ganze Name. Oder gibt es Dinge, die weniger Arbeit sind, aber keine Kritik verdienen? Ich denke es gibt und var ist einer von ihnen.

Die wahrscheinlichste Zeit, die Sie dafür benötigen, ist für anonyme Typen (wo dies zu 100% erforderlich ist). aber es vermeidet auch Wiederholungen für die trivialen Fälle, und IMO macht die Linie klarer. Für eine einfache Initialisierung muss der Typ nicht zweimal angezeigt werden.

Zum Beispiel:

Dictionary<string, List<SomeComplexType<int>>> data = new Dictionary<string, List<SomeComplexType<int>>>();

(Bitte bearbeiten Sie den hscroll oben nicht - es beweist irgendwie den Punkt !!!)

vs:

var data = new Dictionary<string, List<SomeComplexType<int>>>();

Es gibt jedoch Fälle, in denen dies irreführend ist und möglicherweise Fehler verursachen kann. Seien Sie vorsichtig, varwenn die ursprüngliche Variable und der initialisierte Typ nicht identisch sind. Zum Beispiel:

static void DoSomething(IFoo foo) {Console.WriteLine("working happily") }
static void DoSomething(Foo foo) {Console.WriteLine("formatting hard disk...");}

// this working code...
IFoo oldCode = new Foo();
DoSomething(oldCode);
// ...is **very** different to this code
var newCode = new Foo();
DoSomething(newCode);

Ein spezieller Fall, in dem var schwierig ist: Offline-Codeüberprüfungen, insbesondere auf Papier.

Dafür können Sie sich nicht auf Mouse-Over verlassen.

Ich verstehe nicht, was die große Sache ist ..

var something = someMethod(); // Type of 'something' not clear <-- not to the compiler!

Sie haben immer noch die volle Intelligenz für 'etwas' und für jeden zweideutigen Fall haben Sie Ihre Unit-Tests, oder? ( machst du? )

Es ist kein Varchar, es ist nicht dunkel und es ist sicherlich keine dynamische oder schwache Eingabe. Es stoppt Madden wie folgt:

List<somethinglongtypename> v = new List<somethinglongtypename>();

und Reduzieren dieser totalen Unordnung auf:

var v = new List<somethinglongtypename>();

Schön, nicht ganz so schön wie:

v = List<somethinglongtypename>();

Aber dafür ist Boo da .

Wenn jemand das varSchlüsselwort verwendet, weil er den Typ nicht "herausfinden" möchte, ist dies definitiv der falsche Grund. Das varSchlüsselwort erstellt keine Variable mit einem dynamischen Typ, der Compiler muss den Typ noch kennen. Da die Variable immer einen bestimmten Typ hat, sollte der Typ nach Möglichkeit auch im Code ersichtlich sein.

Gute Gründe für die Verwendung des varSchlüsselworts sind zum Beispiel:

• Wo es benötigt wird, dh um eine Referenz für einen anonymen Typ zu deklarieren.
• Wo es den Code lesbarer macht, dh sich wiederholende Deklarationen entfernen.

Das Ausschreiben des Datentyps erleichtert häufig das Verfolgen des Codes. Es zeigt, welche Datentypen Sie verwenden, sodass Sie den Datentyp nicht herausfinden müssen, indem Sie zuerst herausfinden, was der Code tut.

Angesichts der Leistungsfähigkeit von Intellisense bin ich mir nicht sicher, ob var schwerer zu lesen ist als Mitgliedsvariablen in einer Klasse oder lokale Variablen in einer Methode, die außerhalb des sichtbaren Bildschirmbereichs definiert sind.

Wenn Sie eine Codezeile wie haben

IDictionary<BigClassName, SomeOtherBigClassName> nameDictionary = new Dictionary<BigClassName, SomeOtherBigClassName>();

Es ist viel einfacher oder schwerer zu lesen als:

var nameDictionary = new Dictionary<BigClassName, SomeOtherBigClassName>();

Ich denke, das Wichtigste bei VAR ist, es nur dort zu verwenden, wo es angebracht ist, dh wenn Sie Dinge in Linq tun, die es erleichtert (und wahrscheinlich in anderen Fällen).

Wenn Sie schon bekommen einen Typen für etwas in der dann sollten Sie sie verwenden - nicht so zu tun , ist einfach Faulheit (im Gegensatz zu kreativer Faulheit gegenüber, die im Allgemeinen gefördert werden soll - gute Programmierer oft sehr hart arbeiten , faul zu sein und könnte in Betracht gezogen werden die Quelle der Sache an erster Stelle).

Ein generelles Verbot ist genauso schlimm wie der Missbrauch des Konstrukts, aber es muss einen vernünftigen Codierungsstandard geben.

Die andere Sache, an die man sich erinnern sollte, ist, dass es keine VB- Typvariable ist , da es keine Typen ändern kann - es ist eine stark typisierte Variable, nur dass der Typ abgeleitet wird (weshalb es Leute gibt, die argumentieren, dass dies nicht unangemessen ist Verwenden Sie es beispielsweise in einem Foreach, aber ich würde aus Gründen der Lesbarkeit und Wartbarkeit nicht zustimmen.

Ich vermute, dieser wird rennen und rennen (-:

Murph

Sicher, intist einfach, aber wenn der Typ der Variablen ist IEnumerable<MyStupidLongNamedGenericClass<int, string>>, macht var die Dinge viel einfacher.

Aus dem Beitrag zu diesem Thema bei CodingHorror gestohlen :

Leider haben Sie und alle anderen es ziemlich falsch verstanden. Ich stimme Ihnen zwar zu, dass Redundanz keine gute Sache ist, aber der bessere Weg, um dieses Problem zu lösen, wäre gewesen, etwa Folgendes zu tun:

Nicholas Paldino .NET / C # MVP am 20. Juni 2008 um 08:00 Uhr

Ich denke, wenn Ihr Hauptanliegen darin besteht, weniger tippen zu müssen, dann gibt es kein Argument, das Sie davon abhält, es zu verwenden.

Wenn Sie jemals nur die Person sein werden, die sich Ihren Code ansieht, wen interessiert das dann? Ansonsten in einem Fall wie diesem:

var people = Managers.People

Es ist in Ordnung, aber in einem Fall wie diesem:

var fc = Factory.Run();

Es schließt alle unmittelbaren Typabzüge kurz, die mein Gehirn aus dem 'Englisch' des Codes bilden könnte.

Andernfalls verwenden Sie einfach Ihr bestes Urteilsvermögen und programmieren Sie "Höflichkeit" gegenüber anderen, die möglicherweise an Ihrem Projekt arbeiten müssen.

Die Verwendung varanstelle eines expliziten Typs erleichtert die Umgestaltung erheblich (daher muss ich den vorherigen Postern widersprechen, die bedeuteten, dass es keinen Unterschied machte oder es sich lediglich um "syntaktischen Zucker" handelte).

Sie können den Rückgabetyp Ihrer Methoden ändern, ohne jede Datei zu ändern, in der diese Methode aufgerufen wird. Vorstellen

...
List<MyClass> SomeMethod() { ... }
...

welches wie verwendet wird

...
IList<MyClass> list = obj.SomeMethod();
foreach (MyClass c in list)
  System.Console.WriteLine(c.ToString());
...

Wenn Sie einen Refactor SomeMethod()für die Rückgabe eines IEnumerable<MySecondClass>erstellen möchten, müssen Sie die Variablendeklaration ändern (auch innerhalb desforeach ) an jeder Stelle Sie die Methode verwendet haben.

Wenn du schreibst

...
var list = obj.SomeMethod();
foreach (var element in list)
  System.Console.WriteLine(element.ToString());
...

Stattdessen müssen Sie es nicht ändern.

@aku: Ein Beispiel sind Codeüberprüfungen. Ein weiteres Beispiel sind Refactoring-Szenarien.

Grundsätzlich möchte ich nicht mit meiner Maus auf Typjagd gehen. Es ist möglicherweise nicht verfügbar.

Es ist Geschmackssache. All diese Aufregung um den Typ einer Variablen verschwindet, wenn Sie sich an dynamisch typisierte Sprachen gewöhnen. Das heißt, wenn Sie jemals anfangen, sie zu mögen (ich bin nicht sicher, ob jeder kann, aber ich tue es).

C # varist ziemlich cool, da es wie dynamisches Tippen aussieht , aber tatsächlich statisches Tippen ist - der Compiler erzwingt die korrekte Verwendung.

Der Typ Ihrer Variablen ist nicht wirklich so wichtig (dies wurde bereits gesagt). Es sollte relativ klar aus dem Kontext (seinen Interaktionen mit anderen Variablen und Methoden) und seinem Namen hervorgehen - erwarten Sie nicht, dass customerList eine int...

Ich warte immer noch darauf zu sehen, was mein Chef von dieser Angelegenheit hält - ich habe eine Decke bekommen, um neue Konstrukte in 3.5 zu verwenden, aber was werden wir gegen die Wartung tun?

In Ihrem Vergleich zwischen IEnumerable<int>und IEnumerable<double>Sie müssen sich keine Sorgen machen - wenn Sie den falschen Typ übergeben, wird Ihr Code sowieso nicht kompiliert.

Es gibt keine Sorge über Typsicherheit, da varist nicht dynamisch. Es ist nur Compiler-Magie und jede Art von unsicheren Aufrufen, die Sie tätigen, wird abgefangen.

Var wird für Linq unbedingt benötigt:

var anonEnumeration =
    from post in AllPosts()
    where post.Date > oldDate
    let author = GetAuthor( post.AuthorId )
    select new { 
        PostName = post.Name, 
        post.Date, 
        AuthorName = author.Name
    };

Schauen Sie sich nun anonEnumeration in Intellisense an und es wird ungefähr so ​​aussehenIEnumerable<'a>

foreach( var item in anonEnumeration ) 
{
    //VS knows the type
    item.PostName; //you'll get intellisense here

    //you still have type safety
    item.ItemId;   //will throw a compiler exception
}

Der C # -Compiler ist ziemlich clever - separat generierte Anontypen haben denselben generierten Typ, wenn ihre Eigenschaften übereinstimmen.

Abgesehen davon ist es sinnvoll, varüberall dort, wo der Kontext klar ist, zu verwenden, solange Sie Intellisense haben .

//less typing, this is good
var myList = new List<UnreasonablyLongClassName>();

//also good - I can't be mistaken on type
var anotherList = GetAllOfSomeItem();

//but not here - probably best to leave single value types declared
var decimalNum = 123.456m;

Ich denke, es hängt von Ihrer Perspektive ab. Ich persönlich hatte nie Schwierigkeiten, einen Code wegen var"Missbrauchs" zu verstehen , und meine Mitarbeiter und ich verwenden ihn überall ziemlich häufig. (Ich stimme zu, dass Intellisense in dieser Hinsicht eine große Hilfe ist.) Ich begrüße es als einen Weg, sich wiederholende Kruft zu entfernen.

Immerhin, wenn Aussagen wie

var index = 5; // this is supposed to be bad

var firstEligibleObject = FetchSomething(); // oh no what type is it
                                            // i am going to die if i don't know

Wäre es wirklich so unmöglich, damit umzugehen, würde niemand dynamisch getippte Sprachen verwenden.

Ich benutze var nur, wenn klar ist, welcher Typ verwendet wird.

Zum Beispiel würde ich in diesem Fall var verwenden, da Sie sofort sehen können, dass x vom Typ "MyClass" ist:

var x = new MyClass();

In solchen Fällen würde ich var NICHT verwenden, da Sie die Maus über den Code ziehen und in der QuickInfo nachsehen müssen, welcher Typ MyFunction zurückgibt:

var x = MyClass.MyFunction();

Insbesondere verwende ich var nie in Fällen, in denen die rechte Seite nicht einmal eine Methode ist, sondern nur ein Wert:

var x = 5;

(weil der Compiler nicht wissen kann, ob ich ein Byte, Short, Int oder was auch immer will)

Für mich zeigt die Abneigung gegen var, warum Zweisprachigkeit in .NET wichtig ist. Für diejenigen C # -Programmierer, die auch VB .NET ausgeführt haben, liegen die Vorteile von varintuitiv auf der Hand. Die Standard-C # -Deklaration von:

List<string> whatever = new List<string>();

entspricht in VB .NET der folgenden Eingabe:

Dim whatever As List(Of String) = New List(Of String)

In VB .NET macht das allerdings niemand. Es wäre dumm, denn seit der ersten Version von .NET können Sie dies tun ...

Dim whatever As New List(Of String)

... wodurch die Variable erstellt und alles in einer einigermaßen kompakten Zeile initialisiert wird. Ah, aber was ist, wenn Sie eine wollen IList<string>, keine List<string>? In VB .NET bedeutet dies, dass Sie Folgendes tun müssen:

Dim whatever As IList(Of String) = New List(Of String)

Genau wie Sie es in C # tun müssten und offensichtlich nicht verwenden könnten varfür:

IList<string> whatever = new List<string>();

Wenn Sie benötigen die Art , etwas anderes zu sein, kann es sein. Eines der Grundprinzipien einer guten Programmierung ist jedoch die Reduzierung der Redundanz, und genau das tut var.

Verwenden Sie es für anonyme Typen - dafür ist es da. Alles andere ist zu weit verbreitet. Wie viele Leute, die mit C aufgewachsen sind, bin ich es gewohnt, links in der Erklärung nach dem Typ zu suchen. Ich schaue nicht auf die rechte Seite, es sei denn, ich muss. Wenn varich für eine alte Erklärung verwende, mache ich das die ganze Zeit, was mir persönlich unangenehm ist.

Diejenigen, die sagen: "Es spielt keine Rolle, verwenden Sie, womit Sie zufrieden sind", sehen nicht das ganze Bild. Jeder wird irgendwann den Code anderer Leute aufgreifen und sich mit den Entscheidungen befassen müssen, die er zum Zeitpunkt des Schreibens getroffen hat. Es ist schon schlimm genug, sich mit radikal anderen Namenskonventionen oder - den klassischen Gripe - Bracing-Stilen auseinandersetzen zu müssen, ohne das Ganze ' varoder nicht' in die Mischung aufzunehmen. Der schlimmste Fall wird sein, wenn ein Programmierer nicht verwendet hat, varund dann kommt ein Betreuer, der es liebt, und erweitert den Code, der es verwendet. Jetzt hast du also ein unheiliges Durcheinander.

Standards sind eine gute Sache, gerade weil sie bedeuten, dass Sie mit viel größerer Wahrscheinlichkeit zufälligen Code erfassen und schnell verarbeiten können. Je mehr Dinge anders sind, desto schwieriger wird es. Und die Umstellung auf den Stil "überall überall" macht einen großen Unterschied Unterschied.

Es macht mir nichts aus, dynamisch zu tippen, und es macht mir nichts aus, das Tippen zu implizieren - in Sprachen, die für sie entwickelt wurden. Ich mag Python sehr. Aber C # wurde als statisch explizit typisierte Sprache entworfen und so sollte es auch bleiben. Die Regeln für anonyme Typen zu brechen war schon schlimm genug; Es ist etwas, mit dem ich nicht zufrieden bin, wenn die Leute das noch weiter gehen lassen und die Redewendungen der Sprache noch mehr brechen. Jetzt, wo der Geist aus der Flasche ist, wird er nie wieder hineingehen. C # wird in Lager balkanisiert. Nicht gut.

Während des Testens habe ich oft folgenden Code:

var something = myObject.SomeProperty.SomeOtherThing.CallMethod();
Console.WriteLine(something);

Jetzt möchte ich manchmal sehen, was SomeOtherThing selbst enthält. SomeOtherThing ist nicht derselbe Typ, den CallMethod () zurückgibt. Da ich var verwende, ändere ich Folgendes:

var something = myObject.SomeProperty.SomeOtherThing.CallMethod();

dazu:

var something = myObject.SomeProperty.SomeOtherThing;

Ohne var müsste ich auch den deklarierten Typ auf der linken Seite weiter ändern. Ich weiß, dass es geringfügig ist, aber es ist äußerst praktisch.

Für Liebhaber, die denken, dass sie varZeit sparen, sind weniger Tastenanschläge erforderlich, um Folgendes einzugeben :

StringBuilder sb = new StringBuilder();

als

var sb = new StringBuilder();

Zähle sie, wenn du mir nicht glaubst ...

19 gegen 21

Ich werde erklären, ob ich muss, aber versuchen Sie es einfach ... (Abhängig vom aktuellen Status Ihres Intellisense müssen Sie möglicherweise für jeden ein paar mehr eingeben.)

Und es gilt für jeden Typ, den Sie sich vorstellen können !!

Mein persönliches Gefühl ist, dass var niemals verwendet werden sollte, außer wenn der Typ nicht bekannt ist, da dies die Lesbarkeit der Erkennung im Code verringert. Das Gehirn braucht länger, um den Typ zu erkennen, als eine vollständige Linie. Oldtimer, die Maschinencode und Bits verstehen, wissen genau, wovon ich spreche. Das Gehirn arbeitet parallel und wenn Sie var verwenden, zwingen Sie es, seine Eingabe zu serialisieren. Warum sollte jemand sein Gehirn härter arbeiten lassen wollen? Dafür sind Computer da.

Ich teile var überall auf, die einzigen fragwürdigen Orte für mich sind interne Kurztypen, zB ziehe ich es int i = 3;vorvar i = 3;

Mit dem Code, den ich gestern geschrieben habe, kann es die Dinge sicherlich einfacher machen:

var content  = new Queue<Pair<Regex, Func<string, bool>>>();
...
foreach (var entry in content) { ... }

Dies wäre ohne sehr ausführlich gewesen var.

Nachtrag: Ein wenig Zeit mit einer Sprache mit realer Typinferenz (z. B. F #) zeigt, wie gut Compiler darin sind, die Art der Ausdrücke richtig zu machen. Es hat sicherlich bedeutet, dass ich dazu neige, varso viel wie möglich zu verwenden, und die Verwendung eines expliziten Typs zeigt jetzt an, dass die Variable nicht vom Typ des initialisierenden Ausdrucks ist.

Keine, außer dass Sie den Typnamen nicht zweimal schreiben müssen. http://msdn.microsoft.com/en-us/library/bb383973.aspx