Que signifie «var» en C #? [dupliquer]

En C #, comment fonctionne le mot clé var?

Cela signifie que le type du local déclaré sera déduit par le compilateur:

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

Notamment, varne définit pas une variable comme étant de type dynamique. Donc ce n'est PAS légal:

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

var n'a que deux utilisations:

1. Il nécessite moins de typage pour déclarer des variables, en particulier lors de la déclaration d'une variable en tant que type générique imbriqué.
2. Il doit être utilisé lors du stockage d'une référence à un objet de type anonyme, car le nom du type ne peut pas être connu à l'avance: var foo = new { Bar = "bar" };

Vous ne pouvez pas utiliser varcomme type de quoi que ce soit, sauf des locaux. Vous ne pouvez donc pas utiliser le mot-clé varpour déclarer des types champ / propriété / paramètre / retour.

Cela signifie que le type de données est dérivé (implicite) du contexte.

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

À partir de Visual C # 3.0, les variables déclarées à la portée de la méthode peuvent avoir un type implicite var. Une variable locale typée implicitement est fortement typée comme si vous aviez déclaré le type vous-même, mais le compilateur détermine le type. Les deux déclarations suivantes de i sont fonctionnellement équivalentes:

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

var est utile pour éliminer la frappe au clavier et le bruit visuel, par exemple,

MyReallyReallyLongClassName x = new MyReallyReallyLongClassName();

devient

var x = new MyReallyReallyLongClassName();

mais peut être surutilisé au point où la lisibilité est sacrifiée.

"var" signifie que le compilateur déterminera le type explicite de la variable, en fonction de son utilisation. Par exemple,

var myVar = new Connection();

vous donnerait une variable de type Connection.

Il déclare un type basé sur ce qui lui est assigné lors de l'initialisation.

Un exemple simple est que le code:

var i = 53;

Examinera le type de 53 et le réécrira essentiellement comme suit:

int i = 53;

Notez que bien que nous puissions avoir:

long i = 53;

Cela n'arrivera pas avec var. Bien que cela puisse avec:

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

De même:

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.

Cela peut être une commodité mineure avec des types compliqués. C'est plus important avec les types anonymes:

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

Ici, il n'y a pas d'autre moyen de définir iet jd'utiliser varque car il n'y a pas de nom pour les types qu'ils contiennent.

Avez-vous déjà détesté écrire de tels initialiseurs de variables?

XmlSerializer xmlSerializer = new XmlSerialzer(typeof(int))

Donc, à partir de C # 3.0, vous pouvez le remplacer par

var xmlSerializer = new XmlSerialzer(typeof(int))

Un avis: le type est résolu lors de la compilation, donc aucun problème de performances. Mais le compilateur devrait être capable de détecter le type lors de l'étape de construction, donc le code comme var xmlSerializer;ne se compilera pas du tout.

• Comme son nom l'indique, var est une variable sans aucun type de données.
• Si vous ne savez pas quel type de données sera retourné par une méthode, de tels cas conviennent à l'utilisation de var.
• var est un type implicite, ce qui signifie que le système définira le type de données lui-même. Le compilateur déduit son type en fonction de la valeur à droite de l'opérateur "=".
• int / string etc. sont les types explicites tels qu'ils sont définis explicitement par vous.
• Var ne peut être défini dans une méthode qu'en tant que variable locale
• Plusieurs variables ne peuvent pas être déclarées et initialisées dans une seule instruction. Par exemple, var i = 1, j = 2; est invalide.

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

var est un "mot clé contextuel" en C #, ce qui signifie que vous ne pouvez l'utiliser que comme variable locale implicitement dans le contexte de la même classe que vous utilisez la variable. Si vous essayez de l'utiliser dans une classe que vous appelez depuis "Main" ou une autre classe extérieure, ou une interface par exemple, vous obtiendrez l'erreur CS0825 < https://docs.microsoft.com/en-us/dotnet/ csharp / misc / cs0825 >

Consultez les remarques sur les cas où vous pouvez et ne pouvez pas l'utiliser dans la documentation ici: < https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/implicitly-typed -local-variables # remarques >

Fondamentalement, vous ne devriez utiliser cela que lorsque vous déclarez une variable avec une valeur implicite telle que "var myValue =" Ceci est la valeur "; Cela permet de gagner un peu de temps par rapport à dire" chaîne "par exemple, mais à mon humble avis, peu de temps est enregistré et impose une contrainte sur l'évolutivité de votre projet.