Uso eccessivo di var in C # [duplicato]

Question

Uso eccessivo di var in C # [duplicato]

Naviga le tue risposte

#1 da (7 voti)
#2 da (2 voti)

2

Con l'introduzione dei tipi anonimi in C # abbiamo ottenuto la parola chiave var .

Ora le persone usano var ovunque anziché il tipo corretto. I motivi che ho sentito per questo sono:

Rende più facile il refactoring
È più breve
migliora la leggibilità

Un esempio comune potrebbe essere

var result = client.GetResult(query);

è migliore di:

MyObject result = client.GetResult(query);

Perché se si refactoring GetResult per restituire un oggetto diverso; ad esempio:

MyOtherObject result = client.GetResult(query);

non è necessario anche rifattorizzare il codice chiamante.

Tuttavia, di recente ho dovuto eseguire il seguente refactoring

IEnumerable<MyObject> GetResult(query)

a

Task<List<MyObject>> GetResult(query)

Il codice chiamante era lungo le linee di

//return true if there are any results
var result = client.GetResult(query);
if(result != null)
{
    return true;
}
return false;

Che dopo il refactoring sarebbe ancora compilato e restituire sempre true. Mentre il modulo tipizzato esplicitamente avrebbe generato un errore di compilazione.

. La domanda è. Dato che ci sono degli svantaggi nell'usare var al posto della variabile tipizzata esplicitamente. È semplicemente un caso di preferenza per lo stile di codifica, o ci sono chiare ragioni per usare o non usare var in questo modo? (ad es. se richiesto con tipi anonimi)

c# coding-standards

posta Ewan 22.08.2016 - 10:28

fonte

2 risposte

Leggi altre domande sui tag c# coding-standards

Come fornire un oggetto ubiquitario senza includerlo in ogni elenco di parametri Le migliori pratiche per ordinare, quindi invertire, o scrivere il comparatore "all'indietro"?

score 7 · Answer 1

FWIW Trovo che var sia sovrautilizzato. Ciò non significa che non dovrebbe essere usato però. Questi sono gli standard che utilizziamo sul mio posto di lavoro.

Usa var quando il tipo è ovvio.
```
var foo = new Foo();
```
Non utilizzare var quando il tipo di reso non è evidente.
```
Foo foo = service.GetItem();
```
Non utilizzare var quando il metodo restituisce un tipo concreto.
```
ICollection<Foo> items = new List<Foo>();
```

score 2 · Answer 2

Come già detto, l'uso di var è totalmente facoltativo (a parte la dichiarazione di tipo anonimo). È solo una preferenza di stile di codifica.

Vorrei utilizzare la dichiarazione del tipo esplicito quando si assegna il valore da una funzione. Ma è solo per la leggibilità, non per il vantaggio se e quando la funzione di chiamata verrà refactored.

L'esempio riportato è davvero negativo. Di solito eseguiremmo un'operazione sull'oggetto restituito. Se ci fossero alcune operazioni eseguite sull'oggetto restituito da client.GetResult , sicuramente ci sarebbe un errore di compilazione.

Normalmente non restituiamo true o false dopo aver controllato nulla. La funzione chiamata può benissimo restituire true / false stessa.
Oppure, dato che il valore di ritorno prima del refactoring era IEnumerable<MyObject> la funzione client.GetResult avrebbe potuto restituire una lista vuota ( modello oggetto Null? ) invece di null .... solo dicendo ..