Utiliser des variables locales implicitement typées

Je viens d’installer une version d’évaluation de ReSharper et l’une des premières choses que j’ai remarquées est qu’elle suggère toujours de remplacer les variables locales explicitement typées par des variables implicitement typées, par exemple:

public ssortingng SomeMethod(int aParam) { int aNumber = SomeOtherMethod(aParam); // should be changed to: var aNumber = SomeOtherMethod(aParam); } 

Je pense que les variables typées explicitement sont plus lisibles (plus explicites).

Que pensez-vous de la suggestion de ReSharper? Y a-t-il un avantage à utiliser des variables implicitement typées? Quand utilisez-vous des vars implicites / explicites?

    Personnellement, j’utilise uniquement «var» quand je peux clairement distinguer la variable Type en lisant simplement la déclaration, par exemple:

     var someVariable = new List(); 

    Dans l’exemple ci-dessus, il est évident que «var» fait référence à «List ».

    Je n’aime pas utiliser «var» quand je dois aller à une définition de méthode pour savoir quel type de variable «var» représente ou en ayant besoin de faire appel à visual studio intelli-popup ou à ce que l’on appelle, par exemple pas d’accord pour moi:

     var someVaraible = SomeMethod(); 

    Je veux dire, quelle est la fonction «SomeMethod» censée revenir? Pouvez-vous dire simplement en regardant la ligne de code? Non, vous ne pouvez pas, c’est pourquoi j’évite d’utiliser «var» dans ces situations.

    Il y a beaucoup de discussions à ce sujet, mais je pense que tout se résume à des goûts personnels, tout comme l’utilisation du mot-clé «this» presque partout.

    Personnellement, je préfère les variables explicitement typées, mais lorsque vous utilisez des collections génériques nestedes, les choses peuvent devenir plus lisibles en utilisant une variable implicitement typée. Regarder:

     Dictionary> myDictionary = new Dictionary>(); 

    contre:

     var myDictionary = new Dictionary>(); 

    EDIT: ce sujet SO couvre le même sujet, avec quelques bonnes réponses: Que faire: var ou type de nom d’object?

    EDIT2: Travaillant beaucoup avec l’async de nos jours, je trouve que l’utilisation de variables typées de manière explicite peut parfois empêcher les bogues méchants. Considérez cet exemple idiot où vous voudriez renvoyer l’ID d’un utilisateur. Considérez également que GetUserAsync renvoie une Task . Si vous utilisez des variables implicitement tapées, vous finirez par utiliser quelque chose comme ceci:

     public long GetUserId() { var user = GetUserAsync(); return user.Id; } 

    Cela comstack, mais c’est faux. “utilisateur” est en fait une Task . Et il comstack comme Task également une propriété Id . Dans ce cas, on renverrait accidentellement l’id d’une tâche au lieu de l’utilisateur.

     public long GetUserId() { User user = GetUserAsync(); return user.Id; } 

    Ce qui précède ne comstack pas, car le compilateur se plaindra que vous ne pouvez pas diffuser une tâche à un utilisateur. Ajouter le mot-clé wait bien sûr résout ce problème.

    En fait, cela m’est arrivé une fois 🙂

    Juste au cas où certains n’auraient pas encore remarqué, vous pouvez facilement modifier les «suggestions» dans Reshaper (Reshaper -> Options -> Languages ​​-> Actions de contexte -> «Remplacer la spécification de type explicite par« var »»).

    Personnellement, je préfère avoir des spécifications de type explicites partout, mais je ne suis pas trop pointilleux à ce sujet.

    Il est juste plus facile de taper le pseudo-mot clé var que parfois un nom de type énorme, surtout si un générique peut être impliqué. Cependant, vous devez savoir qu’ils sont fonctionnellement identiques. Il n’y a pas de différence de performance ou quoi que ce soit d’autre. Le compilateur dérive le type du côté droit de l’affectation et remplace var par ce type. Cela ne se produit pas à l’exécution comme une variante de VB.

    FWIW, le mot-clé var est clairement lisible dans de nombreux cas. En particulier si…

    1. Le côté droit de l’affectation est une expression de constructeur.

      var map = new Dictionary> ();

    2. Les variables locales ont de bons noms.

    HTH