Au-delà de l'utilisation évidente de var avec LINQ, je l'utilise aussi pour abréger les déclarations de variables poilues pour une meilleure lisibilité, par exemple:
var d = new Dictionary<string, Dictionary<string, Queue<SomeClass>>>();
En général, je reçois une sorte de confort (faute d'un meilleur mot) de typage statique qui me fait hésiter à l'abandonner. J'aime le sentiment que je sais ce que je fais quand je déclare une variable. Déclarer une variable n'est pas seulement dire quelque chose au compilateur, c'est dire à la personne qui lit votre code quelque chose. Laissez-moi vous donner un exemple.
Supposons que j'ai une méthode qui renvoie un List<string>. Ce code est certainement correct, et je pense qu'il est ainsi 90% des développeurs C# serait probablement écrire:
List<string> list = MyMethod();
De toute évidence, non? En fait, voici un endroit où vous pourriez tout aussi facilement utiliser var.
Assez vrai. Mais cette version du code est non seulement déclaration d'une variable, il me dit ce que la personne qui l'a écrit l'intention de faire:
IEnumerable<string> list = MyMethod();
Le développeur qui a écrit que le code me dit: « Je suis Je ne vais pas changer cette liste, je ne vais pas non plus utiliser un index pour accéder à ses membres, tout ce que je vais faire c'est de le parcourir. C'est beaucoup d'informations à transmettre dans une seule ligne de code. C'est quelque chose que vous abandonnez si vous utilisez var.
Bien sûr, vous n'abandonnez pas si vous ne l'utilisiez pas en premier lieu. Si vous êtes le genre de développeur qui écrirait cette ligne de code, vous savez déjà que vous n'utiliserez pas var là.
Edit:
Je viens de relire le poste de Jon Skeet, et cette citation d'Eric Lippert m'a sauté aux yeux:
habitants Implicitement typés ne sont qu'une petite façon dont vous pouvez deemphasize la comment et ainsi mettre l'accent sur le quoi.
Je pense que dans beaucoup de cas, en utilisant la typage implicite, on laisse ce qui est implicite. C'est juste de ne pas s'attarder sur le quoi. Par exemple, je vais avec désinvolture écrire une requête LINQ comme:
var rows = from DataRow r in parentRow.GetChildRows(myRelation)
where r.Field<bool>("Flag")
orderby r.Field<int>("SortKey")
select r;
Quand je lis ce code, l'une des choses que je pense quand je suis en train de lire, il est "rows est un IEnumerable<DataRow>.«Parce que je sais que ce que LINQ requêtes retour est IEnumerable<T>, et je peux voir le type de l'objet sélectionné là.
C'est un cas où la ce n'a pas été explicité. Il a été laissé pour moi .. pour en déduire
maintenant, dans environ 90% des cas où j'utiliser LINQ, cela n'a pas d'importance un petit peu parce que 90% du temps, la ligne de code suivante est:
foreach (DataRow r in rows)
Mais il n'est pas difficile d'imaginer un code dans lequel il serait très utile de déclarer rows comme IEnumerable<DataRow> - code où de nombreux types d'objets différents étaient interrogés, il n'était pas possible de placer la déclaration de requête à côté de l'itération, et il serait utile de pouvoir inspecter rows avec IntelliSense. Et c'est une chose, pas une chose.
Bonne question. – Contango