Я знаю, что название вопроса очень субъективно, но я столкнулся с использованием ??
оператора моими коллегами, где в то же время я был не очень доволен / не чувствовал себя комфортно при применении var
в новом готовящемся коде.
Аргумент, приведенный для использования ??
оператора был, он убирает читабельность в коде.
Мой вопрос: разве не происходит то же самое, когда вы начинаете использовать var
?
c#
coding-style
readability
Ньюман
источник
источник
??
оператор null coalesce после его объяснения, он не должен быть допущен к рабочему коду.Ответы:
Нулевой оператор объединения (??)
Лично я не вижу никаких минусов в использовании этого оператора. Рассмотрим следующие три примера кода, от «простых» до «сложных» новых операторов.
Без магии:
Тернарный оператор:
Нулевое слияние:
Причина, по которой эти операторы были изобретены, заключается в том, что они представляют собой очень распространенные операции программирования . Нежелание их использовать, потому что вы к ним не привыкли, просто упрямство . Языки развиваются, функции развиваются, учитесь ими пользоваться!
ключевое слово var
У меня несколько иное мнение о ключевом слове var. Тип переменной часто дает дополнительную информацию о вашем коде. Я считаю, что сокрытие типа с помощью ключевого слова var иногда делает код менее читабельным. Вы меньше знаете, чего ожидать, не используя автоматическое завершение или наводя курсор на идентификаторы, чтобы увидеть, что они на самом деле. На мой взгляд, это приводит к коду, который медленнее для чтения / записи.
Я использую ключевое слово, когда обнаруживаю, что тип не дает много дополнительной информации.
В качестве примера для последнего утверждения:
источник
Factory.CreateSomeType
возвращаетсяIEnumerable<SomeType>
. Однажды, по какой-то причине, он меняется, чтобы вернутьсяSomeType[]
. Если вы использовали var, это просто перекомпиляция.Factory.CreateSomeType()
изменения, чтобы вернутьISomeType
?null
полностью. Кроме того, чем больше я ищу альтернативnull
, тем больше я понимаю, что использованиеnull
иногда является самым чистым решением. Мой приведенный пример не так уж и плох, ИМХО, и я считаю его подходящим использованием обнуляемых типов.var позволяет меньше подробного кода, что повышает удобочитаемость. По моему мнению, читаемость должна измеряться не тем, сколько деталей вы видите, а тем, сколько деталей скрыто на первый взгляд. Помимо примеров Linq, var позволяет вводить утки на уровне исходного кода, учитывая следующий пример:
Кому интересно, что это за тип метки, если она предоставляет свойство Text?
источник
У меня нет серьезных комментариев по поводу
??
оператора, так как я никогда не использовал язык с таким оператором интенсивно. Что касаетсяvar
людей, то они программируют на таких языках, как Ruby, Python, Perl и PHP, которые все время имеют полностью неявную типизацию. Уроженцы этих языков понимают, что формальный тип переменной обычно не имеет никакого отношения к шуму. Вас больше интересует, что может сделать переменная , то есть ее структурный / утиный интерфейс.Точно так же я программирую в основном на D. D имеет статическую типизацию, но имеет
auto
ключевое слово, эквивалентноеvar
. Считается идиоматичным использовать его везде, если только вы не видите особой необходимости подчеркивать тип чего-либо для читателя или (посредством неявного преобразования) компилятора. За исключением случая, когда он используется в качестве возвращаемого типа функции (это разрешено в D), я никогда не считал, что это затрудняет читабельность, потому что я в основном думаю о структурных / утиных интерфейсах, а не формальных / номинативных типах, когда я программирую.Кроме того, IMHO использование
var
везде, где это возможно, является хорошим примером СУХОГО. Тип чего-либо должен быть указан в одном и только одном месте, а затем автоматически распространяться всякий раз, когда это необходимо распространять. Если вы используетеvar
и формальный тип переменной должен измениться в какой-то момент, необходимые изменения будут автоматически распространяться везде, где это необходимо компилятору, если программа все еще корректна по типу, а не программисту, который должен вручную изменять каждый экземпляр , Это хорошая вещь (ТМ).источник
Я думаю, что это вопрос для команды в конце концов. Если он не доступен для чтения кому-либо еще в моей команде, я не буду его использовать, хотя я мог бы пару раз попытаться убедить их примерами или указать на анагональные сокращения (такие как + =), которые они считают более читабельными.
Однако если работать в одиночку, то я нахожу и вар в высшей степени читабельный без ограничений. Четное
это довольно однозначно для меня.
Тернарные операторы и
dynamic
другое дело, конечно.источник
var a = b ?? c ?? d ?? e ?? String.Empty ?? "";
String.Empty
когда-нибудь вернетсяnull
, нас ждет чертовски много неработающего кода.Кратко подумав об этом, этот комментарий говорит мне, что человек, делающий комментарий, не понимает его так, как он / она должен. Скорее всего, это верно в определенных ситуациях, но в целом я не сбрасываю со счетов то, что команда C # явно сочла достаточно важным, чтобы добавить его из-за «читабельности». Я положил это в той же категории
if(boolean_object)
противif(boolean_object == true)
. Некоторые люди утверждают, что второй более читабелен, но на самом деле он просто добавляет дополнительный код для чтения / ввода, а в некоторых ситуациях может быть более запутанным (думаюif(boolean_object != false)
)Команда C # позволила вам не определять то, что вы знаете, что это будет. Если мне абсолютно не нужно определять, какой будет переменная (либо абсолютно важно, чтобы возвращаемый объект имел тип x, либо он действительно не читался), я использую
var
.var x = "MY_STRING";
Я знаю, что это строка, когда я смотрю на нее. По правде говоря, мне все равно, что это строка, если она делает то, что мне нужно. Определение типа переменной для меня, а не для компилятора. Если что-то не так, компилятор сообщит мне, когда он запустится, если у меня неправильный тип переменной.источник
var
Ключевое слово, на мой взгляд, взял верх используется в ситуациях , для которых он был введен оригинальный - LINQ запросы. В этих запросах тип возвращаемого результата часто имеет какое-то большое запутанное имя, которое трудно определить заранее и не помогает читателю понять, что делает ваш код.Однако делать
var text = "Some text " + variableName + "some more text."
это просто лениво.РЕДАКТИРОВАТЬ: @Jorg Вы вскочили на намеренно упрощенный ответ, но ничего не добавили к обсуждению. Хорошо, как об этом для лучшего примера:
var items = doc.DocumentElement.FirstChild.ChildNodes;
если вы сможете выяснить тип из этого, я дам вам печенье.источник
"Some text "
этоstring
, то у вас есть гораздо более серьезные проблемы, чем количествоvar
s в вашем коде.var
; проблема в дерьмовом имени переменной "items". Если вы используете хорошее имя переменной, в этом нет ничего плохогоvar
.У меня есть фундаментальная проблема с использованием var.
В этом примере все бок о бок, но проблема действительно в больших решениях с общими библиотеками или проектами.
Учти это:
Что произойдет, если GetMeAnObject будет изменен кем-то другим в соответствии с их потребностями?
Метод MainProgram будет иметь большую красную ошибку при .PerformOperation (). Что произошло? PerformOperation отлично работал раньше. Мы смотрим на методы объекта, и он просто исчезает без следа. Это было там в прошлый раз, и нам нужен этот метод. Вы могли бы потратить много времени, преследуя свой хвост и пытаясь выяснить, почему, если MyFirstObject имеет метод PerformOperation, его теперь нельзя увидеть. Все «знают», что GetMeAnObject возвращает MyFirstObject, поэтому нет смысла проверять это.
Если бы вы явно ввели theObject, то в строке, которая вызывает GetMeAnObject, возникла бы ошибка Invalid Cast, и было бы ослепительно очевидно, что GetMeAnObject возвращает тип, который отличается от ожидаемого.
Короче говоря, явное объявление означает, что вы знаете, что означают ошибки. Неверное приведение означает, что вы ожидали один тип, а другой тип был возвращен. Нераспознанный участник означает, что участник был не распознан.
источник
var
? Нельзя ожидать, что язык защитит от такого поведения - что если бы они изменили MyFirstObject напрямую? Это все еще сломалось бы, но никакой синтаксис не мог бы вас спасти от этого. Я бы даже посчитал это сильнымvar
: что если вместо возврата MySecondObject вы теперь вместо этого возвращаете IMyFirstObject?