it-swarm.it

Definizione esplicita di tipi di dati variabili rispetto all'uso della parola chiave "var"?

In C #, sono incoraggiato a usare 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 #.

35
wassimans

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.

54
Michael Brown

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 utilizzarlo 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 M, il valore predefinito è double anziché decimal.

14
Jesse C. Slicer

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;

per

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, un'intera 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 var il più delle volte (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.

7
3Dave

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 variabile foreach iteration deve essere tipizzato 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);
    }
3

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.

0

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 che var sia un'eresia e il più è prolisso, meglio è.

Dovrai esprimere la tua opinione personale :)

0
eka808