Как далеко должны 'var' и оператор объединения нулей '??' развлекаться без ущерба для читабельности?

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

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

Мой вопрос: разве не происходит то же самое, когда вы начинаете использовать var?

Нулевой оператор объединения (??)

Лично я не вижу никаких минусов в использовании этого оператора. Рассмотрим следующие три примера кода, от «простых» до «сложных» новых операторов.

Без магии:

bool isNameSet = false;
string name;
if ( isNameSet )
{
    Console.WriteLine( name );
}
else
{
    Console.WriteLine( "No name set." );
}

Тернарный оператор:

bool isNameSet = false;
string name;
Console.WriteLine( isNameSet ? name : "No name set." );

Нулевое слияние:

string name = null;
Console.WriteLine( name ?? "No name set." );

Причина, по которой эти операторы были изобретены, заключается в том, что они представляют собой очень распространенные операции программирования . Нежелание их использовать, потому что вы к ним не привыкли, просто упрямство . Языки развиваются, функции развиваются, учитесь ими пользоваться!

ключевое слово var

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

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

• Главным образом в циклах foreach , которые я узнал от Resharper, как это там. Большую часть времени вы знаете, какой тип коллекции вы просматриваете, поэтому вы знаете, что ожидаете элементы из этой коллекции.
• Linq запросы . Результатом запросов linq часто являются очень сложные универсальные типы. Отображение этого типа приносит больше вреда, чем пользы.
• Длинные имена, которые просто инициализируются их конструктором. Вы уже можете сказать, что это за тип, посмотрев на конструктор.

В качестве примера для последнего утверждения:

ThisIsSomeSpecializedTypeRightHere duplication =
    new ThisIsSomeSpecializedTypeRightHere();
var justAsReadable =
    new ThisIsSomeSpecializedTypeRightHere();  // Less duplication.

// But I still prefer the following ...
int number = 9;
SomeCreatedType foo = Factory.CreateSomeType();

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

...
foreach (var message in messages) {
  var label = Factory.CreateLabel();
  label.Text = message;
  Controls.Add(label);
}
...

Кому интересно, что это за тип метки, если она предоставляет свойство Text?

У меня нет серьезных комментариев по поводу ?? оператора, так как я никогда не использовал язык с таким оператором интенсивно. Что касается varлюдей, то они программируют на таких языках, как Ruby, Python, Perl и PHP, которые все время имеют полностью неявную типизацию. Уроженцы этих языков понимают, что формальный тип переменной обычно не имеет никакого отношения к шуму. Вас больше интересует, что может сделать переменная , то есть ее структурный / утиный интерфейс.

Точно так же я программирую в основном на D. D имеет статическую типизацию, но имеет auto ключевое слово, эквивалентное var. Считается идиоматичным использовать его везде, если только вы не видите особой необходимости подчеркивать тип чего-либо для читателя или (посредством неявного преобразования) компилятора. За исключением случая, когда он используется в качестве возвращаемого типа функции (это разрешено в D), я никогда не считал, что это затрудняет читабельность, потому что я в основном думаю о структурных / утиных интерфейсах, а не формальных / номинативных типах, когда я программирую.

Кроме того, IMHO использование varвезде, где это возможно, является хорошим примером СУХОГО. Тип чего-либо должен быть указан в одном и только одном месте, а затем автоматически распространяться всякий раз, когда это необходимо распространять. Если вы используете varи формальный тип переменной должен измениться в какой-то момент, необходимые изменения будут автоматически распространяться везде, где это необходимо компилятору, если программа все еще корректна по типу, а не программисту, который должен вручную изменять каждый экземпляр , Это хорошая вещь (ТМ).

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

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

var a = b ?? c ?? d ?? e ?? "";

это довольно однозначно для меня.

Тернарные операторы и dynamicдругое дело, конечно.

Аргумент за использование ?? Оператор был, он забирает читабельность в коде.

Кратко подумав об этом, этот комментарий говорит мне, что человек, делающий комментарий, не понимает его так, как он / она должен. Скорее всего, это верно в определенных ситуациях, но в целом я не сбрасываю со счетов то, что команда C # явно сочла достаточно важным, чтобы добавить его из-за «читабельности». Я положил это в той же категории if(boolean_object)против if(boolean_object == true). Некоторые люди утверждают, что второй более читабелен, но на самом деле он просто добавляет дополнительный код для чтения / ввода, а в некоторых ситуациях может быть более запутанным (думаю if(boolean_object != false))

Мой вопрос: разве не происходит то же самое, когда вы начинаете использовать var?

Команда C # позволила вам не определять то, что вы знаете, что это будет. Если мне абсолютно не нужно определять, какой будет переменная (либо абсолютно важно, чтобы возвращаемый объект имел тип x, либо он действительно не читался), я использую var. var x = "MY_STRING";Я знаю, что это строка, когда я смотрю на нее. По правде говоря, мне все равно, что это строка, если она делает то, что мне нужно. Определение типа переменной для меня, а не для компилятора. Если что-то не так, компилятор сообщит мне, когда он запустится, если у меня неправильный тип переменной.

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

Однако делать var text = "Some text " + variableName + "some more text."это просто лениво.

РЕДАКТИРОВАТЬ: @Jorg Вы вскочили на намеренно упрощенный ответ, но ничего не добавили к обсуждению. Хорошо, как об этом для лучшего примера: var items = doc.DocumentElement.FirstChild.ChildNodes;если вы сможете выяснить тип из этого, я дам вам печенье.

У меня есть фундаментальная проблема с использованием var.

В этом примере все бок о бок, но проблема действительно в больших решениях с общими библиотеками или проектами.

Учти это:

public MyFirstObject GetMeAnObject() {
    return new MyFirstObject();
}

public void MainProgram() {
    var theObject = GetMeAnObject();
    theObject.PerformOperation();
}

Что произойдет, если GetMeAnObject будет изменен кем-то другим в соответствии с их потребностями?

public MySecondObject GetMeAnObject() {
    return new MySecondObject();
}

Метод MainProgram будет иметь большую красную ошибку при .PerformOperation (). Что произошло? PerformOperation отлично работал раньше. Мы смотрим на методы объекта, и он просто исчезает без следа. Это было там в прошлый раз, и нам нужен этот метод. Вы могли бы потратить много времени, преследуя свой хвост и пытаясь выяснить, почему, если MyFirstObject имеет метод PerformOperation, его теперь нельзя увидеть. Все «знают», что GetMeAnObject возвращает MyFirstObject, поэтому нет смысла проверять это.

Если бы вы явно ввели theObject, то в строке, которая вызывает GetMeAnObject, возникла бы ошибка Invalid Cast, и было бы ослепительно очевидно, что GetMeAnObject возвращает тип, который отличается от ожидаемого.

Короче говоря, явное объявление означает, что вы знаете, что означают ошибки. Неверное приведение означает, что вы ожидали один тип, а другой тип был возвращен. Нераспознанный участник означает, что участник был не распознан.