Quel est l'intérêt du mot-clé var ?

Question

En var supprime la nécessité d'une déclaration de type explicite et j'ai lu avec intérêt le document intitulé Discussion sur le SO de quand cela pourrait être approprié.

J'ai également lu sur (mais pas utilisé) Boo qui semble aller encore plus loin en faisant en sorte que facultatif pour déclarer une variable locale . Avec Boo, le type et la déclaration peuvent être implicites.

Ce qui m'amène à me demander pourquoi les concepteurs du langage C# ont pris la peine d'inclure un mot-clé var ?

Mise à jour : Oui, var supporte les types anonymes, mais les types anonymes en eux-mêmes ne nécessitent pas le mot-clé var...

var anon = new { Name = "Terry", Age = 34 };

contre

anon = new { Name = "Terry", Age = 34 };

Answer 1

Sans le mot-clé var, il devient possible de créer accidentellement une nouvelle variable alors que vous aviez en fait l'intention d'utiliser une variable déjà existante, par ex.

name = "fred";
   ...
Name = "barney"; // whoops! we meant to reuse name

Answer 2

Mise à jour : Il y a deux questions connexes ici, en fait : 1. Pourquoi dois-je déclarer des variables ? 2. Quelle est l'utilité de "var" dans un langage qui vous oblige à déclarer des variables ?

Les réponses à (1) sont nombreuses, et peuvent être trouvées ailleurs pour cette question. Ma réponse à (2) est ci-dessous :

Comme l'ont dit d'autres commentateurs, LINQ utilise cela pour ses types anonymes. Cependant, LINQ est en fait une instance d'un problème plus général où le type du côté droit d'une expression est soit inconnu du programmeur, soit extrêmement verbeux. Pensez-y :

SomeGeneric<VeryLongTypename<NestedTypename>> thing = new   
SomeGeneric<VeryLongTypename<NestedTypename>>();

Verbeux et source d'erreurs, non ? Donc maintenant ils vous laissent faire ça :

var thing = new SomeGeneric<VeryLongTypename<NestedTypename>>();

En réduisant la duplication des informations, les erreurs sont éliminées. Notez qu'il ne s'agit pas seulement d'erreurs de frappe : il est possible que le type de l'expression de gauche soit mal saisi de telle sorte que le compilateur puisse effectuer un cast silencieux de gauche à droite, mais le cast perd en fait une propriété de la rvalue. Ceci est encore plus important lorsque les types renvoyés par la rvalue peuvent être inconnus ou anonymes.

Answer 3

Je comprends la nécessité du var et il remplit parfaitement son rôle. Ne pas avoir de mot-clé et définir des variables à la volée sans type est effrayant. Vous blessez le prochain gars qui doit maintenir votre code ou vous-même si vous devez retravailler le code que vous n'avez pas touché depuis plus d'un an. Je ne suis pas sûr que ce soit une porte à ouvrir en C# et j'espère qu'elle ne le sera pas car var cause déjà des problèmes de lisibilité lorsqu'il est surutilisé alors qu'il n'est pas nécessaire.

Presque tous les exemples .net 3.5 que je vois ces derniers temps ont toutes les variables définies avec var.

L'argument que j'avance est qu'il sacrifie vraiment la lisibilité au nom de l'économie de frappe lorsqu'il est surutilisé. Par exemple :

// What myVar is, is obvious
SomeObject myVar = new SomeObject();

// What myVar is, is obvious here as well
var myVar = new SomeObject();

Le problème que je vois est que les gens l'utilisent partout... par exemple :

// WTF is var without really knowing what GetData() returns?
// Now the var shortcut is making me look somewhere else when this should
// just be readable!
var myVar = GetData();

// If the developer would have just done it explicitly it would actually
// be easily readable.
SomeObject myVar = GetData();

Donc le prochain argument sera, il suffit de mieux nommer la fonction...

var weight = GetExactWeightOfTheBrownYakInKilograms();

On ne sait toujours pas ce qui va revenir. Est-ce un int, un décimal, un float, un objet de poids, quoi ? Je dois toujours perdre du temps à le chercher... j'ai besoin de la béquille intellisense pour sauver la journée de ma programmation paresseuse. Peut-être inclure le type de retour dans le nom de la fonction. Bonne idée, maintenant l'utilisation de var ne nous a rien épargné à part le fait que toutes mes fonctions ont des noms vraiment longs.

Je pense que les gens utilisent trop de var et que cela conduit à une programmation paresseuse qui, à son tour, conduit à un code plus difficile à lire. Chaque fois que vous tapez le mot clé var, vous devriez avoir une bonne raison de l'utiliser au lieu d'être explicite.

Answer 4

C'est un peu subjectif, mais je pense que le fait d'avoir conçu C# 3.0 pour avoir le mot-clé "var" pour les variables implicitement typées au lieu de ne pas avoir de mot-clé rend le code plus lisible. Par exemple, le premier bloc de code ci-dessous est plus lisible que le second :

Évident où la variable est déclarée :

var myVariable = SomeCodeToSetVariableHere;
myVariable = SomeOtherCodeTOSetVariable;

L'endroit où la variable est déclarée n'est pas évident :

myVariable = SomeCodeToSetVariableHere;
myVariable = SomeOtherCodeTOSetVariable;

Ces exemples sont trop simplistes. Je pense que vous pouvez voir où cela mène. Dans des situations complexes, il peut être intéressant de pouvoir trouver l'endroit où une variable est réellement définie.

Answer 5

Dans votre question, var ajoute de la valeur au code en indiquant au compilateur le mot anon peut désormais être utilisé partout où l'on s'attendrait à voir un élément du type impliqué dans l'affectation. Le fait d'exiger l'introduction de noms dans le compilateur de cette manière permet à ce dernier de rejeter les choses qui ne lui ont pas été explicitement indiquées comme étant autorisées, et donc de détecter certains types d'erreurs au moment de la compilation afin qu'elles n'explosent pas au moment de l'exécution.

Par exemple, dans la section "mise à jour" de votre question, vous avez posé une question sur cet extrait :

anon = new { Name = "Terry", Age = 34 };

Le problème est que cela transforme tout ce qui se trouve à gauche d'une affectation où le nom n'existait pas auparavant en une déclaration de variable, même s'il s'agit d'une erreur de frappe. Si, plus tard dans le programme, vous assignez quelque chose d'autre à anon et que, plus loin encore, vous faites référence à la nouvelle valeur, mais que la déclaration du milieu comportait une faute de frappe, vous avez un problème qui n'apparaîtra qu'au moment de l'exécution.

Votre réponse est que Boo le fait, donc ça doit être bien ou au moins possible. Mais c'est un faux-fuyant. Nous parlons de C#, pas de Boo. L'un des objectifs de C# est d'avoir un langage où le compilateur peut attraper autant d'erreurs que possible. Boo veut faire cela, aussi, mais il veut aussi être plus comme Python. Il sacrifie donc algunos (pas tous) de la sécurité de compilation de C# en échange d'une syntaxe de type python.