Неявная типизация; почему только локальные переменные?

Question

Кто-нибудь знает или может спросить, почему неявное типирование ограничено локальными переменными?

var thingy = new Foo(); 

Но почему бы не ...

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

Answer 1

Эрик Липперт сделал все записи в блоге на эту тему.

• http://blogs.msdn.com/ericlippert/archive/2009/01/26/why-no-var-on-fields.aspx

В целом, основная проблема заключается в том, что это потребовало бы крупной повторной архитектуры C# компилятор, чтобы сделать это. Объявления обрабатываются в один проход. Это потребует нескольких проходов из-за возможности создавать циклы между выведенными переменными. У VB.net есть примерно такая же проблема.

Answer 2

Я думаю, что это связано с тем, что объем этого подразумеваемого типа намного шире и, следовательно, более вероятно вызовет проблемы, чем в рамках одного метода.

Answer 3

Потому что это намного проще сделать. Если вы хотите сделать вывод о всех типах, нужно будет что-то вроде системы вывода типа Hindley Milner, которая сделает ваш любимый C# на языке производных Haskel.

Answer 4

По существу, проблема, с которой вы сталкиваетесь, заключается в том, что C# (пока) является статически типизированным языком. Локальная переменная, определенная как var, все еще статически типизирована, но синтаксически скрыта. С другой стороны, метод, возвращающий var, имеет много последствий. Он становится скорее интерфейсом для использования, и вы ничего не получаете, используя var.

Answer 5

У Джареда есть фантастическая ссылка в его ответе, на фантастическую тему.

Я думаю, что он не отвечает на вопрос явно.

Почему бы и нет?

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

Причина этого заключается в том:

Что делать, если?

class Foo {} 

var GetFoo() { 
    return GetBar(); 
} 

var GetBar() { 
    return GetBaz(); 
} 

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

Можно сделать вывод, что GetFoo собирается вернуться Foo, но вам придется отслеживать через все вызов, метод делает и его детей делают просто определить тип. В его нынешнем виде компилятор C# не предназначен для работы таким образом. В начале процесса ему нужны методы и типы полей до того, как код, который вводит типы, может работать.

На чисто эстетическом уровне я нахожу определения var на методах путают вещи. Его единственное место, где я думаю, что явное указание всегда помогает, оно защищает вас от стрельбы по себе в ногу, случайно возвращая тип, который заставляет вашу подпись и тонну других зависимых сигнатур методов изменять. Хуже того, вы могли бы изменить все ваши подписи цепочки методов, даже не зная, что вы сделали это, если вы вернете значение метода, возвращающего объект, и ему повезло.

Я думаю, что методы вар лучше оставить для динамических языков, как Ruby,

Answer 6

вы можете использовать в VS 2010 Dynamic

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