Привет всем.

Полюбил я ключевое слово var всей душой и телом. И юзаю его везде где только можно.

И сильно расстроился когда компилятор (VS2010) ниасилил

class Program
{
 private static var sm_Tests=new List<int>();
};//class Program

Ну что за ботва!

Здравствуйте, Коваленко Дмитрий, Вы писали:

Тут дело не в том, что компилятор не осили вывод типов, а в том что var может использоваться только при объявлении локальных переменных.
http://msdn.microsoft.com/en-us/library/bb383973.aspx

Beginning in Visual C# 3.0, variables that are declared at method scope can have an implicit type var.

Здравствуйте, adontz, Вы писали:

A>Тут дело не в том, что компилятор не осили вывод типов, а в том что var может использоваться только при объявлении локальных переменных.
A>http://msdn.microsoft.com/en-us/library/bb383973.aspx

A>

A>Beginning in Visual C# 3.0, variables that are declared at method scope can have an implicit type var.

Ага, спасибо. Я пока еще не натаскался на все эти ограничения и пишу методом проб и ошибок

И, ясный пень, в документацию не смотрю смотрю через раз

The following restrictions apply to implicitly-typed variable declarations:

• var can only be used when a local variable is declared and initialized in the same statement; the variable cannot be initialized to null, or to a method group or an anonymous function.
  
  
• var cannot be used on fields at class scope.
  
  
• Variables declared by using var cannot be used in the initialization expression. In other words, this expression is legal: int i = (i = 20); but this expression produces a compile-time error: var i = (i = 20);
  
  
• Multiple implicitly-typed variables cannot be initialized in the same statement.
  
  
• If a type named var is in scope, then the var keyword will resolve to that type name and will not be treated as part of an implicitly typed local variable declaration.

Отюда

Здравствуйте, adontz, Вы писали:

A>Здравствуйте, Коваленко Дмитрий, Вы писали:

A>Тут дело не в том, что компилятор не осили вывод типов, а в том что var может использоваться только при объявлении локальных переменных.
A>http://msdn.microsoft.com/en-us/library/bb383973.aspx

A>

A>Beginning in Visual C# 3.0, variables that are declared at method scope can have an implicit type var.

только вот зачем такое ограничение сделали — не понятно.

Здравствуйте, Jack128, Вы писали:

J>только вот зачем такое ограничение сделали — не понятно.

public class Bar
{
    private var foo;
}

Какой тип имеет переменная foo?
Если очень хочется, то есть dynamic.

Здравствуйте, antigravity, Вы писали:

J>>только вот зачем такое ограничение сделали — не понятно.

A>

A>public class Bar
A>{
A>    private var foo;
A>}
A>

A>Какой тип имеет переменная foo?
A>Если очень хочется, то есть dynamic.

static void test_method()
{
 var x;
}

Какой тип имеет переменная x?

КД>Какой тип имеет переменная x?

Дело в том, что когда Вы пишите:
class Program
{
private static var sm_Tests=new List<int>();
};//class Program

То "new List<int>();" происходит в конструкторе, путь и статическом, но конструкторе. И получается объявление вида:
"private static var sm_Tests;"
И действительно не понятно, какой тип должна иметь эта переменная. Конечно, это могли бы и обойти, но видимо не захотели...

Здравствуйте, Аноним, Вы писали:

КД>>Какой тип имеет переменная x?

А>Дело в том, что когда Вы пишите:
А>class Program
А>{
А> private static var sm_Tests=new List<int>();
А>};//class Program

А>То "new List<int>();" происходит в конструкторе, путь и статическом, но конструкторе. И получается объявление вида:
А>"private static var sm_Tests;"
А>И действительно не понятно, какой тип должна иметь эта переменная. Конечно, это могли бы и обойти, но видимо не захотели...

Вот — фактически ответ на вопрос!

А я ведь читал (и даже перечитывал) про эту инициализацию членов класса.

Но не увязал с этой проблемой

---
Жаль что не захотели

Здравствуйте, Аноним, Вы писали:

КД>>Какой тип имеет переменная x?

А>Дело в том, что когда Вы пишите:
А>class Program
А>{
А> private static var sm_Tests=new List<int>();
А>};//class Program

А>То "new List<int>();" происходит в конструкторе, путь и статическом, но конструкторе. И получается объявление вида:
А>"private static var sm_Tests;"
А>И действительно не понятно, какой тип должна иметь эта переменная. Конечно, это могли бы и обойти, но видимо не захотели...

Позволю себе позанудствовать: это происходит НЕ в статическом конструкторе. Между такой инициализацией полей и статическим конструктором есть разница.

Здравствуйте, Коваленко Дмитрий, Вы писали:

A>>Какой тип имеет переменная foo?
A>>Если очень хочется, то есть dynamic.

КД>

КД>static void test_method()
КД>{
КД> var x;
КД>}
КД>

КД>Какой тип имеет переменная x?

Никакого. Код не скомпилится.

Здравствуйте, Коваленко Дмитрий, Вы писали:

КД>

КД>static void test_method()
КД>{
КД> var x;
КД>}
КД>

КД>Какой тип имеет переменная x?

Согласен, пример не очень удачный, но суть раскрывает.
Тут Эрик довольно подробно описывает, почему var используется только внутри методов.

So immediately we have one problem; if we have "var" fields then the type of the field cannot be determined until the expression is analyzed, and that happens after we already need to know the type of the field.

Здравствуйте, Lloyd, Вы писали:

A>>>Какой тип имеет переменная foo?
A>>>Если очень хочется, то есть dynamic.

КД>>

КД>>static void test_method()
КД>>{
КД>> var x;
КД>>}
КД>>

КД>>Какой тип имеет переменная x?

L>Никакого. Код не скомпилится.

А вот хрена лысого

class t_test
{
 class var
 {
 };

 static void test()
 {
  var x;
 }//test
};//class t_test

Пожалуй добавлю я еще очков adontz-у за ссылку на доку

Здравствуйте, Коваленко Дмитрий, Вы писали:

L>>Никакого. Код не скомпилится.

КД>А вот хрена лысого
КД>

КД>class t_test
КД>{
КД> class var
КД> {
КД> };

КД> static void test()
КД> {
КД>  var x;
КД> }//test
КД>};//class t_test
КД>

КД>

Этот код отличается от предыдущего кода.

Здравствуйте, Lloyd, Вы писали:

L>>>Никакого. Код не скомпилится.

КД>>А вот хрена лысого

L>Этот код отличается от предыдущего кода.

Ага, но все равно прикольно

Здравствуйте, Коваленко Дмитрий, Вы писали:

КД>Полюбил я ключевое слово var всей душой и телом.

Эт хорошо!

КД> И юзаю его везде где только можно.

А вот эт ты зря. Как и любую возможность любого языка программирования, ее нужно использовать ни "где только можно", а "где только нужно". А то это мне анекдот про кота напоминает

Я полностью "за" использование var-a и применяю его очень часто, но есть моменты, пусть и очень-очень редкие, когда без понимания четкого типа переменной понять, что происходит в коде сложно. Повторюсь, я за эту штуку, но категоричность глаз режет.

КД>И сильно расстроился когда компилятор (VS2010) ниасилил
КД>

КД>class Program
КД>{
КД> private static var sm_Tests=new List<int>();
КД>};//class Program
КД>

КД>Ну что за ботва!

ИМО у этой ботвы есть несколько причин.
1. Никто не хотел сделать C# 3.0 полностью неявнотипизированным языком программирования, типа F#-а, где все типы выводились бы компилятором. Неявная типизация прежде всего являлась одной из составляющих (пусть и важной) более общей концепции под названием LINQ. Поскольку результатами LINQ-запросов могли быть последовательности анонимных классов, то без этой возможности мы бы получили слишком урезанные возможности LINQ-а.

Неявно-типизированные поля же никоим образом делу LINQ-а помочь не могли.

2. Даже с первого взгляда тут появляются ряд вопросов к использованию var-а в полях.
Да, я понимаю, что можно ограничить использование var-а только field-like инициализацией и выдавать ошибку при попытке записи чего-то типа:

class Program
{
  var c;
}

Так что с предыдущим комментом проблем никаких.

Вопрос следующий: что делать с анонимными классами? Ведь с точки зрения синтаксиса языка следующий код должен был бы быть абсолютно законным:

class A
{
  public var field = new {I = 1, S = "2"};
}

В результате мы получили бы класс, чей открытый интерфейс не пойми как использовать. Ведь анонимные классы — это закрытые классы, которые генерируются внутри текущей сборки и, по идее, использованы снаружи быть не могут. Конечно, можно было бы ограничить использование var только для внутренних (internal) полей, но, согласитесь, было бы странно, что мы можем некоторую языковую возможность использовать с одним модификатором доступа и не можем — с другим.

Можно было бы запретить использование анонимных классов для инициализации неявно-типизированных полей, но тогда мы бы получили дикую несогласованность, поскольку две "родственные" фичи: а именно, неявно-типизированные локальные переменные и поля, не могли бы использоваться в одних и тех же условиях.

Я думаю, что можно найти еще подводных камней в реализации неявно-типизированных полей в языке C# (типа, необходимость полной переделки компилятора, о которой пишет Липперт), но, думаю, что уже должно быть понятно, почему сделано именно так, а не иначе.

Здравствуйте, SergeyT., Вы писали:

ST>Вопрос следующий: что делать с анонимными классами? Ведь с точки зрения синтаксиса языка следующий код должен был бы быть абсолютно законным:

ST>

ST>class A
ST>{
ST>  public var field = new {I = 1, S = "2"};
ST>}
ST>

ST>В результате мы получили бы класс, чей открытый интерфейс не пойми как использовать.

Здесь проблема лежит глубже. Такой код вполне имеет право на существование... в рамках структурной типизации. Рано или поздно разработчики C# таки упрутся в систему типов дотнета, конечно хотелось быть чтобы это случилось раньше.

Здравствуйте, rumatavz, Вы писали:

R>Позволю себе позанудствовать: это происходит НЕ в статическом конструкторе. Между такой инициализацией полей и статическим конструктором есть разница.

Инициализация происходит в статическом конструкторе, класс помечается аттрибутом beforefieldinit

Здравствуйте, Коваленко Дмитрий, Вы писали:

КД>Привет всем.

КД>Полюбил я ключевое слово var всей душой и телом. И юзаю его везде где только можно.

С точки зрения читателя такого кода, это очень неудобно. Это создает лишние трудности для его понимания. Тип ведь частенько хочется узнать, все-таки. Ну хорошо, отказались от венгерской нотации мотивируя это тем, что, мол, "а я наведу мышку на переменную, мне тип и покажется". Использование же var и это утешение отменяет. Выглядит это просто так, что человеку лень даже тип указать. Мотивация повсеместного использования этого вообще непонятна. Кроме редкий ситуаций, для который его и придумали (создание анонимных типов в Linq-запросах), непонятно совершенно — где его применение еще может быть оправдано.
Такое нецелевое использование, на мой взгляд, признак дурного тона в программировании.

Здравствуйте, sunshine, Вы писали:

S>Ну хорошо, отказались от венгерской нотации мотивируя это тем, что, мол, "а я наведу мышку на переменную, мне тип и покажется".

С var будет показан настоящий тип, а не var.

S>непонятно совершенно — где его применение еще может быть оправдано.

Ну, например, при перечислении в foreach элементов словаря, приятнее написать var, а не KeyValuePair<TKey, TValue>. Я против употребления var везде где можно, но бывают какие-то совсем очевидные и весьма многословные случаи.

Здравствуйте, sunshine, Вы писали:

КД>>Полюбил я ключевое слово var всей душой и телом. И юзаю его везде где только можно.

S>С точки зрения читателя такого кода, это очень неудобно.
S>Это создает лишние трудности для его понимания.
S>Выглядит это просто так, что человеку лень даже тип указать.
S>Такое нецелевое использование, на мой взгляд, признак дурного тона в программировании.

Коротко говоря — лично мне все это по-барабану

Потому что меня прёт