Обертывание всего в блоках попытки/выгоды составляют безопасное программирование?

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

, По моему опыту, 95% всех блоков выгоды или просто игнорируют исключение (catch {}) или просто регистрируют ошибку и повторно бросают исключение. Последний мог бы походить на правильный поступок, но на практике, когда это сделано на каждом уровне, Вы просто заканчиваете со своим журналом, нарушенным пятью копиями того же сообщения об ошибке. Обычно эти приложения имеют, "игнорируют выгоду" наверху большая часть уровня (так как "мы имеем, пробуют/ухватываются все более низкие уровни"), приводя к очень медленному приложению за большим количеством пропущенных исключений и журналу ошибок, что слишком долго для любого, чтобы быть готовым просмотреть его.

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

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

Иногда я вижу Попытку.. Система выгоды. Исключение, где блок выгоды просто регистрирует исключение и переброски. Существует по крайней мере 3 проблемы с тем подходом:

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

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

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

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

private String name;

public void setName(String name) {
}

, Как Вы обрабатываете имя == пустой указатель? Вы выдаете исключение, или Вы принимаете его? Если не имеет смысла иметь объект без имени, то необходимо выдать исключение. Что относительно имени ==""?

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

Другой пример:

public boolean isXXX (String s) {
}

Здесь, защитная стратегия состоит в том, чтобы часто возвращать false, когда s == пустой указатель (избегают NPEs, когда Вы можете).

Или:

public String getName() {
}

программист обороны А мог бы возвратиться "" если имя == пустой указатель для предотвращения NPEs в коде вызова.

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

• представление дружественного сообщения пользователю, и
• сохранение диагностики.

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

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

В целом, Если... Еще намного лучше, чем Попытка... Выгода.

Ловля случайных исключений плоха. Что тогда?

• Игнорируют их? Превосходный. Сообщите мне, как это работает на них.
• Регистрируют их и продолжают бежать? Я думаю нет.
• Выдают различное исключение как часть катастрофического отказа? Удача отлаживая это.

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

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

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

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

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

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

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

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

Я предполагаю, что реальный ответ, "Он зависит". Если бы блоки try-catch ловят очень универсальные исключения тогда, я сказал бы, что это - безопасное программирование таким же образом, что никогда изгнание из Вашего окружения является аккуратным вождением. Выгода попытки (imo) должна быть адаптирована в соответствии с определенными исключениями.

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

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

Слишком многие? Глаз наблюдателя.

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

Это, конечно, кажется "защитным" в обычном значении слова.

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