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

In C #, sono incoraggiato a utilizzare la parola chiave var per tutti gli usi per ogni dichiarazione di variabile? Se sì, devo menzionare quei caratteri speciali per i valori letterali all'interno della dichiarazione della variabile come M per i decimali nella seguente istruzione:

var myDecimal = 14.5M;

Se fa la differenza, sto provando a fare un po 'di sviluppo web con C #.

Ci sono state molte controversie sull'uso di var. Le mie regole generali sono le seguenti.

• Quando il tipo è ovvio, ad esempio quando la mano destra dell'assegnazione è un costruttore, utilizzare var.
• Quando il tipo è complesso da scrivere, ad esempio una query LINQ (il motivo per cui var è in primo luogo) utilizzare var.
• Per i tipi ambivalenti (il tuo Decimale è un esempio) in cui vuoi assicurarti che la tua variabile sia digitata correttamente, spiegala.
• I tipi anonimi devono usare var.
• In tutti gli altri casi, precisare il tipo.

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

Quando usare varè una "guerra santa" di programmazione. Esiste esattamente un posto in cui è richiesto: quando il risultato di un'operazione crea un tipo anonimo, come:

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

In qualsiasi altro luogo, è facoltativo e veramente all'altezza del tuo standard di codifica usarlo o meno nelle altre situazioni.

E sì, avrai bisogno dei caratteri speciali per i letterali per far sapere al compilatore di cosa si tratta sul lato destro. Nel tuo esempio, senza il M, il valore predefinito è doublepiuttosto che decimal.

Da MSDN :

Tuttavia, l'uso di var ha almeno il potenziale per rendere il tuo codice più difficile da capire per altri sviluppatori. Per questa ragione, la documentazione C # usa generalmente var solo quando è richiesta.

Non mi piace davvero, la digitazione implicita. In superficie tende a rendere il codice più leggibile, ma può portare a molti problemi lungo la strada. Se uno sviluppatore cambia un inizializzatore variabile, diciamo, da

var myFloat=100f;

a

var myFloat=100;

o

var myFloat=100.0;

Il tipo cambierà, causando tutta una serie di errori del compilatore o, se è in una visualizzazione Web e non si sta utilizzando il passaggio post-build per precompilare le visualizzazioni, tutta una serie di errori di runtime che non verranno rilevati senza efficacia test pre-implementazione.

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

var può essere utilizzato solo quando una variabile locale viene dichiarata e inizializzata nella stessa istruzione; la variabile non può essere inizializzata su null, su un gruppo di metodi o su una funzione anonima.

var non può essere utilizzato su campi nell'ambito della classe.

Le variabili dichiarate utilizzando var non possono essere utilizzate nell'espressione di inizializzazione. In altre parole, questa espressione è legale: int i = (i = 20); ma questa espressione produce un errore in fase di compilazione: var i = (i = 20);

Più variabili tipizzate implicitamente non possono essere inizializzate nella stessa istruzione.

Se un tipo denominato var è nell'ambito, la parola chiave var si risolverà in quel nome di tipo e non verrà trattata come parte di una dichiarazione di variabile locale tipizzata in modo implicito.

Mantenere il codice coerente (in questo caso, usando la digitazione esplicita ovunque) è una cosa molto, molto buona. A mio avviso, varè pigro e non offre 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 la varmaggior parte del tempo (tranne cose come variabili di tipo interfaccia e simili). Mantiene il codice conciso che migliora la leggibilità. Tuttavia, presta attenzione a ciò che è realmente il tipo risolto.

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

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

 // 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 var type. Quindi, se si desidera memorizzare una variabile di tipo decimale in una variabile var, è necessario utilizzare 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 (ad esempio per essere sicuro che il tipo utilizzato sia doppio e non decimale, e questo è un grosso problema, fidati di me!)
• Codice polimorfico come Fruit foo = new Apple();. In questo caso, penso che var sia da evitare e l'uso della classe genitore (qui Fruit) è migliore consentendo una migliore comprensione della logica del codice e la limitazione dei probabili bug (Con var, nessun controllo 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 variabili, e alcune persone del mondo Java penseranno semplicemente che var è un'eresia e più è prolisso, meglio è.

Dovrai esprimere la tua opinione personale :)