Tratamento e lançamento de exceções
Aplicativos devem ser capazes de manipular erros que ocorrem durante a execução de uma forma consistente. O common language runtime fornece um modelo para notificar os aplicativos de erros de uma maneira uniforme. Todas as operações do .NET Framework indicam falhas lançando exceções.
Este tópico contém as seções a seguir:
Exceções a.NET Framework
Exceções vs. Métodos tradicionais de tratamento de erros
Como o Tempo de Execução Gerencia as Exceções
Filtrando Exceções de Tempo de Execução
Tópicos relacionados
Referência
Exceções a.NET Framework
Uma exceção é qualquer condição de erro ou comportamento inesperado que for encontrado por um programa em execução. Exceções podem ser disparadas por causa de uma falha no seu código ou no código que você chamar (como, por exemplo, uma biblioteca compartilhada), recursos disponíveis do sistema operacional, condições inesperadas que encontra do common language runtime (como o código que não pode ser verificado) e assim por diante. Seu aplicativo pode recuperar de algumas dessas condições, mas não de outros. Embora seja possível recuperar a partir da maioria das exceções de aplicativo, é possível recuperar a maioria das exceções de tempo de execução.
No.NET Framework, uma exceção é um objeto que herda de System.Exception classe. Uma exceção é lançada a partir de uma área de código onde ocorreu um problema. A exceção é passada à pilha até que o aplicativo a manipule ou encerre o programa.
Voltar ao topo
Exceções vs.Métodos tradicionais de tratamento de erros
Tradicionalmente, o modelo de tratamento de erros do idioma se baseavam maneira do idioma de detectar erros e localizar manipuladores para eles ou o mecanismo de tratamento de erros, fornecido pelo sistema operacional. O tempo de execução implementa o tratamento de exceções com os seguintes recursos:
Lida com exceções sem levar em consideração a linguagem que gera a exceção ou a linguagem que lida com a exceção.
Não requer qualquer sintaxe de linguagem específica a sintaxe para tratamento de exceções, mas permite que cada linguagem defina sua própria sintaxe.
Permite que exceções sejam lançadas através de limites de processos e até mesmo de máquina.
Exceções oferecem várias vantagens sobre outros métodos de notificação de erro, como códigos de retorno. Falhas não passam despercebidas. Valores inválidos não continuam a se propagar através do sistema. Não é necessário que você verifique os códigos de retorno. Códigos de tratamento de exceções podem ser facilmente adicionados para aumentar a confiabilidade do programa. Finalmente, o tempo de execução do tratamento de exceções é mais rápido que a manipulação de erros em C++ baseada em Windows.
Como segmentos de execução rotineiramente atravessam blocos de código gerenciado e não gerenciado, o tempo de execução pode lançar ou capturar exceções tanto em código gerenciado quanto não gerenciado. O código não gerenciado pode incluir tanto exceções SEH em estilo C++ quanto HRESULTS baseados em COM.
Como o Tempo de Execução Gerencia as Exceções
O modelo usa uma manipulação de exceção de tempo de execução com base em objetos de exceção e protegidos de blocos de código. Um objeto Exception é criado para representar uma exceção quando ele ocorre.
O tempo de execução cria uma tabela de informações de exceção para cada arquivo executável. Cada método do executável tem uma matriz associada de informações de manipulação de exceção (que podem estar vazias) na tabela de informações de exceção. Cada entrada da matriz descreve um bloco protegido do código, os filtros de exceção associados com esse código e quaisquer manipuladores de exceção (catch instruções). Esta tabela de exceção é extremamente eficiente e não causa qualquer penalidade de desempenho em tempo de processador ou em uso de memória quando uma exceção não ocorre. Você utiliza os recursos somente quando ocorre uma exceção.
A tabela de informações de exceção representa quatro tipos de manipuladores de exceção para blocos protegidos:
A finally manipulador que é executado sempre que o bloco for encerrado, se o que ocorre por fluxo de controle normal ou uma exceção não tratada.
Um manipulador de falha, que deve executar se uma exceção ocorrer, mas não é executado na conclusão do fluxo de controle normal.
Um manipulador com filtro de tipo, que lida com qualquer exceção de uma classe especificada, ou qualquer uma de suas classes derivadas.
Um manipulador com filtro de usuário, que executa código especificado pelo usuário para determinar se a exceção deve ser manipulada pelo manipulador associado ou deve ser passada para o próximo bloco protegido.
Cada linguagem implementa esses manipuladores de exceção de acordo com as suas especificações. Por exemplo, o Visual Basic fornece acesso para o manipulador filtrados por usuário por meio de uma comparação de variável (usando o When palavra-chave) na catch instrução; C# não implementa o manipulador filtrados por usuário.
Quando ocorre uma exceção, o tempo de execução começa um processo de duas etapas:
O runtime procura a matriz para o primeiro bloco protegido que faz o seguinte:
Protege uma região que inclui a instrução atualmente em execução.
Contém um manipulador de exceção ou contém um filtro que lida com a exceção.
Se houver uma correspondência, o runtime cria um Exception objeto que descreve a exceção. O tempo de execução, em seguida, executa todas as finally ou instruções de falhas entre a instrução onde a exceção ocorreu e a instrução que manipula a exceção. Observe que a ordem dos manipuladores de exceção é importante; o manipulador de exceção interna é avaliado primeiro. Observe também que manipuladores de exceção podem acessar as variáveis locais e a memória local da rotina que captura a exceção, mas quaisquer valores intermediários no momento que a exceção é lançada são perdidos.
Se nenhuma correspondência ocorrer no método atual, o tempo de execução busca cada chamador do método atual, e ele continua este caminho pilha acima. Se o chamador tem uma correspondência, o tempo de execução permite o acesso a exceção do depurador. Se o depurador não anexar à exceção, o tempo de execução gera o evento AppDomain.UnhandledException. Se não houver nenhum ouvintes para este evento, o runtime Despeja um rastreamento de pilha e termina o aplicativo.
Voltar ao topo
Filtrando Exceções de Tempo de Execução
Você pode filtrar as exceções que você detectar e manipulá-las, tanto pelo tipo, quanto por alguns critérios definidos pelo usuário.
Manipuladores filtrados por tipo de gerenciam um determinado tipo de exceção (classes ou derivados dele). O exemplo a seguir mostra um manipulador de filtrados por tipo projetado para capturar uma exceção específica, nesse caso, o FileNotFoundException.
Catch e As FileNotFoundException
Console.WriteLine("[Data File Missing] {0}", e)
catch (FileNotFoundException e)
{
Console.WriteLine("[Data File Missing] {0}", e);
}
catch (FileNotFoundException^ e)
{
Console::WriteLine("[Data File Missing] {0}", e);
}
Manipuladores de exceção filtradas pelo usuário capturam e tratam exceções com base nos requisitos que você definiu para a exceção. Para obter mais informações sobre a filtragem de exceções, dessa forma, consulte Usando exceções específicas em um bloco Catch.
Voltar ao topo
Tópicos relacionados
Título |
Descrição |
|---|---|
Descreve os elementos de um objeto de exceção. |
|
Descreve as exceções das quais a maioria das exceções deriva. |
|
Explica como manipular exceções usando instruções catch, throw e finally. |
|
Descreve métodos sugeridos para o tratamento de exceções. |
|
Descreve como manipular exceções lançadas e capturadas em código não gerenciado. |
|
Descreve o mapeamento de exceções entre códigos gerenciados e não gerenciados. |
Voltar ao topo