Maneira de ver automaticamente as funções que podem potencialmente retornar exceção em c #

https://stackoverflow.com/questions/915941

06-09-2019
|

Pergunta

nada mais frustrante do que ver o seu acidente de código no depurador em um método que exceptionned e você não tente / pegá-lo.

Existe uma maneira fácil para fazer a varredura através de suas fontes e marcar todas as funções que pode potencialmente lançar exceções?

Será que a construção no Visual auxiliar ter alguma opção oculta para colorir estas funções em uma cor específica?

graças

Solução

Eu acho redgate ter alguma uma ferramenta para isso "Exception Hunter" Eles cobram para ele depois de um julgamento.

http://www.red-gate.com/products/Exception_Hunter /index.htm

Outras dicas

Todo o código, mas o mais trivial poderia lançar exceções (falta de memória, no mínimo). Você provavelmente está melhor escrever seu código defensiva, com pelo menos um try / catch mundial em vez de tentar gerenciar quais seções de código irá ou não lançar exceções.

Não, não há nenhuma maneira de fazer isso automaticamente nem há uma boa maneira de obter uma lista de todas as possíveis exceções lançadas por um método. Aqui estão algumas razões pelas quais

exceções lançadas Considere implicitamente como StackOverflowException pode ser jogado em qualquer momento a partir de qualquer método. Você deve assumir que qualquer método no CLR pode jogar estes tipos de exceções
Reflexão e / ou delegados podem esconder o código real que está sendo chamado em um método particular para que você não pode inspecionar todos os caminhos de código possíveis de um método.
Isto exigiria inspecionar IL vs. metadados.
Na Net não há nenhuma exigência para exceções de documentos que são explicitamente lançada por uma API

Como já foi dito, eu não tenho certeza se você vai encontrar uma maneira infalível de fazer isso em C # desde não suporta exceções verificadas.

Como um pouco de um lado, isso me fez lembrar de uma entrevista com Anders Hejlsberg discutir " A problemas com exceções verificadas ". Eu não estou tentando chama exceções verificadas, mas sugerindo que você lê lógica de Ander trás C # 's projeto de exceção e o caminho sugerido para tratamento de exceções:. Tratamento de exceção centralizada

Eu acho que o ReSharper dá dicas sobre exceções. Mas, devido ao motivo que C # não suporta exceções verificadas, não há maneira de determinar as exceções. Talvez ferramentas de análise de código como NDepend suportar isto.

Tudo pode lançar uma exceção. Verifique MSDN para uma lista de exceções que pode ser lançada por um método.

Todos os métodos não-vazios podem lançar exceções em uma forma ou outra. Se você está preocupado com as exceções que você gerou pessoalmente, você pode exibi-los de intellisense da mesma maneira métodos de enquadramento fazer através de documentação XML, assim:

/// <summary>  
/// I seem to have written a method to do a thing.
/// </summary>  
/// <exception cref="System.Exception">An unfortunate failure.</exception>
public void DoSomething()
{
   /* ... */
}

Qualquer código poderia potencialmente causar uma exceção é o seu trabalho para tentar antecipar isso!

Há uma série de ferramentas de terceiros que podem ajudar a encontrar alguns erros comuns por exemplo FxCop e ferramentas como refatorar pode fazer sugestões.

Há algum trabalho foi feito no momento em que pode ajudá-lo a encontrar potenciais exceções. Dê uma olhada na PEX que pode ajudar a gerar testes para as suas funções: research.microsoft.com/en-us/projects/Pex/ (ligação parece ser baixo no momento da postagem)

Outra área interessante é contratos de código (que vem em .net 4 / disponíveis como especificação #). contratos de código permitem que você escrever instruções que especificam as condições que devem ser cumpridas. Estes podem ser antes e depois da sua função que está sendo chamado e você também pode declarar invariantes. A condição pode ser algo tão simples como valor! = Null. Estas condições são, em seguida, analisado em tempo de compilação e tempo de execução para verificar nenhum código de caminhos de violar.

Como os outros disseram, você deve assumir que cada única linha de código pode lançar uma exceção, a menos que você já provou que ele não pode. A melhor pergunta é: "O que você pretende fazer sobre isso?"

Em geral, você não deve estar pegando quaisquer excepções em tudo.

Claro que, tudo o resto é uma exceção a essa regra. Faz sentido para capturar uma exceção, a fim de registrá-lo (se o seu ambiente não faz isso para você, como ASP.NET faz). Faz sentido para capturar uma exceção, a fim de substituí-lo com outra exceção que fornece mais detalhes sobre o contexto:

public int GetConfiguredInteger(string name) {
    string s = null;
    try {
        s = GetStringFromConfigFile(name);
    }
    catch (IOException ex) {
        throw new Exception(String.Format(
            "Error in configuration file foo.config when processing {0}", name),
            ex);
    }
    return int.Parse(s);
}

O chamador não poderia ter sabido que o IOException foi causado por um arquivo de configuração, se você não lhes tinha dito. Note-se também como eu ignorei todas as exceções não relacionadas com o arquivo I / O. Em particular, nota que o int.Parse não é mesmo dentro do bloco try / catch.

Há um pequeno número de outras exceções, mas a idéia básica de exceções captura é:. Não fazê-lo a menos que ele seria pior se você não fez

Há um add reflector em Exceção do Finder que irá mostrar o que exceções podem ser lançada por um método. Eu não usei, mas viu um exemplo disso em uma reunião grupo de usuários de .Net.

Há uma ferramenta para fora lá que pode fazer isso. Você pode baixar o julgamento e ver se você gosta dela. Eu realmente não acho que seria tão necessário, mas se você está trabalhando para uma empresa e eles vão pagar por isso você pode querer olhar para ele. Como já foi dito antes, existem apenas demasiadas excepções possíveis que ser levantadas. Confira excpetion Hunter

Exception Hunter mencionada por algumas pessoas é uma boa ferramenta para ajudar com isso. Eu não sei se ele tem um tie-in com o comentário <exception> XML-Doc para que você possa aplicar documentação de exceções lançadas por código.

Acho que é muito mais frustrante para quebrar dentro de um bloco catch exterior e cavar meu caminho até o ponto real onde a happend exceção.

Na maioria das vezes, se uma exceção foi acionada e eu não esperava que eu encontrei um bug e é mais fácil de resolvê-lo se ele não foi ofuscado por alguma manipulação fazer-nada exceção.

EDIT: Desde que seus exemplos é realmente um bom eu ainda não estou convencido de que essa ferramenta iria ajudá-lo. Não haveria tantas exceções possíveis que literalmente cada linha de código poderia jogar que você terá um tempo difícil encontrar os "interessantes".

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow