it-swarm-eu.dev

Explicitní definice proměnných datových typů vs. použití klíčového slova „var“?

V C #, jsem vyzván, abych použil univerzální klíčové slovo var pro každé prohlášení o proměnné? Pokud ano, musím v následujícím prohlášení uvést tyto zvláštní znaky pro doslovné hodnoty v proměnné deklaraci, jako je M pro desetinné číslo:

var myDecimal = 14.5M;

Pokud to změní rozdíl, snažím se udělat nějaký vývoj webu s C #.

35
wassimans

O použití varu bylo mnoho sporů. Moje obecná pravidla jsou následující.

  • Pokud je typ zřejmý, například když je pravá ruka přiřazení konstruktorem, použijte var.
  • Pokud je typ zápisu složitý, například dotaz LINQ (na prvním místě důvod var), použijte var.
  • U ambivalentních typů (například desetinné číslo), kde se chcete ujistit, že je vaše proměnná správně zadána, ji vyhláskujte.
  • Anonymní typy musí používat var.
  • Ve všech ostatních případech uveďte typ.

Cílem je v zásadě usnadnit čtení kódu. Pokud máte pocit, že var postačuje, protože přiřazení je zřejmé, použijte var. Pokud máte pocit, že je to nutné, použijte jako nápovědu pro čtenáře celé jméno.

54
Michael Brown

Kdy použít var je programování „svaté války“. Tam, kde je to vyžadováno, je přesně jedno místo: když výsledek operace vytvoří anonymní typ, například:

var result = new { Name = "John", Age = 35 };

Kdekoli jinde, je to volitelné a opravdu podle vašeho kódovacího standardu, abyste jej mohli použít i v jiných situacích.

A ano, budete potřebovat speciální znaky pro literály, aby kompilátor věděl, co to je na pravé straně. Ve vašem příkladu bez M je výchozí hodnota double místo decimal.

14
Jesse C. Slicer

Z MSDN :

Použití varu však má přinejmenším potenciál k tomu, aby byl váš kód pro ostatní vývojáře obtížněji srozumitelný. Z tohoto důvodu dokumentace C # obecně používá var pouze tehdy, když je to vyžadováno.

Skutečně se mi nelíbí implicitní psaní. Na povrchu má tendenci zvyšovat srozumitelnost kódu, ale může vést k mnoha problémům po silnici. Pokud dev změní proměnný inicializátor, řekněme od

var myFloat=100f;

na

var myFloat=100;

nebo

var myFloat=100.0;

Typ se změní, což má za následek celou řadu chyb kompilátoru nebo, pokud je to ve webovém zobrazení a nepoužíváte krok po sestavení k předkompilaci svých zobrazení, celou řadu chyb runtime, které nebudou zachyceny bez efektivního testování před nasazením.

Implicitní psaní také nefunguje všude (od stejného odkazu MSDN)

var lze použít, pouze pokud je lokální proměnná deklarována a inicializována ve stejném příkazu; proměnnou nelze inicializovat na null nebo do skupiny metod nebo anonymní funkce.

var nelze použít na polích v rozsahu třídy.

Proměnné deklarované pomocí var nelze použít v inicializačním výrazu. Jinými slovy, tento výraz je legální: int i = (i = 20); ale tento výraz způsobuje chybu kompilace: var i = (i = 20);

Více implicitně zadaných proměnných nelze inicializovat ve stejném příkazu.

Pokud je typ pojmenovaný var v rozsahu, klíčové slovo var se převede na tento název typu a nebude s ním nakládáno jako s částí implicitně zadané deklarace místní proměnné.

Udržování konzistentního kódu (v tomto případě pomocí všude explicitního psaní) je velmi, velmi dobrá věc. Domnívám se, že var je líný a neposkytuje žádný skutečný přínos a představuje další potenciální bod selhání již tak složitého procesu.

Aktualizace 2017

Úplně jsem změnil názor. Když pracuji v C #, většinu času používám var (s výjimkou věcí, jako jsou proměnné typu rozhraní apod.). Udržuje napjatý kód, což zlepšuje čitelnost. Přesto však věnujte pozornost tomu, co je skutečně vyřešený typ.

7
3Dave

C # Reference ukazuje následující pro ilustraci dobrého vs. špatného použití tohoto konstruktu:

Následující příklad ukazuje dva výrazy dotazu. V prvním výrazu je použití varu povoleno, ale není vyžadováno, protože typ výsledku dotazu lze explicitně uvést jako IEnumerable. Ve druhém výrazu však musíte použít var, protože výsledkem je kolekce anonymních typů a název tohoto typu není přístupný kromě samotného kompilátoru. Všimněte si, že v příkladu č. 2 musí být implicitně zapsána proměnná položka iterace foreach.

 // Example #1: var is optional because 
    // the select clause specifies a string 
    string[] words = { "Apple", "strawberry", "grape", "Peach", "banana" };
    var wordQuery = from Word in words
                    where Word[0] == 'g'
                    select Word;

    // Because each element in the sequence is a string,  
    // not an anonymous type, var is optional here also. 
    foreach (string s in wordQuery)
    {
        Console.WriteLine(s);
    }

    // Example #2: var is required because 
    // the select clause specifies an anonymous type 
    var custQuery = from cust in customers
                    where cust.City == "Phoenix" 
                    select new { cust.Name, cust.Phone };

    // var must be used because each item  
    // in the sequence is an anonymous type 
    foreach (var item in custQuery)
    {
        Console.WriteLine("Name={0}, Phone={1}", item.Name, item.Phone);
    }
3

Klíčové slovo var vyžaduje pouze kompilátor, aby automaticky odvodil typ proměnné typu var. Pokud tedy chcete uložit proměnnou desítkového typu do proměnné var, musíte použít m. Stejně tak pokud ukládáte řetězec, musíte jej uzavřít do uvozovek.

0

Pro mě nepoužívám var v následujících případech:

  • Když si chci být jistý typem mé proměnné (například abych si byl jistý, že použitý typ je dvojitý a ne desetinný, a tohle je velká věc, věř mi!)
  • Polymorfní kód jako Fruit foo = new Apple();. V tomto případě si myslím, že var je vyhnout se a použití nadřazené třídy (zde Fruit) je lepší tím, že umožní lepší porozumění logice kódu a omezení pravděpodobných chyb (S varem, žádná kontrola polymorfního konceptu!)

Pokud jde o zbytek, myslím, že to závisí na případu a na pozadí vývojáře. Někteří lidé ze světa PHP svět bude raději nestarat se o typy proměnných a někteří lidé ze světa Java svět si budou myslet, že var je hereze a čím podrobnější je, tím lepší je.

Budete muset vyjádřit svůj osobní názor :)

0
eka808