Definire esplicitamente i tipi di dati variabili e utilizzare la parola chiave "var"? [chiuso]

C'è stata molta controversia sull'uso di var. Le mie regole generali sono le seguenti.

• Quando il tipo è ovvio, ad esempio quando la mano destra del compito è un costruttore, usa var.
• Quando il tipo è complesso da scrivere, come una query LINQ (il motivo per var in primo luogo) usa var.
• Per i tipi ambivalenti (il tuo decimale è un esempio) in cui vuoi assicurarti che la tua variabile sia stata digitata correttamente, spelling fuori.
• I tipi anonimi devono usare var.
• In tutti gli altri casi scrivi il tipo.

Fondamentalmente, l'obiettivo è rendere più semplice la lettura del codice. Se ritieni che la Var sia sufficiente perché l'assegnazione è ovvia, usa var. Usa il nome completo del tipo come suggerimento per il lettore quando ritieni sia necessario.

Quando usare var è una programmazione "guerra santa". C'è esattamente un posto dove è richiesto: quando il risultato di un'operazione crea un tipo anonimo, come ad esempio:

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

Ovunque, è facoltativo e dipende dallo standard di codifica da utilizzare o meno nelle altre situazioni.

E sì, avrete bisogno dei caratteri speciali per i letterali per consentire al compilatore di sapere di cosa si tratta sul lato destro. Nel tuo esempio, senza M , il valore predefinito è double anziché decimal .

Da MSDN :

However, the use of var does have at least the potential to make your code more difficult to understand for other developers. For that reason, the C# documentation generally uses var only when it is required.

Davvero, davvero non mi piace la digitazione implicita. In superficie tende a rendere il codice più leggibile, ma può portare a molti problemi lungo la strada. Se un dev cambia un inizializzatore di variabile, ad esempio da

var myFloat=100f;

a

var myFloat=100;

o

var myFloat=100.0;

Il tipo cambierà, causando un gran numero di errori del compilatore o, se si trova in una visualizzazione Web e non si sta utilizzando la fase post-compilazione per precompilare le visualizzazioni, un'intera serie di errori di runtime che non saranno catturato senza efficaci test di pre-distribuzione.

Anche la digitazione implicita non funziona ovunque (dallo stesso link MSDN)

var can only be used when a local variable is declared and initialized in the same statement; the variable cannot be initialized to null, or to a method group or an anonymous function.

var cannot be used on fields at class scope.

Variables declared by using var cannot be used in the initialization expression. In other words, this expression is legal: int i = (i = 20); but this expression produces a compile-time error: var i = (i = 20);

Multiple implicitly-typed variables cannot be initialized in the same statement.

If a type named var is in scope, then the var keyword will resolve to that type name and will not be treated as part of an implicitly typed local variable declaration.

Mantenere il tuo codice coerente (in questo caso, usare digitazioni esplicite ovunque) è una cosa molto, molto buona. Secondo me, var è pigro e non fornisce alcun vantaggio reale e introduce un altro potenziale punto di errore in un processo già complesso.

Aggiornamento 2017

Ho completamente cambiato idea. Quando lavoro in C #, uso var la maggior parte delle volte (eccetto cose come variabili di tipo interfaccia e simili). Mantiene il codice terso che migliora la leggibilità. Tuttavia, però, prestate attenzione a ciò che è realmente il tipo risolto.

Il riferimento C # mostra quanto segue per illustrare l'uso buono e cattivo di questo costrutto:

Il seguente esempio mostra due espressioni di query. Nella prima espressione, l'uso di var è consentito ma non è obbligatorio, poiché il tipo di risultato della query può essere dichiarato esplicitamente come un oggetto IEnumerable. Tuttavia, nella seconda espressione, var deve essere utilizzato perché il risultato è una raccolta di tipi anonimi e il nome di quel tipo non è accessibile tranne che per il compilatore stesso. Si noti che nell'esempio n. 2, anche l'elemento della variabile di iterazione foreach deve essere implicitamente digitato.

 // 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);
    }

La parola chiave var richiede solo al compilatore di dedurre automaticamente il tipo della variabile di tipo var. Quindi, se si desidera memorizzare una variabile di tipo decimale in una variabile var, è necessario utilizzare il m. Allo stesso modo, se stai memorizzando una stringa devi racchiuderla tra virgolette.

Per me non uso var per i seguenti casi:

• Quando voglio essere sicuro del tipo della mia variabile (per esempio per essere sicuro che il tipo usato sia doppio e non decimale, e questo è un grosso problema, credimi!)
• Codice polimorfico come Fruit foo = new Apple(); . In questo caso, penso che var è da evitare e usare la classe genitore (qui Fruit) è meglio permettendo una migliore comprensione della logica del codice e la limitazione dei probabili bug (con var, nessuna verifica del concetto polimorfico!)

Per il resto, penso che dipenda dal caso e dallo sfondo dello sviluppatore. Alcune persone del mondo PHP preferiranno non prendersi cura dei tipi di variabili, e alcune persone del mondo Java penseranno che var sia un'eresia e più verboso sia, meglio è.

Dovrai esprimere la tua opinione personale:)