Typage implicite; pourquoi seulement des variables locales?

StackOverflow https://stackoverflow.com/questions/824739

Question

Quelqu'un sait-il ou souhaite-t-il spéculer sur la raison pour laquelle le typage implicite est limité aux variables locales? 

var thingy = new Foo();

Mais pourquoi pas ... 

var getFoo() {
    return new Foo(); 
}
Était-ce utile?

La solution

Eric Lippert a publié un article de blog complet sur le sujet.

En résumé, le principal problème est qu’il aurait fallu une nouvelle architecture majeure du compilateur C # pour le faire. Les déclarations sont actuellement traitées en une seule passe. Cela nécessiterait plusieurs passes en raison de la possibilité de former des cycles entre des variables inférées. VB.net a à peu près le même problème.

Autres conseils

Jared a un lien fantastique dans sa réponse, à un sujet fantastique.

Je pense que cela ne répond pas explicitement à la question.

Pourquoi pas? 

var getFoo() {
    return new Foo(); 
}

La raison en est:

Et si? 

class Foo {}

var GetFoo() {
   return GetBar(); 
}

var GetBar() {
  return GetBaz(); 
}

var GetBaz() {
   return new Foo();
}

Vous pouvez en déduire que GetFoo va renvoyer Foo , mais vous devrez suivre tous les appels que cette méthode effectue et ses enfants fait juste pour déduire le type. Dans l'état actuel des choses, le compilateur C # n'est pas conçu pour fonctionner de cette manière. Il a besoin des types de méthode et de champ à un stade précoce du processus avant que le code qui en déduit les types puisse être exécuté.

Sur un plan purement esthétique, je trouve que les diverses définitions de méthodes confondent les choses. Je pense qu’il est toujours utile d’être explicite, il vous empêche de vous tirer dans le pied en renvoyant accidentellement un type qui entraîne la modification de votre signature et d’une tonne d’autres signatures de méthode dépendantes. Pire encore, vous pourriez potentiellement changer toutes les signatures d’une chaîne de méthodes sans même le savoir, si vous renvoyez la valeur d’une méthode qui renvoie un objet et s’avère chanceux.

Je pense qu'il vaut mieux laisser les méthodes var pour les langages dynamiques comme Ruby

Parce que c'est beaucoup plus facile à faire. Si vous deviez déduire tous les types, il vous faudrait quelque chose comme le système d’inférence de type Hindley Milner qui transformera votre bien-aimé C # en langage dérivé de Haskel.

Essentiellement, le problème que vous rencontrez est que C # (jusqu’à présent) est un langage à typage statique. Une variable locale définie en tant que var est toujours typée statiquement, mais masquée syntaxiquement. Une méthode retournant var, en revanche, a de nombreuses implications. Cela devient plus une interface d'utilisation, et vous ne gagnez rien en utilisant var.

vous pouvez utiliser vs 2010 Dynamique 

Dynamic getFoo() { 
    return new Foo();  
}

Je pense que c'est parce que la portée de ce type implicite est beaucoup plus large et est donc plus susceptible de poser problème que dans le cadre d'une méthode unique.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top