Навіщо ловити та повторно викидати виняток у C #?

Я переглядаю статтю C # - Об'єкт передачі даних про серіалізаційні DTO.

У статтю включений цей фрагмент коду:

public static string SerializeDTO(DTO dto) {
    try {
        XmlSerializer xmlSer = new XmlSerializer(dto.GetType());
        StringWriter sWriter = new StringWriter();
        xmlSer.Serialize(sWriter, dto);
        return sWriter.ToString();
    }
    catch(Exception ex) {
        throw ex;
    }
}

Інша частина статті виглядає розумною та розумною (для noob), але цей спробу-ловля кидає WtfException ... Хіба це не зовсім рівно, ніж взагалі не обробляти винятки?

Ergo:

public static string SerializeDTO(DTO dto) {
    XmlSerializer xmlSer = new XmlSerializer(dto.GetType());
    StringWriter sWriter = new StringWriter();
    xmlSer.Serialize(sWriter, dto);
    return sWriter.ToString();
}

Або я пропускаю щось принципове щодо обробки помилок у C #? Це майже те саме, що і Java (мінус перевірені винятки), чи не так? ... Тобто вони обоє вдосконалювали C ++.

Питання про переповнення стека Різниця між повторним закиданням без укладання параметрів і нічого не робить? Мабуть, підтримує моє твердження, що пробувати-кидати - не-оп.

Редагувати:

Просто підвести підсумок для тих, хто знайде цю тему в майбутньому ...

НЕ

try {
    // Do stuff that might throw an exception
}
catch (Exception e) {
    throw e; // This destroys the strack trace information!
}

Інформація про стеження стека може мати вирішальне значення для виявлення першопричини проблеми!

ДО

try {
    // Do stuff that might throw an exception
}
catch (SqlException e) {
    // Log it
    if (e.ErrorCode != NO_ROW_ERROR) { // filter out NoDataFound.
        // Do special cleanup, like maybe closing the "dirty" database connection.
        throw; // This preserves the stack trace
    }
}
catch (IOException e) {
    // Log it
    throw;
}
catch (Exception e) {
    // Log it
    throw new DAOException("Excrement occurred", e); // wrapped & chained exceptions (just like java).
}
finally {
    // Normal clean goes here (like closing open files).
}

Ловіть більш конкретні винятки перед менш конкретними (як і Java).

Список літератури:

• MSDN - Обробка виключень
• MSDN - спробу лову

Спочатку; те, що код у статті робить це, є злим. throw exскине стек викликів за винятком того пункту, де знаходиться цей оператор кидка; втрачаючи інформацію про те, де фактично створено виняток.

По-друге, якщо ви просто ловите та повторно кидаєтесь так, я не бачу додаткової вартості, приклад коду вище був би настільки ж хорошим (або, враховуючи throw exбіт, ще краще) без спроб улов.

Однак бувають випадки, коли ви можете зловити і повторно вигнати виняток. Одне з них може бути одним із журналів:

try 
{
    // code that may throw exceptions    
}
catch(Exception ex) 
{
    // add error logging here
    throw;
}

Не робіть цього,

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

Ви втратите інформацію про стежку стека ...

Або робити,

try { ... }
catch { throw; }

АБО

try { ... }
catch (Exception ex)
{
    throw new Exception("My Custom Error Message", ex);
}

Однією з причин, яку ви можете захопити, є, якщо ви обробляєте різні винятки, наприклад

try
{
   ...
}
catch(SQLException sex)
{
   //Do Custom Logging 
   //Don't throw exception - swallow it here
}
catch(OtherException oex)
{
   //Do something else
   throw new WrappedException("Other Exception occured");
}
catch
{
   System.Diagnostics.Debug.WriteLine("Eeep! an error, not to worry, will be handled higher up the call stack");
   throw; //Chuck everything else back up the stack
}

C # (до C # 6) не підтримує CIL "відфільтровані винятки", що робить VB, тому в C # 1-5 однією з причин повторного викидання винятків є те, що у вас не вистачає інформації під час лову () щоб визначити, чи хотіли ви насправді зловити виняток.

Наприклад, у VB можна зробити

Try
 ..
Catch Ex As MyException When Ex.ErrorCode = 123
 .. 
End Try

... який не обробляє MyExceptions з різними значеннями ErrorCode. У C # до версії v6 вам доведеться спіймати і перекинути MyException, якщо ErrorCode не було 123:

try 
{
   ...
}
catch(MyException ex)
{
    if (ex.ErrorCode != 123) throw;
    ...
}

Оскільки C # 6.0 ви можете фільтрувати так само, як і за допомогою VB:

try 
{
  // Do stuff
} 
catch (Exception e) when (e.ErrorCode == 123456) // filter
{
  // Handle, other exceptions will be left alone and bubble up
}

Моя основна причина наявності коду типу:

try
{
    //Some code
}
catch (Exception e)
{
    throw;
}

тому я можу мати точку перелому в улові, що має об'єкт екстремального винятку. Я роблю це багато під час розробки / налагодження. Звичайно, компілятор подає мені попередження про всі невикористані електронні повідомлення, і в ідеалі їх слід видалити перед збіркою релізу.

Хоча вони приємні під час налагодження.

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

public static string SerializeDTO(DTO dto) {
  try {
      XmlSerializer xmlSer = new XmlSerializer(dto.GetType());
      StringWriter sWriter = new StringWriter();
      xmlSer.Serialize(sWriter, dto);
      return sWriter.ToString();
  }
  catch(Exception ex) {
    string message = 
      String.Format("Something went wrong serializing DTO {0}", DTO);
    throw new MyLibraryException(message, ex);
  }
}

Хіба це зовсім не рівно, ніж взагалі не обробляти винятки?

Не зовсім так, це не те саме. Він скидає стеження винятку. Хоча я згоден, що це, мабуть, помилка, і, отже, приклад поганого коду.

Ви не хочете кидати колишнього - оскільки це втратить стек викликів. Див. Розділ Обробка винятків (MSDN).

І так, спробу ... улов не робить нічого корисного (крім втрати стека викликів - так це насправді гірше - якщо з якихось причин ви не хотіли викривати цю інформацію).

Справа, яку люди не згадували, полягає в тому, що, хоча мови .NET насправді не роблять належного розрізнення, питання про те, чи варто вживати заходів, коли відбувається виняток, і чи вирішить це, насправді є різними питаннями. Існує багато випадків, коли слід вживати заходів на основі винятків, і сподівання на вирішення не має, і є деякі випадки, коли все, що необхідно для "вирішення" винятку, - це розкрутити стек до певного моменту - не потрібні подальші дії. .

Зважаючи на загальну думку про те, що треба "ловити" лише речі, з якими можна "впоратися", багато коду, який повинен вжити заходів, коли трапляються винятки, не існує. Наприклад, багато коду придбає замок, поставить об'єкт, що охороняється, "тимчасово" в стан, який порушує його інваріанти, потім поставить його в законний стан, а потім відпустить замок назад, перш ніж хто-небудь ще може побачити об'єкт. Якщо виняток трапляється, коли об’єкт перебуває у небезпечно недійсному стані, загальною практикою є звільнення блокування з об'єктом, який все ще знаходиться у цьому стані. Набагато кращою схемою було б виняток, який виникає, коли об’єкт перебуває у "небезпечному" стані, явно недійсний замок, тому будь-яка майбутня спроба його придбання негайно зазнає невдачі.

У більшості мов .NET єдиний спосіб вчинити дії коду, заснованого на винятку, - catchце йому (хоча він знає, що виняток не вирішує), виконайте відповідну дію та повторно throw). Ще один можливий підхід, якщо коду не важливо, який викид буде кинуто, - використовувати okпрапор із try/finallyблоком; встановіть okпрапор falseперед блоком і trueперед виходом блоку та перед тим, returnщо знаходиться в блоці. Тоді в межах finally, припустимо, що якщо okце не встановлено, повинен статися виняток. Такий підхід семантично кращий, ніж a catch/ throw, але некрасивий і менш доцільний, ніж повинен бути.

Це може бути корисно, коли ваші програми програмування для бібліотеки або dll.

Ця структура перезарядки може бути використана для цілеспрямованого скидання стеку викликів, так що замість того, щоб бачити виняток, викинутий з окремої функції всередині функції, ви отримуєте виняток із самої функції.

Я думаю, що це просто використовується для того, щоб викинуті винятки були більш чистими і не входили в "коріння" бібліотеки.

Однією з можливих причин лову - це відключити будь-які фільтри винятків глибше стека від фільтрації ( випадкове старе посилання ). Але звичайно, якби це був намір, там був би коментар, який би сказав так.

Це залежить від того, що ви робите в блоці вилову, і якщо ви хочете передати помилку на код виклику чи ні.

Ви можете сказати, Catch io.FileNotFoundExeption exа потім використати альтернативний шлях до файлу чи якийсь подібний, але все-таки киньте помилку.

Також виконання Throwзамість Throw Exдозволяє зберігати повний слід стека. Throw ex перезапускає стек стека з оператора кидання (я сподіваюся, що це має сенс).

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

Прикладом цього є те, коли у вас є метод, за допомогою якого ви встановлюєте курсор (наприклад, курсор очікування), метод має кілька точок виходу (наприклад, якщо () return;), і ви хочете переконатися, що курсор скидається на кінець методу.

Для цього ви можете згорнути весь код у спробу / catch / нарешті. Нарешті встановіть курсор назад до правого курсору. Щоб ви не ховали жодних дійсних винятків, закиньте їх у вилов.

try
{
    Cursor.Current = Cursors.WaitCursor;
    // Test something
    if (testResult) return;
    // Do something else
}
catch
{
    throw;
}
finally
{
     Cursor.Current = Cursors.Default;
}

У прикладі коду, який ви опублікували, насправді немає сенсу ловити виняток, оскільки на вилові нічого не робиться, це просто повторне відтоплення, адже це приносить більше шкоди, ніж користі, оскільки втрачається стек викликів .

Однак ви захочете виключити, щоб виконати якусь логіку (наприклад, закрити з'єднання sql блокування файлу або просто деякий журнал) у разі виключення, повернути його до викликового коду для вирішення. Це є більш поширеним у бізнес-шарі, ніж код переднього кінця, оскільки, можливо, ви хочете, щоб кодер, що реалізує ваш бізнес-рівень, обробляв виняток.

Повторне повторення, хоча немає жодного сенсу ловити виняток у прикладі, який ви розмістили. НЕ роби це так!

Вибачте, але багато прикладів як "покращений дизайн" все ще жахливо пахнуть або можуть бути вкрай оманливими. Спробувавши {} catch {log; кидок} просто безглуздо. Журнал винятків слід проводити в центральному місці всередині програми. винятки все-таки перекидають стек-трек, чому б не записувати їх десь і близько до меж системи?

Необхідно використовувати обережність, коли ви серіалізуєте свій контекст (тобто DTO в одному з наведених прикладів) просто в повідомлення журналу. Він може легко містити конфіденційну інформацію, яка, можливо, не захоче потрапити до рук усіх людей, які мають доступ до файлів журналу. І якщо ви не додасте до винятків будь-якої нової інформації, я дійсно не бачу сенсу перетворювати винятки. У доброї старої Java є певний сенс для цього, вона вимагає, щоб абонент знав, які винятки слід очікувати, а потім викликати код. Оскільки у вас немає цього в .NET, обгортання не приносить користі принаймні 80% випадків, які я бачив.

На додаток до того, що сказали інші, дивіться мою відповідь на відповідне запитання, яке показує, що лов і повторне викидання не є неоперативним (це в VB, але деякий код може бути C #, на який посилається VB).

Більшість відповідей говорять про сценарій catch-log-rethrow.

Замість того, щоб писати його у своєму коді, подумайте про використання AOP, зокрема Postsharp.Diagnostic.Toolkit з OnExceptionOptions IncludeParameterValue і IncludeThisArgument

Перезавантаження винятків через throwкорисно, коли у вас немає конкретного коду для обробки поточних винятків або у випадках, коли у вас є логіка для обробки конкретних випадків помилок, але ви хочете пропустити всі інші.

Приклад:

string numberText = "";
try
{
    Console.Write("Enter an integer: ");
    numberText = Console.ReadLine();
    var result = int.Parse(numberText);

    Console.WriteLine("You entered {0}", result);
}
catch (FormatException)
{
    if (numberText.ToLowerInvariant() == "nothing")
    {
        Console.WriteLine("Please, please don't be lazy and enter a valid number next time.");
    }
    else
    {
        throw;
    }
}    
finally
{
    Console.WriteLine("Freed some resources.");
}
Console.ReadKey();

Однак існує й інший спосіб зробити це, використовуючи умовні пропозиції у блоках улов:

string numberText = "";
try
{
    Console.Write("Enter an integer: ");
    numberText = Console.ReadLine();
    var result = int.Parse(numberText);

    Console.WriteLine("You entered {0}", result);
}
catch (FormatException) when (numberText.ToLowerInvariant() == "nothing")
{
    Console.WriteLine("Please, please don't be lazy and enter a valid number next time.");
}    
finally
{
    Console.WriteLine("Freed some resources.");
}
Console.ReadKey();

Цей механізм є більш ефективним, ніж повторне закидання винятку, оскільки час виконання .NET не повинен перестроювати об’єкт виключення перед повторним закиданням.