Как указать, когда намеренно игнорируется возвращаемое значение

Question

В некоторых ситуациях, использующих C / C ++, я могу синтаксически указать компилятору, что возвращаемое значение намеренно игнорируется:

int SomeOperation()
{
    // Do the operation

    return report_id;
}

int main()
{
    // We execute the operation, but in this particular context we
    // have no use of the report id returned.
    (void)SomeOperation();
}

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

Насколько я знаю, компилятор C # не будет жаловаться на неявно игнорируемые возвращаемые значения, но я хотел бы знать, есть ли подобное соглашение для использования, чтобы дать четкое указание другим разработчикам.

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

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

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

Mutex mtx = new Mutex();
(void)mtx.WaitOne();

Поскольку возвращаемое значение никогда не может быть чем-либо, кроме true.

Answer 1

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

SomeMethod(); // return value ignored - $REASON

Answer 2

Я могу вспомнить только одну ситуацию, когда «возвращаемое значение» нельзя игнорировать в C #: когда произошла ошибка. Это должно быть обеспечено путем генерирования исключения, которое делает невозможным игнорирование.

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

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

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

Я забыл случай?

Answer 3

С C # 7.0 и выше вы можете указать намеренно игнорируемые возвращаемые значения с помощью оператора отбрасывания '_'.

int SomeOperation()
{
    return report_id;
}

int main()
{
    _ = SomeOperation();
}

Для получения дополнительной информации вы можете посмотреть документацию Microsoft здесь .

Answer 4

Компилятор Microsoft C # не выдает предупреждение об игнорировании возвратов. В этом нет необходимости, поскольку имеется сборщик мусора, поэтому утечки памяти не будет из-за игнорирования возвращаемых объектов (если, конечно, они не являются IDisposable). Следовательно, нет необходимости явно «переопределять» компилятор.

РЕДАКТИРОВАТЬ: Кроме того, я считаю, что проблема "ремонтопригодности" больше похожа на проблему документации и практики именования. Я понимаю, что это был только пример, но вы не ожидаете, что метод с именем SomeOperation вернет ReportId. Однако можно ожидать, что метод GetReportId вернет ReportId без большого количества побочных эффектов. Действительно, игнорирование возвращаемого значения метода с именем GetReportId было бы довольно странным. Поэтому убедитесь, что вы правильно называете свои методы, и у людей не будет сомнений по поводу эффектов ваших вызовов функций.

РЕДАКТИРОВАТЬ 2: В этом примере мьютексов, я считаю, что правильное использование будет фактически не игнорировать возвращаемое значение. Даже если текущая реализация никогда не вернет false, я думаю, что хорошей практикой будет по-прежнему проверять возвращаемое значение, на случай, если вы в конечном итоге будете использовать другую реализацию в будущем или они изменят поведение в будущем выпуске .NET Framework или что-то:

if (mutex.WaitOne())
{
   // Your code here
}
else
{
   // Optionally, some error handling here
}

Answer 5

object dummy = JustDontCare();

Answer 6

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

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

Answer 7

Я видел:

var notUsed = SomeOperation();

Хотя это не очень нравится.

Answer 8

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

Тем не менее, компилятор C # выдаст ошибку синтаксиса.

Answer 9

Нет стандартных соглашений, о которых я знаю.

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