Pourquoi ReSharper veut-il utiliser " var " pour tout?

ce que ReSharper suggère est clairement une surutilisation du mot-clé var. Vous pouvez l'utiliser lorsque le type est évident:

var obj = new SomeObject();

Si le type n'est pas évident, vous devriez plutôt écrire:

SomeObject obj = DB.SomeClass.GetObject(42);

personnellement, je préfère désactiver cette suggestion. L'utilisation de var peut souvent améliorer la lisibilité, mais comme vous l'avez mentionné, il réduit parfois (avec des types simples, ou lorsque le type résultant est obscur ).

je préfère choisir quand j'utilise var et quand je ne le fais pas. Mais encore une fois, ce n'est que moi.

var peut augmenter la lisibilité du code tout en diminuant la compréhension immédiate du code. De même, cela peut diminuer la lisibilité du code pour d'autres situations. Parfois, l'utilisation de l'informatique est neutre. La mesure de la lisibilité à la compréhension n'est pas proportionnelle mais dépend de la situation. Parfois les deux sont augmentées ou diminuées ensemble.

le facteur est ce que var est appliqué à et la façon dont la cible soutient immédiat l'obscurcissement de son type de données au lecteur, ou si son type d'info est nécessaire pour comprendre le programme à portée de main.

par exemple, un mauvais nom peut conduire à var causant une diminution de la compréhension du code. Ce n'est pas la faute de var :

var value1 = GetNotObviousValue(); //What's the data type? 
//vs. 
var value2 = Math.Abs(-3); // Obviously a numeric data type. 

parfois, il n'est pas logique d'utiliser var pour des types de données simples lorsque le code est plus lisible en son absence:

var num = GetNumber(); // But what type of number?
// vs. 
double num = GetNumber(); // I see, it's a double type. 

Parfois var peut être utile pour cacher des informations de type de données que vous ne vous souciez pas nécessairement de voir les complexités de:

    IEnumerable<KeyValuePair<string,List<Dictionary<int,bool>>>> q = from t in d where t.Key == null select t; // OMG! 
    //vs. 
    var q = from t in d where t.Key == null select t;

    // I simply want the first string, so the last version seems fine.  
    q.First().Key; 

Vous doit utiliser var quand il y a un type anonyme présente, car il n'y a pas de type de nom pour l'appeler par:

var o = new { Num=3, Name="" };

lorsque vous avez Visual Studio Intellisense fournir des informations de type en dépit de var , vous devez alors moins compter sur votre compréhension par une lecture stricte du code sans aide. Il est probablement sage de supposer que tout le monde n'a pas ou N'utilise pas Intellisense.

en résumé d'après les exemples ci-dessus, je dirais que l'application carte blanche de var n'est pas une bonne idée parce que la plupart des choses sont à faire avec modération et en se basant sur les circonstances telles qu'indiquées ici.

pourquoi Resharper l'utilise - t-il par défaut? Je suggère pour la facilité, parce que cela Je ne peux pas analyser les nuances des situations pour décider quand il vaut mieux ne pas l'utiliser.

dans ReSharper (8.02, mais probablement d'autres versions), l'option pour la suggestion "déclaration de variable locale d'utilisation implicitement dactylographiée" peut être ajustée à votre préférence , quelle qu'elle soit, en ouvrant d'abord le menu options pour ReSharper:

puis, sous "inspection de Code" en ajustant la "sévérité de L'Inspection" de votre langue choisie, dans mon cas c#:

comme vous pouvez le voir, Il ya des options pour ajuster toutes les suggestions que ReSharper fait. Espère que cela aide quelqu'un comme moi qui a déjà une stratégie d'utilisation 'var' et veut juste ReSharper pour le respecter:)

je suis surpris que personne n'a mentionné qu'il est aussi plus facile de changer le type de l'objet instancié, parce que

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

est une forme de répétition . Si je veux changer AVeryLongTypeName en une de ses classes dérivées, Je n'ai besoin de changer cela qu'une fois en utilisant var et peut encore accéder aux méthodes des classes enfants.

outre cela, l'amélioration de la lisibilité est un point important, mais comme d'autres ont dit, var ne devrait pas être surutilisé, donc je pense qu'éteindre l'allusion dans Resharper est tout à fait correct.

'var' est sur d'être clair

le principal débat sur l'utilisation du mot-clé var ou non est sur la façon dont le code est lisible pour vous et d'autres développeurs.

comme si vous écriviez une histoire, il n'y a pas de bonne réponse définitive. Mais regardons quelques exemples de cela dans un anglais simple.

Jake dit bonjour à Bill. Il n'a pas, comme lui, donc il se tourna et est allé dans l'autre sens.

qui est allé de l'autre côté? Jake ou le projet de Loi? Dans ce cas, utiliser les noms "Jake" et "Bill" est comme utiliser le nom de type. Et "il" et "lui" c'est comme utiliser le mot-clé var . Dans ce cas, il pourrait aider à être plus précis. Par exemple, ce qui suit est beaucoup plus clair.

Jake dit bonjour à Bill. Jake n'aimait pas Bill alors il s'est tourné et est allé dans l'autre sens.

dans ce cas étant plus spécifique a rendu la phrase plus claire. Mais ce n'est pas toujours le cas. Dans certains cas, le fait d'être précis rend la lecture plus difficile.

Bill aime les livres, donc Bill est allé à la bibliothèque et Bill a sorti un livre que Bill a toujours aimé.

dans ce cas, il serait plus facile de lire la phrase si nous utilisions "il" et dans certains cas, en laissant de côté son nom, ce qui est l'équivalent d'utiliser le mot-clé var .

Bill aime les livres, donc il est allé à la bibliothèque et prit un livre qu'il a toujours aimé.

Ces exemples couvrent l'essentiel, mais ils ne disent pas toute l'histoire. Dans ces exemples, il n'y avait qu'une façon de désigner la personne. Soit en utilisant son nom ou en utilisant un terme plus général comme "il" et "lui".

dans le cas du code, nous avons 3 façons de aider à ajouter de la clarté. Le type, le nom de la variable, et de l'affectation. Prenez cette ligne de code par exemple:

Person p = GetPerson();

la question est maintenant de savoir s'il y a assez d'information dans cette ligne de code pour vous aider à comprendre ce qui se passe?

Qu'en est-il de la ligne de code suivante? Sauriez-vous encore ce que p signifie dans ce cas:

var p = GetPerson();

et maintenant:

var p = Get();

ou maintenant:

var person = Get();

ou celui-ci:

var t = GetPerson();

ou ceci:

var u = Person.Get();

si le mot-clé var fonctionne dans un scénario donné dépend beaucoup du contexte du code, comme la façon dont les variables, les classes et les méthodes sont nommées. Elle dépend aussi de la complexité du code et dans le reste du code qui l'entourent.

personnellement, J'aime utiliser le mot-clé var c'est plus complet pour moi la plupart du temps. Mais j'ai aussi tendance à nommer mes variables d'après le type de sorte que je ne suis pas vraiment perdre des informations.

cela dit parfois selon le contexte que je fais des exceptions, telle est la nature de tout ce qui est complexe, et le logiciel n'est rien si ce n'est complexe.

Je n'aimais pas ça non plus.

Je ne veux pas que cela se transforme en un débat sur l'utilisation de var , il a ses utilisations, mais ne devrait pas être utilisé partout.

la chose clé à se rappeler est ReSharper est configuré selon les normes de codage que vous voulez.

Edit: ReSharper and var

ma règle est la suivante:

• déclarez-vous un type primitif (i.e. byte , char , string , int[] , double? , decimal , etc.)? - >Utiliser le type:

  string myStr = "foo";
  int[] myIntArray = [123, 456, 789];
  double? myDouble = 123.3;
  

• déclarez-vous un type complexe (c.-à-d. List<T> , Dictionary<T, T> , MyObj )? - >Utiliser var :

  var myList = List<string>();
  var myDictionary = Dictionary<string, string>();
  var myObjInstance = new MyObj();
  

je voudrais juste souligner que l'utilisation de" var "est recommandé dans le C# conventions de codage " lorsque le type de la variable est évident du côté droit de la tâche, ou lorsque le type précis n'est pas important", de sorte que c'est probablement pourquoi la pointe est sur par défaut dans ReSharper. Ils fournissent également quelques cas où il ne serait pas améliorer la lisibilité ci-dessous dans le même document.

je vois beaucoup de bonnes réponses, mais manquant le plein.

il est vrai que Resharper l'emporte par défaut sur var. Je pense que la plupart des gens seraient d'accord avec ça. Il est également plus facile à lire lorsque var est utilisé et le type est évident, comme lorsque vous utilisez une nouvelle instruction. J'ai vu un post qui a montré comment mettre à jour la sévérité de l'inspection pour ne montrer des conseils pour l'utilisation de var.

j'avais essayé de commenter sur d'autres posts premier à ajouter où mettre ces mais n'ont pas la réputation. Apparemment, je n'ai pas la réputation de poster ma capture d'écran des paramètres.

je vais vous expliquer comment y arriver.

Dans Visual Studio -> Menu Principal -> Resharper -> Options -> Options d'Édition de Code -> C# -> Style de Code -> Var Utilisation dans des déclarations

• Pour les types intégrés Utilisation explicite de type
• pour les types simples utiliser "var" lorsqu'il est évident
• ailleurs"

ReSharper recommande var parce qu'il tend à débloquer la création d'objet.

comparez ces deux exemples:

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

c'est juste un raccourci qui est censé être plus facile à lire.

je pense que c'est bien quand vous créez de nouveaux objets explicitement avec"nouveau". Dans votre exemple, cependant, il pourrait ne pas être évident si les classes ne sont pas nommés correctement.

BTW, ReSharper établit une distinction entre "vous pourriez vouloir appliquer cette suggestion à votre code" et " votre code est cassé, vous voulez que je le Répare?'. Le mot-clé var est dans la catégorie suggestion, avec des choses comme" inverser si pour réduire la nidification"; vous ne devez pas le suivre.

vous pouvez configurer à quel point chacune de ses alertes sont ennuyeuses à travers la boîte de dialogue Options, ou directement à travers le menu popup pour cette Alerte. Vous pouvez dévaloriser des choses comme Suggestion var pour qu'ils soient moins proéminents, ou vous pouvez mettre à jour des choses comme l'alerte "use extension method" pour qu'elle apparaisse comme une erreur réelle.

la caractéristique var de .Net 3.0 est juste type inférence , qui est type sûr et rend souvent votre code plus facile à lire. Mais vous n'avez pas à le faire, et vous pouvez désactiver cette recommandation dans resharper si vous voulez.

il n'y a pas de différence technique, si vous utilisez var, le type est implicite par le compilateur. Si vous avez un code comme celui-ci:

var x = 1;

x est implicitement un int et aucune autre valeur ne peut lui être attribuée.

le mot-clé var est utile si vous changez le type de la variable; vous n'avez alors qu'à faire un changement au lieu de deux:

var x = 1; --> var x = "hello";
int x = 1; --> string x = "hello";

le mot - clé var a été introduit dans C# 3.0-il nous permet d'oublier de spécifier notre type explicitement.

il n'y a pas de réelle différence à savoir si vous utilisez

MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

ou

var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

excepté la lisibilité pure et moins de risque d'erreur.

il semble comme un exemple cliché, mais dire ce qui suit peut aider votre la compréhension:

var myInt = 23;

renvoie un type int , alors que

var myInt = "23";

renvoie un type string .

référence MSDN

spécifier un type d'objet explicite est en quelque sorte redondant. Même traduit en anglais, il semble redondant: "mettre un objet de type X dans une variable de type X" vs "Mettre un objet de type X dans une variable".

Cependant, l'utilisation de la var' a son limitations . Il empêche l'utilisation ci-dessous de polymorphisme qui est beauté pure :

supposer un chien étend Animal; Chat étend la hiérarchie des classes animales:

Animal x = new Dog();
DoStuffWithDog(x as Dog);

x = new Cat();
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

le même code, avec x déclaré Avec 'var' ne compilera pas .

var x = new Dog(); // from this point, x is a Dog
DoStuffWithDog(x as Dog);

x = new Cat(); // cannot assign a Cat instance to a Dog
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

de toute façon, pour revenir à la question initiale, Je n'utilise pas Resharper, mais je suppose que c'est assez intelligent pour détecter quand ne pas utiliser 'var'. :- )

Var est incroyable! J'ai rencontré beaucoup de développeurs qui ont l'impression que var est lié à un type dynamique, ce n'est pas le cas. Il est encore statiquement dactylographié, il est juste décidé par le compilateur.

voici quelques résultats positifs étonnants de l'utilisation de var

moins typé var est plus court et plus facile à lire, par exemple



Dictionary<int,IList<string>> postcodes = new Dictionary<int,IList<string>>() Yuk.



var postcodes = new Dictionary<int,IList<string>>() \o / \o/



des noms variables plus descriptifs - ténu mais je pense qu'il est important de laisser briller ici la nature fluide de var . Comme var est un peu vague, il encourage vraiment un nom de variable plus déscipitive plutôt que de laisser le type parler pour lui-même.



Moins de changements de code - si le type de retour d'un appel de méthode changements. Il suffit de changer l'appel de méthode, pas tous les endroits où il est utilisé.



types anonymes - les types anonymes sont un concept vraiment puissant, en particulier dans des domaines tels que le WebApi ressources partielles . Sans var, ils ne peuvent pas être utilisés.

parfois cependant il est utile de déclarer explicitement les types et je trouve cela le plus utile dans les primitives ou les structures. Par exemple, Je ne trouve pas Personnellement cette syntaxe très utile:

for(var i = 0; i < 10; i++) 
{

}

vs

for(int i = 0; i < 10; i++) 
{

}

c'est une question de préférence personnelle, mais utiliser var accélérera vraiment votre développement et ouvrira un monde entier de bonté de type anonyme.

pour ceux qui n'aiment pas l'utilisation constante de "var":

NOTE: Vous pouvez également empêcher resharper de faire défaut à var en faisant "introduce variable". C'était quelque chose qui m'a frustré pendant longtemps, il était toujours en défaut à var, et je le changeais à chaque fois.

ces paramètres sont sous édition de Code -- > C# --> Code Style

à mon avis, var ne devrait être utilisé que s'il est immédiatement clair ce que le type est lors de la définition de la valeur de la variable.

exemple:

var s = "string value";

Il est évident que s est un string .

je crois qu'il est également approprié lorsque le nom de type de variable est très complexe.

exemple:

Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>> dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

// This is a little easier to read than the above statement
var dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

mis à part ces scénarios, Je ne vois aucun GAIN à faire en utilisant var , mais je peux penser à certains scénarios dans lesquels il peut être préjudiciable:

par exemple, un type jetable dont la valeur variable du côté droit n'indique pas clairement le type. Se débarrasser de L'IDisposable peut facilement être oublié

exemple:

// returns some file writer
var wr = GetWriter();

wr.add("stuff");
wr.add("more stuff");

//...
//...

// Now `wr` needs to be disposed, 
// but there is no clear indication of the type of `wr`,
// so it will be easily overlooked by code writer and code reviewer.

il n'y a pas de différence technique (comme eWolf l'a souligné). Vous pouvez utiliser l'un ou l'autre, le code CLR généré sera le même.

à mon avis, le principal avantage est que cela tend à vous forcer à utiliser de meilleurs noms de variables. Dans votre exemple 'foo' est un choix assez mauvais pour un nom de variable.

selon JetBrains (l'auteur de ReSharper), ils encouragent l'utilisation du var par défaut.

De leur site web :

utilisant implicitement des variables locales dactylographiées (également connu sous le nom de mot-clé var) introduit dans C# 3.0 est devenu très populaire en raison de l'amélioration de la lisibilité du code résultant. Par défaut, ReSharper encourage également l'utilisation du mot-clé var, mais les préférences de son utilisation sont flexibles. configurable. Par exemple, vous pouvez choisir d'utiliser des types explicites dans des cas spécifiques ou partout.