Quel est le point de le mot-clé var?

La var mot-clé permet d'éliminer la nécessité expresse de la déclaration de type et j'ai lu avec intérêt le DONC la discussion de quand il peut être approprié.

J'ai aussi lu sur (mais pas utilisé) Boo qui semble prendre les choses une étape plus loin en rendant en option pour déclarer une variable locale. Avec Boo, à la fois le type et la déclaration peut être implicite.

Ce qui m'amène à me demander, pourquoi le langage C# concepteurs de la peine d'inclure un mot-clé var à tous?

Mise à jour: Oui, var prend en charge les types Anonymes, mais les types anonymes par 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 };
  • Je ne suis pas de toucher à ce avec un de 10 mètres du poteau. Eh bien, autre que de dire que je suis d'accord avec vous. Je ne comprends pas non plus. 🙂
  • hein, comment est votre deuxième exemple de ligne de code valide en c#?
  • ce n'est pas la question (depuis longtemps répondu), est pourquoi pas?
  • Boo semble être mort. Qu'est-ce exactement avez-vous lu là? Peut-être cela devrait être mieux expliqué au lieu d'être deviné à partir d'un mort URL.
InformationsquelleAutor Ed Guiness | 2008-10-16
  1. 45

    Mise à jour: Il y a deux questions connexes ici, en fait:
    1. Pourquoi dois-je déclarer des variables à tous?
    2. Quelle est la "var" dans une langue qui vous fait déclarer des variables?

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

    Comme d'autres commentateurs l'ont dit, LINQ l'utilise pour ses types anonymes. Cependant, LINQ est en fait une instance d'un problème plus général où le type de la main droite d'une expression est soit inconnue pour le programmeur, ou qui est extrêmement détaillé. Considérer:

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

    Détaillé et sujettes à l'erreur, non? Alors maintenant, ils vous permettent de faire cela:

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

    Par la réduction de la duplication de l'information, les erreurs sont éliminées. Notez qu'il n'y a pas juste des erreurs de frappe, ici: il est possible que le type de la partie gauche de l'expression être une erreur de frappe d'une manière telle que le compilateur peut silencieusement fonte de gauche à droite, mais le plâtre perd réellement une propriété de la rvalue. Cela est encore plus important lorsque le type retourné par la rvalue, peut-être inconnu ou anonyme.

    • C# n'est pas Boo. Il ne prend pas en charge le Duck-Typing. Le compilateur C# détermine le type d'une variable-variable déclarée en fonction du type de l'objet qui lui sont assignées - si le type est inconnu, var ne peut pas être utilisé. Nécessaire pour les types anonymes comme le programmeur vous ne pouvez pas spécifier le type (mais le compilateur C# peut).
    InformationsquelleAutor JSBձոգչ
  2. 47

    Sans le mot-clé var, il devient possible de faire accidentellement à créer une nouvelle variable quand vous avez eu réellement l'intention d'en utiliser une déjà existante variable. par exemple,

    name = "fred";
   ...
Name = "barney"; //whoops! we meant to reuse name
    • Ayant var s'arrête aussi vous avez accidentellement la réutilisation d'une variable var nom = "fred"; .... var nom = "barney"; peut être repéré par le compilateur.
    • bon point. Je n'avais pas bien que.
    • Cette réponse confond deux questions: "pourquoi avez-var dans une langue qui vous oblige à déclarer les variables", et "pourquoi déclarer des variables à tous?" Accidentellement la création d'une variable de réutilisation est empêché en vous forçant à les déclarer.
    • Super! Merci pour cela. Je me demandais ce pour un certain temps maintenant, et quand j'ai lu cette réponse, je me sentais VRAIMENT stupide.
    InformationsquelleAutor Ferruccio
  3. 39

    Je comprends la nécessité pour les var et il sert il but une grande. N'ayant aucun mot-clé juste et la définition des variables à la volée sans type est effrayant. Votre mal le gars à côté qui a pour maintenir votre code ou vous-même si vous avez besoin de retravailler le code que vous n'avez pas touché depuis plus d'un an. Je ne suis pas sûr que c'est une porte qui s'ouvre en C# et j'espère que ce n'est pas que la var est déjà à l'origine de la lisibilité des problèmes lorsque étant plus utilisé lorsqu'il n'est pas nécessaire.

    Presque tous les .net 3.5 exemple que je viens de voir récemment, toutes les variables définies avec var.

    L'arguement je fais c'est que ça sacrifices lisibilité pour le bien de sauver les frappes quand il est plus utilisé. 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 c'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();

    De sorte que la prochaine arguement sera, juste le nom de la fonction mieux...

    var weight = GetExactWeightOfTheBrownYakInKilograms();

    Ne sais toujours pas ce qu'est de retour. Est-il un entier, décimal, float, le poids de l'objet, de quoi? J'ai encore à perdre de temps à chercher jusqu'à... besoin de l'intellisense béquille pour enregistrer le jour de ma programmation différée. Peut-être inclure le type de retour dans le nom de la fonction. Bonne idée, maintenant, à l'aide de var nous a sauvés à rien sauf à faire de toutes mes fonctions ont de vrais noms longs.

    Je pense que les gens sont un peu plus l'utilisation de var et il est à la tête de la programmation différée qui à son tour conduit à la plus difficile de lire le code. Chaque fois que vous tapez le mot-clé var, vous devriez avoir une bonne raison pour laquelle vous l'utilisez au lieu d'être explicite.

    • J'aime la GetExactWeightOfTheBrownYakInKilograms().
    • chaque fois que vous tapez types sur les deux côtés de l'égalité-signe, vous êtes juste de gaspiller de frappes par la non-utilisation de la var.
    • Aimé votre réponse, et j'adore le GetExactWeightOfTheBrownYakInKilograms();. Haha!
    • Ce n'est pas ce qu'il préconise.
    • L'exemple est aspiré hors de l'air mince. Qui se soucie des unités de mesure, tant que c'est la même au sein d'une application. Oh, vous pensez que cela peut être différent? Veuillez coder explicitement à l'aide d'un wrapper.
    • Ceci permet de clarifier les choses pour moi. Je voulais m'assurer que ce n'était pas quelque chose qui me manquait pour lesquelles il a été utilisé. Ce que je retiens de cette et d'autres réponses est: utiliser rarement, et si vous le faites, assurez-vous qu'il est clair.
    • La façon de traiter avec têtu développeurs qui affirment que l'utilisation de "var" est partout la Microsoft préféré façon de faire les choses?? Il m'exaspère. Je ne peux pas lire leur code d'un coup d'oeil et prend deux fois plus longtemps pour comprendre ce qu'il se passe. Je ne comprends pas comment ils lisent de leur propre code mois sur toute la ligne.

    InformationsquelleAutor Kelsey
  4. 5

    C'est un peu subjectif, mais je pense que la conception de C# 3.0, pour avoir le mot clé "var" pour implicitement les variables de type au lieu de aucun mot-clé rend le code plus lisible. Par exemple, le premier bloc de code ci-dessous est plus lisible que le deuxième:

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

    var myVariable = SomeCodeToSetVariableHere;
myVariable = SomeOtherCodeTOSetVariable;

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

    myVariable = SomeCodeToSetVariableHere;
myVariable = SomeOtherCodeTOSetVariable;

    Ce sont les simplismes des exemples. Je pense que vous pouvez voir où cela va. Dans des situations complexes, il pourrait être agréable d'être en mesure de trouver l'endroit où une variable est en fait défini.

    InformationsquelleAutor Jason Jackson
  5. 4

    Dans votre question, var ajoute de la valeur pour le code en indiquant au compilateur le mot anon est maintenant légal pour utiliser n'importe où vous vous attendez à voir un élément de type implicite dans le travail. Nécessitant la mise en place de noms pour le compilateur comme ceci permet au compilateur de rejeter les choses qu'il n'a pas été dit explicitement autorisées, et ainsi attraper certains types d'erreurs au moment de la compilation afin de ne pas exploser au moment de l'exécution.

    Par exemple, dans la section mise à jour de votre question, vous avez demandé à propos de cet extrait:

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

    Le problème en permettant de cette façon, c'est qu'il tourne à quoi que ce soit sur le côté gauche de l'affectation où le nom n'existait pas encore dans une déclaration de variable, même si c'est vraiment une faute de frappe. Si plus tard dans le programme vous attribuer quelque chose d'autre à anon et puis encore plus loin sur la référence de la nouvelle valeur, mais le milieu a une faute de frappe, vous avez un problème que de ne pas s'afficher jusqu'à ce que l'exécution.

    Votre réponse, c'est que Boo t-il, donc il doit être bon ou le moins possible. Mais c'est un leurre. Nous parlons, C#, pas de Boo. L'un des buts de C# est d'avoir une langue où le compilateur peut intercepter les erreurs autant que possible. Boo veut le faire aussi, mais il veut aussi être plus comme le Python. Donc, il sacrifices certains (pas tous) de C#'s au moment de la compilation de la sécurité en échange de python syntaxe.

    InformationsquelleAutor Joel Coehoorn
  6. 1

    avertissement: mes exemples sont Java, car c'est ce que je sais, mais les concepts doivent être identiques.

    J'ai voté la réponse que je ressens est critique (c'est trop facile de accidentellement créer une nouvelle variable).

    bill=5;
bi11=bill+5

    Quelle est la valeur du projet de loi?

    Cela dit, je trouve cela un peu gênant à la fois de type:

    DataOutputStream ds=new DataOutputStream();

    Semble redondant, mais honnêtement, il n'y a vraiment rien de mal à cela. Il ne vous prendra pas plus de taper deux fois, et il est extrêmement utile. Ce qui prend du temps, c'est quand vous avez des questions--quand vous ne savez pas exactement comment utiliser certaines API. Si ça vous gêne vraiment de type de la déclaration de type deux fois, alors pourquoi êtes-vous perdre votre temps ici? Depuis que vous avez commencé la lecture de ce que vous pourriez avoir tapé 30 ou 40 de la déclaration, en quantité suffisante pour chaque déclaration que vous aurez besoin pour les deux prochaines semaines.

    Je suppose que je suis en train de dire que même si je comprends le stress émotionnel qui vous répéter vous-même peut provoquer des, de la cohérence, de la clarté et de la capacité de faire plus d'outils intelligents, il fait BIEN la peine.

    Encore une chose, la PLUPART du temps, le code ne devrait pas être comme mon exemple ci-dessus. Ce que vous devez faire, c'est ceci:

    DataOutput ds=new DataOutputStream();

    Immédiatement masque le fait que vous êtes à l'aide d'un béton de classe dans un modèle. Ce modèle doit être capable de faire toutes les opérations dont vous avez besoin sur votre classe. Plus tard, si vous vouliez remplacer la ds avec un autre type de flux de sortie, il suffit de changer cette ligne unique permettra de le corriger. Si vous avez été en utilisant les fonctionnalités ne sont pas disponibles pour DataOutput par la coulée de DataOutputStream, l'éditeur va facilement découvrir et vous laisser savoir.

    InformationsquelleAutor
  7. -1

    Pour les types anonymes, qui, entre autres choses support LINQ.

    http://www.blackwasp.co.uk/CSharpAnonTypes.aspx

    InformationsquelleAutor BlackWasp
  8. -1

    Je crois que var (et plusieurs autres nouveaux mots-clés) ont été ajoutés pour répondre spécifiquement à Linq.

    var est le mot utilisé pour créer un type anonyme - voir http://msdn.microsoft.com/en-us/library/bb397696.aspx

    Les types anonymes peuvent être utilisés dans d'autres lieux de Linq.

    var est exceedingy utile pour Linq. En fait, selon un expert auteur, "Sans ‘var’, LINQ devient trop pénible à utiliser."

    InformationsquelleAutor DOK