Правильно ли перехватывать каждое исключение с помощью класса исключений ??? Если нет, то что?

Question

Правильно ли перехватывать каждое исключение с помощью класса исключений ???Если нет, то какая должна быть правильная последовательность для перехвата исключения в блоке try catch?

например,

try{
       .
       .
       some code
       .
   }
   catch(Exception ex)
   {
       throw ex;
   }

Answer 1

Нет, это неправильно.

1. Поймать только для того, чтобы бросить снова, бессмысленно.

2. Он неправильно отбрасывает, что приводит к потеретрассировки стека.Правильный способ перебрасывания (когда перебрасывание имеет смысл, то есть) заключается в следующем: throw;

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

Итог: поймайте только те исключения, с которыми вы знаете, что делать.

Answer 2

Если вы генерируете исключение сразу после того, как поймаете его - это практически то же самое, что совсем не иметь блока try / catch.

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

Например, вы пытаетесь сохранить файл, но по какой-то причине его невозможно записать:

    try
    {
      SaveFile();
    }
    catch(FileIsReadOnlyException)
    {
      //do whatever to recover
    }
    catch(Exception ex)
    {
      //If we hit the generic exception, we're saying that we basically have 
      //no idea what went wrong, other than the save failed.
      //
      //Depending on the situation you might want to sink and log it, i.e. do nothing
      //but log it so you can debug and figure out what specific exception handler to
      //add to your code -- or you might want to try to save to a temporary file and
      //exit the program.
      //
      //If you were UpdatingAnAdvertisement() or doing something else non-critical
      //to the functioning of the program, you might just let it continue and
      //do nothing.
      //
      //In that case, you can just omit the generic catch.
    }

Answer 3

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

try
{
    // ...  some code that you know may throw ArgumentException or any other known exceptions
}
catch (ArgumentException ex)
{
    // ... handle the exception with a good idea of why it was thrown
}

В блоке catch вы теперь можете обработать ошибку чистым, специфическим способом, зная, что где-то в блоке try был передан недопустимый аргумент.Например, вы могли бы предупредить пользователя о том, что он предоставил неверный аргумент.

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

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

Имеет смысл?

Answer 4

Всегда сначала отлавливайте наиболее конкретные исключения.

    try
    {
        // some file system code
    }
    catch (DirectoryNotFoundException e1)
    {
        // do something about it
    }
    catch (IOException e2)
    {
        // do something else about it
    }
    catch (Exception e)
    {
        // most generic catch - probably just dump onto screen or error log
    }

Rethrowing сделан для облегчения отладки - это не способ сообщить пользователю об ошибке. Правильный способ сделать это:

    try
    {
        // some code that does X
    }
    catch (Exception e)
    {
        throw new Exception("describe X and parameters to it where applicable", e);
    }

Answer 5

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

Что касается случаев, когда вы должны перехватывать исключение, хорошее эмпирическое правило заключается в том, что исключение необходимо перехватывать в тот момент, когда вы хотите, чтобы ваш код ОБРАБОТАЛ об исключении.