Définition explicite de types de données variables et utilisation du mot clé 'var'? [fermé]

En C #, suis-je encouragé à utiliser le mot clé polyvalent var pour chaque déclaration de variable? Si oui, dois-je mentionner ces caractères spéciaux pour les valeurs littérales dans la déclaration de variable, comme le M pour décimal dans l'instruction suivante:

var myDecimal = 14.5M;

Si cela fait une différence, j'essaie de faire du développement Web avec C #.

Il y a eu beaucoup de controverse sur l'utilisation de var. Mes règles générales sont les suivantes.

• Lorsque le type est évident, par exemple lorsque la main droite de l'affectation est un constructeur, utilisez var.
• Lorsque le type est complexe à écrire, tel qu'une requête LINQ (la raison de var en premier lieu), utilisez var.
• Pour les types ambivalents (votre nombre décimal étant un exemple) lorsque vous voulez vous assurer que votre variable est correctement saisie, épelez-la.
• Les types anonymes doivent utiliser var.
• Dans tous les autres cas, précisez le type.

Fondamentalement, l'objectif est de faciliter la lecture du code. Si vous estimez que var suffit car l’affectation est évidente, utilisez var. Utilisez le nom de type complet comme indice pour le lecteur lorsque vous le jugez nécessaire.

Quand utiliser varest une programmation "guerre sainte". Il y a précisément un endroit où cela est requis: lorsque le résultat d'une opération crée un type anonyme, tel que:

var result = new { Name = "John", Age = 35 };

Partout ailleurs, il est facultatif et vraiment conforme à votre norme de codage de l’utiliser ou non dans les autres situations.

Et oui, vous aurez besoin des caractères spéciaux pour les littéraux pour que le compilateur sache ce que c'est du côté droit. Dans votre exemple, sans le M, la valeur par défaut est doubleplutôt que decimal.

À partir de MSDN :

Cependant, l'utilisation de var a au moins le potentiel de rendre votre code plus difficile à comprendre pour les autres développeurs. Pour cette raison, la documentation C # utilise généralement var uniquement lorsque cela est nécessaire.

Je n'aime vraiment pas vraiment la dactylographie implicite. En apparence, il a tendance à rendre le code plus lisible, mais peut entraîner de nombreux problèmes par la suite. Si un dev change un initialiseur de variable, disons de

var myFloat=100f;

à

var myFloat=100;

ou

var myFloat=100.0;

Le type changera, entraînant toute une série d’erreurs de compilation ou, s’il s’agit d’une vue Web et que vous n’utilisez pas l’étape de post-génération pour précompiler vos vues, toute une série d’erreurs d’exécution qui ne seront pas détectées sans un traitement efficace. tests de pré-déploiement.

Le typage implicite ne fonctionne pas non plus partout (à partir du même lien MSDN)

var ne peut être utilisé que lorsqu'une variable locale est déclarée et initialisée dans la même instruction; la variable ne peut pas être initialisée à null, à un groupe de méthodes ou à une fonction anonyme.

var ne peut pas être utilisé sur des champs de portée de classe.

Les variables déclarées à l'aide de var ne peuvent pas être utilisées dans l'expression d'initialisation. En d'autres termes, cette expression est légale: int i = (i = 20); mais cette expression produit une erreur de compilation: var i = (i = 20);

Plusieurs variables implicitement typées ne peuvent pas être initialisées dans la même instruction.

Si un type nommé var se trouve dans la portée, le mot clé var sera résolu en ce nom de type et ne sera pas traité comme faisant partie d'une déclaration de variable locale implicitement typée.

Garder votre code cohérent (dans ce cas, utiliser du texte explicite partout) est une très, très bonne chose. À mon avis, varest paresseux et ne procure aucun avantage réel et introduit un autre point d'échec potentiel dans un processus déjà complexe.

Mise à jour 2017

J'ai complètement changé d'avis. Lorsque je travaille en C #, j'utilise la varplupart du temps (à l'exception de choses comme les variables de type interface, etc.). Cela maintient le code concis, ce qui améliore la lisibilité. Restez cependant attentif à ce que le type résolu est vraiment.

La référence C # montre ce qui suit pour illustrer une bonne ou une mauvaise utilisation de cette construction:

L'exemple suivant montre deux expressions de requête. Dans la première expression, l'utilisation de var est autorisée mais n'est pas obligatoire, car le type du résultat de la requête peut être indiqué explicitement sous la forme IEnumerable. Cependant, dans la deuxième expression, var doit être utilisé car le résultat est une collection de types anonymes et le nom de ce type n'est accessible que par le compilateur lui-même. Notez que dans l'exemple n ° 2, l'élément de variable d'itération foreach doit également être implicitement typé.

 // Example #1: var is optional because 
    // the select clause specifies a string 
    string[] words = { "apple", "strawberry", "grape", "peach", "banana" };
    var wordQuery = from word in words
                    where word[0] == 'g'
                    select word;

    // Because each element in the sequence is a string,  
    // not an anonymous type, var is optional here also. 
    foreach (string s in wordQuery)
    {
        Console.WriteLine(s);
    }

    // Example #2: var is required because 
    // the select clause specifies an anonymous type 
    var custQuery = from cust in customers
                    where cust.City == "Phoenix" 
                    select new { cust.Name, cust.Phone };

    // var must be used because each item  
    // in the sequence is an anonymous type 
    foreach (var item in custQuery)
    {
        Console.WriteLine("Name={0}, Phone={1}", item.Name, item.Phone);
    }

Le mot clé var demande uniquement au compilateur de déduire automatiquement le type de la variable de type var. Par conséquent, si vous souhaitez stocker une variable de type décimal dans une variable var, vous devez utiliser m. De même, si vous stockez une chaîne, vous devez la placer entre guillemets.

Pour moi, je n'utilise pas var dans les cas suivants:

• Quand je veux être sûr du type de ma variable (par exemple, pour être sûr que le type utilisé est double et non décimal, et c'est une grosse affaire, faites-moi confiance!)
• Code polymorphe comme Fruit foo = new Apple();. Dans ce cas, je pense que var est d'éviter et utiliser la classe parente (ici Fruit) est préférable en permettant une meilleure compréhension de la logique du code et la limitation des bogues probables (Avec var, aucune vérification du concept polymorphe!)

Pour le reste, je pense que cela dépend du cas et du fond du développeur. Certaines personnes du monde PHP préféreront ne pas s'occuper des types variables, et certaines personnes du monde Java vont simplement penser que var est une hérésie et plus elle est verbeuse, mieux c'est.

Vous devrez faire votre opinion personnelle :)