c# - usa - Tipificación implícita; ¿Por qué solo variables locales?
tipos de variables en c# (6)
¿Alguien sabe o le interesa especular por qué la tipificación implícita se limita a las variables locales?
var thingy = new Foo();
Pero por qué no...
var getFoo() {
return new Foo();
}
Creo que es porque el alcance de ese tipo implícito es mucho más amplio y por lo tanto es más probable que cause problemas que dentro del alcance de un solo método.
Eric Lippert hizo una publicación completa en el blog sobre el tema.
En resumen, el problema principal es que habría requerido una nueva arquitectura del compilador de C # para hacerlo. Las declaraciones se procesan actualmente de una sola manera. Esto requeriría pases múltiples debido a la capacidad de formar ciclos entre variables inferidas. VB.net tiene aproximadamente el mismo problema.
Esencialmente, el problema con el que te encuentras es que C # (hasta ahora) es un lenguaje tipado estáticamente. Una variable local definida como var todavía se escribe de forma estática, pero se oculta sintácticamente. Un método que devuelve var, por otro lado, tiene muchas implicaciones. Se convierte más en una interfaz para el uso, y usted no gana nada al usar var.
Jared tiene un enlace fantástico en su respuesta, a un tema fantástico.
Creo que no responde explícitamente a la pregunta.
Por qué no?
var getFoo() {
return new Foo();
}
La razón de esto es:
¿Y si?
class Foo {}
var GetFoo() {
return GetBar();
}
var GetBar() {
return GetBaz();
}
var GetBaz() {
return new Foo();
}
Podrías deducir que GetFoo devolverá a Foo , pero tendrás que rastrear todas las llamadas que hace el método y sus hijos solo para inferir el tipo. En su forma actual, el compilador de C # no está diseñado para funcionar de esta manera. Necesita métodos y tipos de campo al principio del proceso antes de que se pueda ejecutar el código que infiere los tipos.
En un nivel puramente estético, encuentro que las definiciones de var de los métodos confunden las cosas. Es un lugar donde creo que ser explícito siempre ayuda, lo protege de dispararse en el pie al devolver accidentalmente un tipo que hace que su firma y una tonelada de otras firmas de métodos dependientes cambien. Peor aún, podría cambiar todas las firmas de una cadena de métodos sin siquiera saber que lo hizo si devuelve el valor de un método que devuelve el objeto y resultó ser afortunado.
Creo que es mejor dejar los métodos var para lenguajes dinámicos como Ruby
Porque es mucho más fácil de hacer. Si tuviera que inferir todos los tipos, uno necesitaría algo como el sistema de inferencia tipo Hindley Milner que hará que su querido C # se convierta en un lenguaje derivado de Haskel.
Puedes usar en vs 2010 Dynamic
Dynamic getFoo() {
return new Foo();
}