Quali sono i vantaggi di tipizzazione implicita in C # 3.0> +

Question

L'unico vantaggio che posso vedere da fare:

var s = new ClassA();

su

ClassA s = new ClassA();

È che in seguito, se si decide ClassB, dovete solo cambiare la RHS della dichiarazione.

Credo che se si sta enumerazione di un insieme si può anche solo a 'var' e quindi capire il tipo più tardi.

È così ?? C'è qualche altro enorme vantaggio mia mente debole non vede?

Answer 1

E 'per lo più zucchero sintattico. E 'davvero la vostra preferenza. A meno che quando si usano i tipi anonimi, quindi utilizzando var è necessaria. Io preferisco tipizzazione implicita per quanto possibile, però, brilla davvero con LINQ.

Trovo ridondante di digitare un tipo di due volte.

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

Quando posso facilmente basta digitare var quando è evidente ciò che il tipo è.

var Foo = new List<string>();

Answer 2

var è utile per i tipi anonimi, che non hanno i nomi per l'uso.

var point = new {X = 10, Y = 10};

Questo creerà un tipo anonimo con proprietà X e Y. E 'utilizzato principalmente per supportare LINQ però. Supponiamo di avere:

class Person
{
    public String Name {get; set;}
    public Int32 Age {get; set;}
    public String Address {get; set;}
    // Many other fields
}

List<Person> people; // Some list of people

Ora supponiamo che io voglio selezionare solo i nomi e gli anni fino all'età 18 di quelle persone che sono sotto l'età di 18:

var minors = from person in people where person.Age < 18 select new {Name = person.Name, YearsLeft = 18 - person.Age};

Ora minors contiene una List di qualche tipo anonimo. Siamo in grado di iterare quelle persone con:

foreach (var minor in minors)
{
    Console.WriteLine("{0} is {1} years away from age 18!", minor.Name, minor.YearsLeft);
}

Niente di tutto questo sarebbe altrimenti possibile; avremmo bisogno di selezionare l'oggetto persona intera e quindi calcolare YearsLeft nel nostro circuito, che non è quello che vogliamo.

Answer 3

ho iniziato quello che si rivelò essere un filo estremamente controverso quando ho firmato qui (la mia scelta di "malvagità" per descrivere l'uso generale del Var era ovviamente una scelta terribile.) Inutile dire che ho più apprezzamento per var di quanto ho fatto prima ho iniziato quel filo, così come una migliore comprensione di come esso può essere utilizzato utilmente:

la malvagità del 'var' in C #?

Alcuni buoni motivi per utilizzare var:

• La brevità
• Riduzione della ripetizione (DRY)
• sforzo refactoring ridotto
• Supporta i tipi anonimi (motivo principale è stato aggiunto al C #)

Answer 4

Date un'occhiata a questa domanda. Forse ti aiutano a decidere.

L'uso della parola chiave var in C #
https://stackoverflow.com/questions/633474/c-do-you-use-var

Answer 5

Mi permette di non ripetermi inutili. Considerate questo:

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

Abbiamo una lunga typename ripetuto due volte sulla stessa linea due volte senza alcun beneficio. Inoltre, se hai bisogno di refactoring questo, è necessario aggiornare il tipo di due volte. Considerando che la presente è altrettanto espressiva:

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

Non c'è ancora alcun dubbio circa il tipo di dict qui, ma il codice è più breve, e vorrei sostengono che è più facile da leggere pure.

Answer 6

In realtà "var" in C # è usato per trattare con tipo anonimo.

Come:

var t = new {number = 10, name = "test"};

Answer 7

La ragione generale per la tipizzazione implicita era quello di sostenere i tipi anonimi, come quelli prodotti da query LINQ. Possono anche essere un grande vantaggio quando si tratta di farmaci generici complessi tipizzato ... qualcosa come Dictionary<int,List<string>>. Questo non è troppo complesso, ma immaginate enumerando ...

foreach KeyValuePair<int,List<string>> pair in myDictionary
{

}

è semplificato con tipizzazione implicita.

Answer 8

Mentre la parola chiave var è stato principalmente introdotto per supportare i tipi anonimi, l'argomento principale che ho visto per il suo utilizzo è più ampiamente per brevità / codice più leggibile, più il montaggio di più sulla linea di codice:

Dictionary<string, double> data = new Dictionary<string, double>();
versus
var data = new Dictionary<string, double>();

Anche se non è una buona ragione per la maggior parte delle persone, mi piace anche la parola chiave var come programmatore cieco, mentre ascolto il codice in fase di lettura e quindi qui il nome della variabile dopo un solo syllabul: -)