Como implementar o tratamento de erros [fechado]

Mesmo que eu tenha programado em nível profissional há alguns anos, ainda não entendo completamente o tratamento de erros. Embora meus aplicativos funcionem bem, o tratamento de erros não é implementado em nível profissional e é uma combinação de várias técnicas.

Não há estrutura por trás do meu tratamento de erros. Eu gostaria de aprender e entender como isso é implementado em nível profissional. Essa é uma área em que não tenho conhecimento.

Quando devo usar uma exceção e quando devo retornar um status de sucesso para ser verificado no fluxo lógico? É bom misturar exceção e retornar um status?

Eu codifico em c # principalmente.

1. Use exceções para coisas excepcionais, coisas que você não pode esperar razoavelmente encontrar com muita frequência, coisas que indicam que algo dá errado. Por exemplo, se a rede estiver inoperante, é algo excepcional para um servidor da web. Se o banco de dados não estiver disponível, isso significa que algo está errado. Se o arquivo de configuração estiver ausente, provavelmente significa que o usuário fez uma bagunça.

2. Não use exceções para manipular código incorreto. Para verificar a correção do código, você deve usar as asserções ou, no .NET Framework 4 e posterior, os contratos de código (que substituem as asserções e possuem recursos adicionais, particularmente valiosos).

3. Não use exceções em casos não excepcionais. O fato de o usuário, quando solicitado a inserir um número, inserir "cão" não é tão excepcional para merecer uma exceção.

4. Tenha cuidado ao escolher os tipos de exceções. Crie seus próprios tipos quando necessário. Escolha cuidadosamente a herança, tendo em mente que a captura dos pais também pegará os filhos. Nunca throw Exception.

5. Não use códigos de retorno para erros. Os códigos de erro são facilmente mascarados, ignorados, esquecidos. Se houver um erro, manipule-o ou propague-o para a pilha superior.

6. Nos casos em que se espera que um método retorne um erro e o erro não seja excepcional, use enumerações, nunca números de erro. Exemplo:

   // Note that the operation fails pretty often, since it deals with the servers which are
   // frequently unavailable, and the ones which send garbage instead of the actual data.
   private LoadOperationResult LoadProductsFromWeb()
   {
       ...
   }

   O significado de LoadOperationResult.ServerUnavailable, LoadOperationResult.ParsingErroretc. é muito mais explícito do que, digamos, lembrar que o código 12 significa que o servidor está inoperante e o código 13 - que os dados não podem ser analisados.

7. Use códigos de erro quando eles se referirem aos comuns, conhecidos por todos os desenvolvedores que trabalham no domínio específico. Por exemplo, não reinvente um valor de enumeração para HTTP 404 não encontrado ou Erro interno do servidor HTTP 500.

8. Cuidado com os booleanos. Mais cedo ou mais tarde, você desejará saber não apenas se um método específico foi bem-sucedido ou falhou, mas por quê. Exceções e enumerações são muito mais poderosas para isso.

9. Não pegue todas as exceções (a menos que você esteja no topo da pilha). Se você pegar uma exceção, deve estar pronto para lidar com isso. Capturar tudo está mostrando que você não se importa se o seu código é executado corretamente. Isso pode resolver o "Não quero pesquisar agora como corrigir isso", mas machucará você mais cedo ou mais tarde.

10. Em C #, nunca repita exceções como esta:

    catch (SomeException ex)
    {
        ...
        throw ex;
    }

    porque você está quebrando a pilha. Faça isso:

    catch (SomeException)
    {
        ...
        throw;
    }

11. Faça um esforço ao escrever mensagens de exceção. Quantas vezes eu vi algo parecido throw Exception("wrong data")ou throw Exception("shouldn't call this method in this context"). Outros desenvolvedores, inclusive você seis meses depois, não teriam idéia de quais dados estão errados e por que ou por que não deveríamos chamar algum método em um contexto, nem qual contexto com precisão.

12. Não mostre mensagens de exceção para o usuário. Eles não são esperados para pessoas comuns e geralmente são ilegíveis para os próprios desenvolvedores.

13. Não localize mensagens de exceção. Pesquisando na documentação por uma mensagem localizada é exaustivo e inútil: todas as mensagens devem estar apenas em inglês e em inglês.

14. Não se concentre exclusivamente em exceções e erros: os logs também são extremamente importantes.

15. No .NET, não esqueça de incluir exceções na documentação XML do método:

    /// <exception cref="MyException">Description of the exception</exception>

    A inclusão de exceções na documentação XML facilita muito as coisas para a pessoa que está usando a biblioteca. Não há nada mais irritante do que tentar adivinhar qual exceção poderia ser lançada por um método e por quê.

    Nesse sentido¹, o tratamento de exceções Java fornece uma abordagem melhor e mais rígida. Obriga você a lidar com exceções potencialmente lançadas pelos métodos chamados ou declarar em seu próprio método que pode lançar as exceções que você não lida, tornando as coisas particularmente transparentes.

^{¹ Dito isto, considero a distinção Java entre exceções e erros bastante inútil e confusa, uma vez que a linguagem verificou e desmarcou as exceções. Felizmente, o .NET Framework possui apenas exceções e nenhum erro.}

Eu acho que a lista da MainMa é muito completa. Vou apenas adicionar alguns dos meus:

1. Leia o artigo de Eric Lippert sobre como ele categoriza exceções. Particularmente importante é o argumento dele de não capturar exceções que, na realidade, são erros no seu código. Corrija o código!
2. Se você sabe que uma exceção pode ocorrer E você pode fazer algo a respeito, lide com ela, mas limite o escopo de tentar capturar e capturar a exceção específica que espera. Ou seja, não faça isso:

public void Foo() {
    try {
        //get input from use
        //do calculations
        //open file
    }
    catch (Exception ex) {
       //handle exception
    }
}

Em vez disso, faça o seguinte:

public void Foo() {
    //get input from use
    //do calculations
    try {
        //open file
    }
    catch (FileOpenException ex) {
       //handle exception
    }
}

• Não use exceções para o fluxo de controle. Por exemplo, não ative um ClientNotFoundException em uma caixa de diálogo de pesquisa (um cliente não encontrado não é excepcional nessa situação) e espere que o código de chamada mostre uma mensagem "Nenhum resultado encontrado" quando isso acontecer.

• Não engula exceções!

• Lembre-se de que realmente manipular uma exceção pode significar apenas três coisas:

  1. Repita a operação. Válido apenas se o problema for transitório.
  2. Tente uma alternativa.
  3. Notifique alguém sobre o problema. Válido apenas se a notificação for acionável, o que significa que o usuário pode fazer algo a respeito.

  Se nenhuma dessas opções se aplicar, provavelmente você não deve capturar essa exceção. Você deve registrá-lo e cancelar a operação ou encerrar. Obviamente, isso depende de quais são seus requisitos em relação à correção versus robustez.