Curso de C#: Lição 15: Introdução a exceções

Esta lição ensina como lidar com exceções em C # seus programas. Os nossos objectivos são os seguintes: Saiba o que é uma exceção. Implementar uma rotina com um tente / captura bloco. Liberação dos recursos em um último bloco.

Por | @oficinadanet Programação
Esta lição ensina como lidar com exceções em C # seus programas. Os nossos objectivos são os seguintes:

  • Saiba o que é uma exceção
  • Implementar uma rotina com um tente / captura bloco
  • Liberação dos recursos em um último bloco


As exceções são imprevisíveis erros que acontecem em seus programas. A maior parte do tempo, você pode, e deve, detectar e tratar programa erros em seu código. Por exemplo, a validação de usuários, verificação de objetos nulos, e verificar os valores devolvidos a partir de métodos são aquilo que você espera, são todos exemplos de boas erro padrão movimentação que você deve fazer o tempo todo.

No entanto, há momentos em que você não sabe se irá ocorrer um erro. Por exemplo, você não pode prever quando você receberá um arquivo I / O erro, esgotar-se de memória do sistema, ou encontrar uma base de dados erro. Estas coisas são geralmente pouco provável, mas eles ainda podia acontecer e que pretende ser capaz de lidar com eles quando eles ocorrem. Esta excepção é quando aparece, manipulação

Quando ocorrer excepções, estão a ser dito "jogado". O que é verdade é jogado um objeto que é derivada da classe System.Exception. Na próxima seção, explicando como eu vou ser jogado exceções são tratadas com experimentar / captura blocos.

Exception fornece vários métodos e propriedades para a obtenção de informações sobre o que correu mal. Por exemplo, a propriedade Mensagem fornece informações resumidas sobre o que o erro foi, a propriedade Stacktrace fornece informações a partir da pilha de onde o problema ocorreu, e as toString () método é sobreposto para revelar verbose uma descrição de toda a exceção.

Identificar as excepções você terá que lidar com a rotina depende do que você está escrevendo. Por exemplo, se a rotina abriu um arquivo com o System.IO.File.OpenRead () método, que pode jogar qualquer um dos seguintes exceções:

  • SecurityException
  • ArgumentException
  • ArgumentNullException
  • PathTooLongException
  • DirectoryNotFoundException
  • UnauthorizedAccessException
  • FileNotFoundException
  • NotSupportedException


É fácil descobrir o que pode levantar exceções um método verificando o. NET Quadros Documentação SDK. Basta ir ao Referência / Class Library e procure na secção Namespace / Classe / Método documentação para os métodos que você usa. A exceção na lista acima foi encontrado por olhar para o OpenRead () método de definição da classe File no namespace System.IO.Cada exceção foi identificada uma hiperligação para a sua classe definição que você pode usar para descobrir aquilo que é de cerca de exceção. Assim que tiver figurado o que há excepções podem ser gerados em seu código, você tem que colocar em prática os mecanismos para lidar com as excepções, caso elas ocorram.

try/catch


Quando exceções são lançadas, o que precisa de ser capaz de lidar com elas. Isto é feito através da aplicação de uma tentativa / captura bloco. Código que poderia lançar uma exceção é colocado em uma excepção ao tentar bloquear movimentação código vai na captura bloco. Listagem 15-1 mostra como uma tentativa de implementar / captura bloco. Uma vez que um OpenRead () método poderia lançar uma das várias excepções, é colocado em experimentar o bloco. Se uma exceção é lançada, ela será capturada nas capturas bloco. O código na listagem 15-1 irá imprimir mensagem e stack trace as informações para o console se uma exceção é levantada.

Nota: Os programas em causa excepções a esta lição efeito. A exceção que você vê é gerado intencionalmente para mostrar aquilo que se parece com a ressalva de mensagem antes de você vê-lo-á no seu próprios programas.

Listagem 15-1. Usando try / catch: tryCatchDemo.cs
 using System;
using System.IO;

class tryCatchDemo
{
    static void Main(string[] args)
    {
        try
        {
            File.OpenRead("NonExistentFile");
        }
        catch(Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }
}


Apesar de o código na listagem 15-1 só tem um único bloco catch, todas as excepções serão capturados lá porque é o tipo da base excepção tipo "excepção". Em excepção movimentação, mais específica excepções serão capturados antes de sua mãe mais geral excepções. Por exemplo, o seguinte trecho mostra como a captura local múltiplos blocos:

        catch(FileNotFoundException fnfex)
        {
            Console.WriteLine(fnfex.ToString());
        }
        catch(Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }


Se o arquivo não existe, uma exceção FileNotFoundException vão ser lançadas e capturado por apanhar o primeiro bloco. No entanto, se uma excepção PathTooLongException foi levantada, a segunda parte das capturas seria capturar a excepção. Isto é assim porque não há um bloco para a captura PathTooLongException excepção dos genéricos e de Exceção tipo captura bloqueio é a única opção disponível para capturar a excepção.

Exceções que não são manipulados irá normalmente bolha até a pilha até uma chamada de rotina a chamada cadeia lida com elas. Se você esquecer de incluir tentar / captura blocos em uma parte do seu código e não há qualquer tentativa / captura blocos anteriores na chamada cadeia, irá interromper o seu programa com uma mensagem descrevendo a exceção. Para os usuários isso seria muito crítico e desconfortável.Trata-se de boas práticas para fornecer excepção movimentação nos seus programas.

Finally


Uma exceção pode deixar o seu programa em um estado inconsistente por não liberar recursos ou fazer algum outro tipo de limpeza. Um bloco catch é um bom lugar para descobrir o que pode ter correu mal e tentar recuperar, no entanto, pode não conta para todos os cenários. Às vezes você precisa para executar ações limpar ou não o seu programa bem sucedido. Estas situações são bons candidatos para a utilização de um último bloco.

Listagem 15-2 ilustra a utilidade de um último bloco. Como se sabe, um arquivo fluxo deve ser encerrada quando terminar com ele. Neste caso, o arquivo é o fluxo dos recursos que precisa de ser limpos.Em Listagem 15-2, outStream é aberto com sucesso, ou seja, o programa agora tem uma alça para abrir um arquivo recurso. Ao tentar abrir o inStream, FileNotFoundException uma exceção é levantada, causando controle de ir imediatamente para a captura bloco.

É possível fechar o outStream a captura em bloco, mas o que se o algoritmo executado com sucesso sem uma excepção? Em êxito, o arquivo jamais seria fechado. Felizmente, nós incluímos uma listagem 15-2 no último bloco, que será sempre executado. É isso mesmo, independentemente do facto de o algoritmo de tentar bloquear as levanta uma exceção ou não, o código no último bloco será executado antes de controlo deixa o método.

Listagem 15-2. Implementar um finally: FinallyDemo.cs
 using System;
using System.IO;

class FinallyDemo
{
    static void Main(string[] args)
    {
        FileStream outStream = null;
        FileStream inStream = null;

        try
        {
            outStream = File.OpenWrite("DestinationFile.txt");
            inStream = File.OpenRead("BogusInputFile.txt");
        }
        catch(Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
        finally
        {
            if (outStream != null)
            {
                outStream.Close();
                Console.WriteLine("outStream closed.");
            }
            if (inStream != null)
            {
                inStream.Close();
                Console.WriteLine("inStream closed.");
            }
        }
    }
}


Um último bloco não é necessária, e você pode perguntar o que acontece se você basta colocar o código após a captura bloco certo que, em circunstâncias normais, se a exceção é capturado, na sequência da captura todos os código será executado. No entanto, tentar / capturas / finalmente está para circunstâncias excepcionais, e que é melhor para o pior plano para fazer seu programa mais robusto. Por exemplo, se uma das capturas manipuladores rethrew causou uma excepção ou outra excepção, o código na sequência da captura bloco (e não em um último bloco) jamais seria executada. Além disso, se você não pegar a excepção a todos, programa fluxo seria imediatamente fazer um passeio à procura de uma pilha excepção manipulador e que se enquadra o código na sequência da captura blocos não seria executado. Desde há muito potencial de código em um algoritmo para não ser executada, por último bloco é um seguro para a sua execução dessas acções crítica que você precisa.

Resumo


Esta tem sido uma introdução à manipulação excepções. Até agora, você deve ter uma boa compreensão do que é uma exceção. Você pode tentar implementar algoritmos try / catch que lidar com exceções. Além disso, você sabe como a limpeza de recursos por meio da aplicação finalmente um bloco cujo código é executado sempre antes de sair de um método.

Artigo automaticamente traduzido de: http://www.csharp-station.com/Tutorials/Lesson15.aspx

Mais sobre: curso_c_sharp c_sharp excecoes
Share Tweet
Recomendado
Comentários
Carregar comentários
Destaquesver tudo