Использование ключевого слова var в C #

После обсуждения с коллегами по поводу использования ключевого слова 'var' в C # 3 мне было интересно, что люди думают о подходящем использовании вывода типов через var?

Например, я довольно лениво использовал var в сомнительных обстоятельства, например: -

foreach(var item in someList) { // ... } // Type of 'item' not clear.
var something = someObject.SomeProperty; // Type of 'something' not clear.
var something = someMethod(); // Type of 'something' not clear.

Более законное использование var таковы: -

var l = new List<string>(); // Obvious what l will be.
var s = new SomeClass(); // Obvious what s will be.

Интересно, что LINQ выглядит немного серой, например: -

var results = from r in dataContext.SomeTable
              select r; // Not *entirely clear* what results will be here.

Ясно, какие результаты будут в том, что это будет тип, который реализует IEnumerable, однако это не совсем очевидно в том же смысле, что и var, объявляющий новый объект.

Еще хуже, когда речь идет о LINQ для объектов, например: -

var results = from item in someList
              where item != 3
              select item;

Это не лучше, чем эквивалентный foreach (var item в someList) {// ...} эквивалентный.

Здесь существует реальная проблема безопасности типов - например, если бы мы поместили результаты этого запроса в перегруженный метод, который принимал IEnumerable и IEnumerable , то вызывающая сторона могла бы непреднамеренно передать неверный тип.

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

406
задан 10 revs, 7 users 57% 3 February 2015 в 03:25
поделиться

54 ответа

Я все еще думаю var, может сделать код более читаемым в некоторых случаях. Если у меня будет Потребительский класс со свойством Orders, и я хочу присвоить это переменной, я просто сделаю это:

var orders = cust.Orders;

я не забочусь если Клиент. Заказы IEnumerable<Order>, ObservableCollection<Order> или BindingList<Order> - все, что я хочу, должен сохранить тот список в памяти, чтобы выполнить итерации по нему или получить ее количество или что-то позже.

Контраст вышеупомянутое объявление с:

ObservableCollection<Order> orders = cust.Orders;

мне, имя типа является просто шумом. И если я возвращаюсь и решаю изменить тип Клиента. Заказы вниз дорожка (говорят от ObservableCollection<Order> до IList<Order>) тогда я должен изменить то объявление также - что-то, что я не должен был бы делать, если я использовал var во-первых.

293
ответ дан 2 revs, 2 users 95% 3 February 2015 в 03:25
поделиться
  • 1
    Можно ли сказать, как использовать этот класс в действии? – Vins 9 July 2013 в 10:42

Я нахожу, что использование ключевого слова var на самом деле делает код более читаемым, потому что Вы просто привыкаете к пропуску ключевого слова 'var'. Вы не должны продолжать прокручивать право выяснить то, что делает код, когда Вы действительно не заботитесь о том, каков определенный тип. Если я действительно должен знать то, что тип 'объект' ниже, я просто толплюсь, моя мышь по нему и Visual Studio скажут мне. Другими словами, я очень читал бы

foreach( var item in list ) { DoWork( item ); }

много раз, чем

foreach( KeyValuePair<string, double> entry in list ) { DoWork( Item ); }

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

- Alan.

1
ответ дан AlanR 3 February 2015 в 03:25
поделиться
  • 1
    Большой ответ - получил меня идущий в правильном направлении. Учитывая синтаксис для asType не работал, но c.newInstance(delegate) сделал для меня. – Armand 25 September 2012 в 09:58

kronoz - в этом случае (перегрузки для обоих) это имело бы значение? Если у Вас будет две перегрузки, которые взяли различные типы, то Вы будете по существу говорить, что любой может быть передан и сделать то же самое.

у Вас не должно быть двух перегрузок, которые делают совершенно другие действия в зависимости от типов передали.

, В то время как Вы могли бы получить некоторый беспорядок в том экземпляре, это все еще будет совершенно безопасно с точки зрения типов, у Вас просто был бы кто-то называющий неправильный метод.

1
ответ дан Keith 3 February 2015 в 03:25
поделиться

Я должен согласиться с Matt Hamilton .

Var может сделать Ваш код намного более читаемым и понятным, когда используется с хорошими именами переменной. Но var может также сделать Ваш код столь же невозможным читать и понять как Perl, когда используется плохо.

список А хорошего и плохого использования var действительно не собирается помогать многому также. Это - случай для здравого смысла. Большим вопросом является одна из удобочитаемости по сравнению со способностью записи. Много devs не заботится, читаем ли их код. Они просто не хотят вводить столько же. Лично я - чтение>, пишут парню.

1
ответ дан 2 revs 3 February 2015 в 03:25
поделиться

Я использую var в следующих ситуациях:

  1. , Когда я имею к (результат является анонимным)
  2. , Когда тип находится на той же строке как код, например,

    var emp = новый Сотрудник ();

Его очевидное мы хотим Сотрудника (потому что мы создаем новый объект Сотрудника), поэтому как

Employee emp = new Employee() any more obvious?

, я НЕ использую var, когда тип не может быть выведен, например,

var emp = GetEmployee();

, поскольку тип возврата не сразу очевиден (в Сотруднике, IEmployee, что-то, что не имеет никакого отношения к объекту Сотрудника вообще и т.д.?).

1
ответ дан Giovanni Galbo 3 February 2015 в 03:25
поделиться
  • 1
    это - единственный ответ, который работал на меня 3 здесь – Alex 15 August 2013 в 20:26

В нашем офисе наш технический директор категорически запретил использование ключевого слова var по тем же причинам, что Вы заявили.

Лично я нахожу использование var только допустимым в новых объектных объявлениях, так как тип объекта очевиден в самом операторе.

Для запросов LINQ, можно разрешить результаты к:

IEnumerable<TypeReturnedBySelectObject>
1
ответ дан Jon Limjap 3 February 2015 в 03:25
поделиться
  • 1
    Это должно быть принятым ответом. Так уберите и работы – Peter 3 October 2013 в 00:31

Я не понимаю, почему люди запускают дебаты как это. Это действительно не служит никакой цели, чем запустить войны пламени, в тогда конце которых ничто не получено. Теперь, если команда C# пыталась постепенно сократить один стиль в пользу другого, я вижу причину спорить по достоинствам каждого стиля. Но так как оба собираются остаться на языке, почему бы не использовать один Вы предпочитаете и позволяете всем сделать то же. Это похоже на использование общего любимого тернарного оператора: некоторым нравится он, и некоторые не делают. В конце дня это не имеет никакого значения к компилятору.

Это похоже на утверждение с Вашими одноуровневыми элементами, по которым Ваш любимый родитель: это не имеет значения, если они не разводятся!

1
ответ дан Tundey 3 February 2015 в 03:25
поделиться

@erlando, из любопытства, почему необходимо знать тип переменной, смотрящий на исходный код?

В моей практике я нашел, что тип переменной является вопросом для меня только в то время, когда я использую его в коде.

, Если я пытаюсь сделать некоторую несоответствующую операцию на , компилятор someVar с удовольствием дает мне error\warning.

я действительно не забочусь о том, что имеет тип someVar , если я понимаю , почему он используется это данный контекст.

1
ответ дан aku 3 February 2015 в 03:25
поделиться

@Keith -

В Вашем сравнении между IEnumerable< int> и IEnumerable< double> Вы не должны волноваться - при передаче неправильного типа код не скомпилирует так или иначе.

, Который не довольно верен - если метод перегружается обоим IEnumerable< int> и IEnumerable< double> тогда это может тихо передать неожиданный выведенный тип (из-за некоторого другого изменения в программе) к неправильной перегрузке, следовательно вызывающей неправильное поведение.

я предполагаю, что вопрос состоит в том, как, вероятно, случается так, что этот вид ситуации подойдет!

я предполагаю, что часть проблемы - то, сколько var беспорядка добавляет к данному объявлению - если не ясно, что вводит что-то, (несмотря на то, чтобы быть со строгим контролем типов и компилятор, понимающий полностью, что вводит его), кто-то мог бы замять ошибку безопасности типов, или по крайней мере занять больше времени для понимания части кода.

0
ответ дан 2 revs, 2 users 92% 3 February 2015 в 03:25
поделиться
  • 1
    Я думал бы что, так как это уже имеет литеральное представление в JavaScript, который перевел бы хорошо в JSON; я предполагаю нет. – canon 22 August 2012 в 15:00

Один конкретный случай, где var является трудным: офлайн кодируйте обзоры, особенно те сделанные на бумаге.

Вы не можете полагаться на наведения мыши для этого.

17
ответ дан Jon Limjap 3 February 2015 в 03:25
поделиться
  • 1
    Та константа является настоящим ртом ffffffffull. – sbi 12 July 2010 в 17:12

В Вашем сравнении между IEnumerable<int> и IEnumerable<double> Вы не должны волноваться - при передаче неправильного типа код не скомпилирует так или иначе.

нет никакой озабоченности по поводу безопасности типов, как var не динамичные. Это - просто волшебство компилятора и любой тип небезопасные вызовы, Вы составляете завещание, пойманы.

Var абсолютно необходим для Linq:

var anonEnumeration =
    from post in AllPosts()
    where post.Date > oldDate
    let author = GetAuthor( post.AuthorId )
    select new { 
        PostName = post.Name, 
        post.Date, 
        AuthorName = author.Name
    };

Теперь взгляд anonEnumeration в intellisense и это появится что-то как IEnumerable<'a>

foreach( var item in anonEnumeration ) 
{
    //VS knows the type
    item.PostName; //you'll get intellisense here

    //you still have type safety
    item.ItemId;   //will throw a compiler exception
}

, компилятор C# довольно умен - скоро вводит сгенерированный, отдельно будет иметь тот же сгенерированный тип, если их свойства будут соответствовать.

За пределами этого, пока у Вас есть intellisense, который это проявляет здравый смысл использовать var где угодно, контекст ясен.

//less typing, this is good
var myList = new List<UnreasonablyLongClassName>();

//also good - I can't be mistaken on type
var anotherList = GetAllOfSomeItem();

//but not here - probably best to leave single value types declared
var decimalNum = 123.456m;
7
ответ дан 3 revs 3 February 2015 в 03:25
поделиться
  • 1
    Вы don' t должны сделать что-либо специальное, чтобы заставить это работать, но необходимо удостовериться, что Вы - not' t устанавливающий значения MYCONST несколько раз - именно это вызывает предупреждение Вас, видят. Удостоверьтесь, что Вы - not' t использующий любое метапрограммирование или операторы оценки для установки MYCONST также, потому что они вызовут ту же проблему. – Pan Thomakos 7 February 2011 в 19:31

@erlando,

Разговор о рефакторинге это, кажется, намного легче изменить тип переменной путем присвоения экземпляра нового типа к одной переменной скорее тогда изменение его в нескольких местах, не так ли?

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

, Таким образом, я повторяю свой вопрос. , Почему тип переменной имеет значение для Вас?

0
ответ дан 2 revs 3 February 2015 в 03:25
поделиться

Я не вижу, каково грандиозное предприятие..

var something = someMethod(); // Type of 'something' not clear <-- not to the compiler!

у Вас все еще есть полный intellisense на 'чем-то', и для какого-либо неоднозначного случая у Вас есть свои модульные тесты, правильно? (Вы?)

Это не varchar, это не тускло, и это - конечно, не динамический контроль типов или слабый контроль типов. Это останавливает maddnes как это:

List<somethinglongtypename> v = new List<somethinglongtypename>();

и сокращение, что общее количество mindclutter к:

var v = new List<somethinglongtypename>();

Хороший, не совсем столь же хороший как:

v = List<somethinglongtypename>();

, Но тогда это - то, для чего Шиканье .

17
ответ дан Frep D-Oronge 3 February 2015 в 03:25
поделиться
  • 1
    Измените свой ответ от " современная работа sytems" к " господствующая тенденция, работающая sytems". я работаю над несколькими современными операционными системами, где Вы отвечаете, не будет применяться. – Brian Neal 12 July 2010 в 23:13

Это - вопрос вкуса. Все это беспокоящееся тип переменной исчезает, когда Вы привыкаете на динамически типизированные языки. Таким образом, , если Вы когда-нибудь начинаете любить их (я не уверен, могут ли все, но я делаю).

C# var довольно прохладен в этом он взгляды как динамический контроль типов, но на самом деле статичен ввод - компилятор осуществляет корректное использование.

тип Вашей переменной не действительно настолько важен (это было сказано прежде). Это должно быть относительно ясно из контекста (его взаимодействия с другими переменными и методами), и его имя - не ожидают customerList содержать int...

я все еще ожидаю для наблюдения то, что мой босс думает об этом вопросе - я заставил общее "разрешение" использовать какие-либо новые конструкции в 3,5, но что мы сделаем об обслуживании?

8
ответ дан Daren Thomas 3 February 2015 в 03:25
поделиться

@aku: Одним примером являются обзоры кода. Другой пример осуществляет рефакторинг сценарии.

В основном я не хочу идти поиск типа со своей мышью. Это не могло бы быть доступно.

8
ответ дан erlando 3 February 2015 в 03:25
поделиться
  • 1
    Уверенный - я получаю это. С включением AASM в ' Amodule' wasn' t предоставление мне способность назвать последующие методы, которые AASM делает доступным, таким образом, у меня создалось впечатление, что так или иначе я должен был переписать методы AASM для отношений к классу, который в конечном счете реализует эти состояния. – Mike 7 February 2011 в 19:20

Я думаю, что ключевая вещь с VAR состоит в том, чтобы только использовать его, где соответствующий т.е. при выполнении вещей в Linq, который это упрощает (и вероятно в других случаях).

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

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

другая вещь помнить состоит в том, что не VB вводит var, в котором он не может изменить типы - это переменная со строгим контролем типов его просто, что тип выведен (который является, почему существуют люди, которые будут утверждать, что ее весьма разумное для использования его в, скажем, foreach, но я не согласился бы по причинам и удобочитаемости и пригодности для обслуживания).

я подозреваю, что этот собирается работать и работать (-:

Murph

10
ответ дан Murph 3 February 2015 в 03:25
поделиться
  • 1
    Возможный? Действительно? Ваша библиотека может знать, прежде чем она будет скомпилирована и связана, являются ли приложения, с которыми она будет связана, многопоточными (несколько стеков) или используют DLLs (несколько "кучи")? – Steve314 12 July 2010 в 19:24

Я думаю, что использование var должно быть вместе с мудро выбранными именами переменной.

у меня нет проблемы с помощью var в foreach операторе, если он не похож на это:

foreach (var c in list) { ... }

, Если это больше было похоже на это:

foreach (var customer in list) { ... }

... тогда кто-то читающий код, намного более вероятно, понял бы, каков "список". Если Вы управляете названием самой переменной списка, это еще лучше.

то же может относиться к другим ситуациям. Это довольно бесполезно:

var x = SaveFoo(foo);

..., но это имеет смысл:

var saveSucceeded = SaveFoo(foo);

Каждый к его собственному, я предполагаю. Я делал это, которое просто безумно:

var f = (float)3;

мне нужна своего рода программа var с 12 шагами. Меня зовут Матовый, и я (ab) использую var.

53
ответ дан 2 revs 3 February 2015 в 03:25
поделиться
  • 1
    нет, это не будет работать. стек растет к меньшим адресам, таким образом, для любого локального var адрес будет больше, чем ESP. Но поскольку вся голова обращается к этому оператору, также будет верно – Andrey 12 July 2010 в 17:46

Статический контроль типов о контрактах, не исходном коде. Идея там является потребностью иметь статическую информацию об одной строке того, что "должно" быть маленьким методом. Общие инструкции редко рекомендуют превысить 25 строк на метод.

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

На самом деле, один из больших аргументов в пользу var - то, что он может сделать рефакторинг более простым, потому что Вы больше не должны волноваться, что сделали свое объявление чрезмерно строгим (т.е. Вы использовали List<>, когда необходимо было использовать IList<>, или IEnumerable<>). Вы все еще хотите думать о новой подписи методов, но по крайней мере Вы не должны будете возвратиться и изменить свои объявления для соответствия.

2
ответ дан nedruod 3 February 2015 в 03:25
поделиться
  • 1
    Я думаю, что лучшее решение приезжает те строки, но необходимо знать направление стека. – Alexandre C. 12 July 2010 в 17:07

После просто преобразования в 3,0 и 3,5 платформы я узнал об этом ключевом слове и решил дать ему водоворот. Прежде, чем фиксировать любой код у меня было понимание, что это казалось назад, как в возвращении к синтаксису ASP. Таким образом, я решил ввести более высокие взлеты по абсолютному адресу для наблюдения то, что они думали.

Они сказали разрешение, таким образом, я использую его.

После этих слов я избегаю использования его, где тип требует некоторого расследования, как это:

var = компания. GetRecords ();

Теперь это могла просто быть персональная вещь, но я сразу наклоняю взгляд на это и определяю - ли это набор Рекордных объектов или массива строк, представляющего название записей. Какой бы ни случай, я верю явному объявлению, полезен в таком экземпляре.

2
ответ дан Pat 3 February 2015 в 03:25
поделиться
  • 1
    В современной операционной системе любит " stack" может не обязательно быть реализован как " данные стека structure". я не забываю читать статью, где они пытались предотвратить стек превышенное использование путем помещения сегментов стека случайным образом через память (т.е. как часть "кучи"). Если Ваша ОС использует эту технику тогда, Вы являетесь неудачливыми. – Martin York 12 July 2010 в 18:18

Кому-то не нравится критика var.. Все ответы downmodded.. о, хорошо..

@Jon Limjap: Я знаю.:), Что я имел в виду, был то, что удобочитаемость ухудшается как он, находится в VB6. Мне не нравится полагаться на Intellisense для выяснения то, что вводит данную переменную. Я хочу быть в состоянии изобразить его использование одного только источника.

Соглашения о присвоении имен не помогают ни одному - я уже использую хорошие имена. Мы возвращаемся к добавлению префикса?

3
ответ дан erlando 3 February 2015 в 03:25
поделиться
  • 1
    StackOverflow приехал к говорящим корреспондентам, они - " выполнение его wrong" для 85.5k представителя Sweeeeet. I' m любопытный, почему Martijn думает, что он хочет сделать это также, но почему отчитывают его? Позвольте ему экспериментировать. – Heath Hunnicutt 12 July 2010 в 17:05

У меня было то же беспокойство, когда я начал использовать ключевое слово var .
Однако я привыкал к нему со временем и не собирающийся возвращаться к явным типам переменных. compiler\intellisense Visual Studio делают очень хорошее задание при создании работы с намного легче переменными с неявно определенным типом.

я думаю, что следование надлежащим соглашениям о присвоении имен может помочь Вам понять код намного лучше тогда явная типизация.

Это, кажется, тот же вид вопросов как, "shoud я использую префиксы в именах переменной?".
Палка с хорошими именами переменной и позволяют компилятору думать на типах переменных.

3
ответ дан 2 revs 3 February 2015 в 03:25
поделиться
  • 1
    Я добираюсь и соглашаюсь с Вашей основной точкой зрения, но этим doesn' t означают I' m не позволенный не согласиться с некоторой деталью Вы сделали по пути. Вы действительно говорили " platform-dependent" таким образом, бонусные очки для этого, но даже тогда..., например, "куча" является просто структурой данных - it' s ошибка принять его должен быть реализован " platform". даже игнорируя проблемы пользовательских средств выделения, there' s также проблема нескольких компиляторов для нескольких DLLs - каждый с ее собственным временем выполнения и поэтому it' s владеют реализацией "кучи". – Steve314 13 July 2010 в 18:21

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

По общему признанию, это может означать, что не ясно, что вводит, мы имеем дело с.И что же? Это - на самом деле точка разъединенного дизайна. При контакте с интерфейсами Вы решительно не заинтересованы типом, который имеет переменная. var берет это гораздо дальше, верный, но я думаю, что аргумент остается тем же с точки зрения удобочитаемости: программист не должен на самом деле интересоваться типом переменной, а скорее в том, что переменная делает . Поэтому Microsoft также называет вывод типа “duck вводом. ”

Так, что делает переменная, когда я объявляю его с помощью var? Легкий, это делает любой IntelliSense, говорит мне, что это делает. Любое обоснование о C#, который игнорирует IDE, далеко от действительности. На практике каждый код C# программируется в IDE, который поддерживает IntelliSense.

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

Теперь, команда C# выпустила инструкцию по кодированию, заявив, что var должен [только 1 113] использоваться для получения результата оператора LINQ, который создает анонимный тип (потому что здесь, у нас нет реальной альтернативы var). Ну, винт это. Пока команда C# не дает мне звуковой аргумент в пользу этой инструкции, я собираюсь проигнорировать его, потому что по моему профессиональному и личному мнению, это - чистый вздор. (Извините; у меня нет ссылки на рассматриваемую инструкцию.)

На самом деле, существуют немного (поверхностно) хорошие объяснения на том, почему Вы не должны использовать var, но я все еще полагаю, что они в основном неправы. Возьмите пример “searchabililty”: автор утверждает, что var сложно искать места, где MyType используется. Право. Сделайте интерфейсы. На самом деле, почему я хотел бы знать, где класс используется? Я мог бы больше интересоваться тем, где это инстанцируют, и это все еще будет доступно для поиска, потому что где-нибудь его конструктор должен быть вызван (даже если это сделано косвенно, имя типа должно быть упомянуто где-нибудь).

168
ответ дан Konrad Rudolph 3 February 2015 в 03:25
поделиться
  • 1
    @KirkWoll, мой комментарий был на меньшем контексте, ответе для комментария выше: как проверить, осуществляются ли FKs на DB; это вне контекста ответа на вопрос. Так: Вы правы: каждый не имеет никакого отношения к другому. – van 8 January 2014 в 19:17

Я разделил var на всем протяжении мест, единственные сомнительные места для меня являются внутренними короткими типами, например, Я предпочитаю int i = 3; [более чем 111]

5
ответ дан robi-y 3 February 2015 в 03:25
поделиться

Я думаю, что люди не понимают ключевого слова var. Они путают его с Visual Basic / ключевое слово JavaScript, которое является различным зверем весь toghether.

Многие люди думают, что ключевое слово var подразумевает слабый контроль типов (или динамический контроль типов), в то время как на самом деле c# и остается со строгим контролем типов.

, Если Вы рассматриваете это в JavaScript:

var something = 5;

Вам разрешают:

something = "hello";

В случае c#, компилятор вывел бы тип из первого оператора, заставив что-то быть типа "интервалом", таким образом, второй оператор приведет к исключению.

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

Уверенный ключевое слово var было представлено для поддержки анонимных типов, но если Вы смотрите на это:

LedDeviceController controller = new LedDeviceController("172.17.0.1");

Это является очень очень подробным, и я уверен, что это столь же читаемо, если не больше:

var controller = new LedDeviceController("172.17.0.1");

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

ОБНОВЛЕНИЕ:

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

1
ответ дан 2 revs 3 February 2015 в 03:25
поделиться
  • 1
    Я должен согласиться с @moby, было бы удобно, если бы была страница, выделенная только просмотру журналов, вместо того, чтобы нажать, нажмите, нажмите только для просмотра того. Кроме того их сайта является потрясающим. – Brad Moore 13 January 2014 в 05:20

Мне антипатия к var иллюстрирует, почему билингвизм в.NET важен. Тем программистам C#, которые также сделали.NET VB, преимущества var интуитивно очевидны. Стандартное объявление C#:

List<string> whatever = new List<string>();

эквивалент, в.NET VB, ввода этого:

Dim whatever As List(Of String) = New List(Of String)

Никто не делает это в.NET VB, все же. Было бы глупо, потому что начиная с первой версии.NET Вы были в состоянии сделать это...

Dim whatever As New List(Of String)

..., который создает переменную и инициализирует все это в одной довольно компактной строке. А-ч, но что, если Вы хотите IList<string>, не List<string>? Ну, в.NET VB, которая означает, необходимо сделать это:

Dim whatever As IList(Of String) = New List(Of String)

Точно так же, как Вы должны были бы сделать в C#, и очевидно не могли использовать var для:

IList<string> whatever = new List<string>();

, Если Вы потребность тип, чтобы быть чем-то другим, это может быть. Но один из основных принципов хорошего программирования уменьшает дублирование, и это точно, что делает var.

6
ответ дан Ryan Lundy 3 February 2015 в 03:25
поделиться
  • 1
    Необходимо, вероятно, просто использовать std::set, никакая потребность отобразиться на что-либо. Кроме того, это должно быть удалено в, удаляют? – GManNickG 12 July 2010 в 18:02

Используйте его для анонимных типов - это - то, для чего это там. Что-либо еще - использование слишком далеко. Как многие люди, которые росли на C, я привык смотреть слева от объявления для типа. Я не смотрю на правую сторону, если я не имею к. Используя var для любого старого объявления заставляет меня сделать это все время, которое я лично нахожу неудобными.

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

Стандарты являются хорошей вещью точно, потому что они означают, что Вы то, что намного более вероятно быть в состоянии взять случайный код и быть в состоянии к grok она быстро. Чем больше вещей, которые отличаются, тем тяжелее, который добирается. И перемещаясь в 'var везде' стиль делает большой различие.

я не возражаю против динамического контроля типов, и я не возражаю против implict, вводящего - на языках, которые разработаны для них. Мне вполне нравится Python. Но C# был разработан как статически явно-типизированный-язык, и это - то, как это должно остаться. Нарушение правил для анонимных типов было достаточно плохо; позволяющие люди берут это еще далее и повреждают идиомы языка, еще больше - что-то, чем я не доволен. Теперь, когда джин вне бутылки, она никогда не будет возвращаться в. C# станет balkanised в лагеря. Не хороший.

6
ответ дан Neil Hewitt 3 February 2015 в 03:25
поделиться
  • 1
    Это должно быть принятым ответом. Я чувствую, что это наиболее тесно обращается к OP' s вопрос и делает так лучшим способом, чем принятый в настоящее время ответ. – rory.ap 30 December 2013 в 18:35

От Eric Lippert, Главного Инженера-разработчика программного обеспечения в команде C#:

, Почему var ключевое слово было представлено?

существует две причины, та, которая существует сегодня, тот, который неожиданно возникнет в 3,0.

первая причина состоит в том, что этот код невероятно ужасен из-за всего дублирования:

Dictionary<string, List<int>> mylists = new Dictionary<string, List<int>>();

И это - простой приме𠆓, я записал хуже. Любое время Вы вынуждены ввести точно то же самое дважды, это - дублирование, которое мы можем удалить. Намного более хороший записать

var mylists = new Dictionary<string,List<int>>();

и позволить компилятору выяснить то, что тип основан на присвоении.

1116-секундный, C# 3.0 представляет анонимные типы. Так как анонимные типы по определению не имеют никаких имен, Вы потребность , чтобы быть в состоянии вывести тип переменной от выражения инициализации, если его тип является анонимным.

шахта Emphasis. Целая статья, C# 3.0 все еще со статическим контролем типов, честен! , и следующее серии довольно хороши.

Это - то, для чего var. Другое использование, вероятно, не будет работать так хорошо. Любое сравнение с JScript, VBScript или динамическим контролем типов является общей койкой. Отметьте снова, var , потребовал для имения определенной другой работы функций в.NET.

68
ответ дан 2 revs, 2 users 99% 3 February 2015 в 03:25
поделиться
  • 1
    @Alexandre Да, это - эмпирическая вещь действительно. Это никогда не будет давать Вам удовлетворяющий ответ, но будет подавлять Ваше любопытство и преподавать Вам что-то расположению памяти. – Gianni 12 July 2010 в 17:09

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

Для меня, который исключает аргумент, что компилятор "знает" то, что вводит переменную, - уверен, Вы не можете записать недопустимому коду первый раз, потому что компилятор мешает Вашему коду компилировать, но когда следующий разработчик читает код через 6 месяцев, они должны быть в состоянии вывести то, что переменная делает правильно или неправильно и быстро определите причину проблем.

Таким образом,

var something = SomeMethod();

вне закона по нашим стандартам кодирования, но следующее поощряется в нашей команде, потому что это увеличивает удобочитаемость:

var list = new List<KeyValuePair<string, double>>();
FillList( list );
foreach( var item in list ) {
   DoWork( item ); 
}
40
ответ дан 3 revs, 3 users 93% 3 February 2015 в 03:25
поделиться
  • 1
    @Andrey Как я сказал в комментарии выше, это won' t работают во многих случаях, но с другой стороны, я don' t думают, что что-либо будет; кроме полноценного сравнения всех указателей вершины стека и стека базируется и имеющий глубокие знания Вашего program' s расположение в RAM. – Gianni 12 July 2010 в 18:01

var важно для анонимных типов (как указано в одном из предыдущих ответов на этот вопрос).

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

var i = 5;
int j = 5;

SomeType someType = new SomeType();
var someType = new SomeType();

... совершенно субъективно.

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

0
ответ дан Richard Everett 3 February 2015 в 03:25
поделиться

Я не использую var, поскольку он идет вразрез с корнями C# - C/C ++/Java. Даже при том, что это - прием компилятора, это заставляет язык чувствовать, что это менее со строгим контролем типов. Возможно, 20 + годы C укоренили все это в наш (люди антиvar) головы, что у нас должен быть тип на обоих левая и правая сторона равняния.

сказавший, что я вижу его достоинства для длинных определений универсального набора и долгих имен классов как пример codinghorror.com, но в другом месте, таких как string/int/bool я действительно не вижу точку. Особенно

foreach (var s in stringArray)
{

}

сохранение 3 символов!

основное раздражение для меня не способно видеть тип, который var представляет для вызовов метода, если Вы не нависаете над методом или F12 он.

0
ответ дан 2 revs 3 February 2015 в 13:25
поделиться
Другие вопросы по тегам:

Похожие вопросы: