Cosa significa "var" in C #? [duplicare]

In C #, come funziona la parola chiave var?

Significa che il tipo di locale da dichiarare verrà dedotto dal compilatore:

// This statement:
var foo = "bar";
// Is equivalent to this statement:
string foo = "bar";

In particolare, varnon definisce una variabile di tipo dinamico. Quindi questo NON è legale:

var foo = "bar";
foo = 1; // Compiler error, the foo variable holds strings, not ints

var ha solo due usi:

1. Richiede meno battitura per dichiarare le variabili, specialmente quando si dichiara una variabile come tipo generico annidato.
2. Deve essere utilizzato quando si memorizza un riferimento a un oggetto di tipo anonimo, poiché il nome del tipo non può essere conosciuto in anticipo: var foo = new { Bar = "bar" };

Non puoi usare varcome tipo di qualcosa tranne i locali. Quindi non è possibile utilizzare la parola chiave varper dichiarare i tipi di campo / proprietà / parametro / restituiti.

Significa che il tipo di dati è derivato (implicito) dal contesto.

Da http://msdn.microsoft.com/en-us/library/bb383973.aspx

A partire da Visual C # 3.0, le variabili dichiarate nell'ambito del metodo possono avere un tipo implicito var. Una variabile locale tipizzata in modo implicito è fortemente tipizzata come se tu avessi dichiarato il tipo tu stesso, ma il compilatore determina il tipo. Le seguenti due dichiarazioni di i sono funzionalmente equivalenti:

var i = 10; // implicitly typed
int i = 10; //explicitly typed

var è utile per eliminare la digitazione sulla tastiera e il rumore visivo, ad es.

MyReallyReallyLongClassName x = new MyReallyReallyLongClassName();

diventa

var x = new MyReallyReallyLongClassName();

ma può essere abusato al punto da sacrificare la leggibilità.

"var" significa che il compilatore determinerà il tipo esplicito della variabile, in base all'utilizzo. Per esempio,

var myVar = new Connection();

ti darebbe una variabile di tipo Connection.

Dichiara un tipo in base a ciò che gli è stato assegnato nell'inizializzazione.

Un semplice esempio è che il codice:

var i = 53;

Esaminerà il tipo di 53 e sostanzialmente lo riscriverà come:

int i = 53;

Nota che mentre possiamo avere:

long i = 53;

Questo non accadrà con var. Anche se può con:

var i = 53l; // i is now a long

Allo stesso modo:

var i = null; // not allowed as type can't be inferred.
var j = (string) null; // allowed as the expression (string) null has both type and value.

Questa può essere una piccola comodità con tipi complicati. È più importante con i tipi anonimi:

var i = from x in SomeSource where x.Name.Length > 3 select new {x.ID, x.Name};
foreach(var j in i)
  Console.WriteLine(j.ID.ToString() + ":" + j.Name);

Qui non c'è altro modo per definire ie jutilizzare varpoiché non esiste un nome per i tipi che contengono.

Hai mai odiato scrivere tali inizializzatori di variabili?

XmlSerializer xmlSerializer = new XmlSerialzer(typeof(int))

Quindi, a partire da C # 3.0, puoi sostituirlo con

var xmlSerializer = new XmlSerialzer(typeof(int))

Un avviso: il tipo viene risolto durante la compilazione, quindi nessun problema con le prestazioni. Ma il compilatore dovrebbe essere in grado di rilevare il tipo durante la fase di compilazione, quindi il codice come var xmlSerializer;non verrà compilato affatto.

• Come suggerisce il nome, var è una variabile senza alcun tipo di dati.
• Se non sai quale tipo di dati verrà restituito da alcun metodo, questi casi sono utili per l'utilizzo di var.
• var è un tipo implicito, il che significa che il sistema definirà il tipo di dati stesso. Il compilatore ne dedurrà il tipo in base al valore a destra dell'operatore "=".
• int / string ecc. sono i tipi espliciti come definiti da te esplicitamente.
• Var può essere definita solo in un metodo come variabile locale
• Non è possibile dichiarare e inizializzare più variabili in una singola istruzione. Ad esempio, var i = 1, j = 2; è invalido.

int i = 100;// explicitly typed 
var j = 100; // implicitly typed

var è una "parola chiave contestuale" in C #, il che significa che puoi usarla solo come variabile locale implicitamente nel contesto della stessa classe in cui stai usando la variabile. Se provi a usarlo in una classe che chiami da "Main" o da qualche altra classe esterna, o un'interfaccia per esempio, otterrai l'errore CS0825 < https://docs.microsoft.com/en-us/dotnet/ csharp / misc / cs0825 >

Vedi le osservazioni su quando puoi e non puoi usarlo nella documentazione qui: < https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/implicitly-typed -local-variables # osservazioni >

Fondamentalmente, dovresti usarlo solo quando dichiari una variabile con un valore implicito come "var myValue =" Questo è il valore "; Ciò consente di risparmiare un po 'di tempo rispetto a dire" stringa "per esempio, ma IMHO non è molto tempo salvato e pone un vincolo alla scalabilità del tuo progetto.