try-catch (C# Reference)

A instrução try-catch consiste em um try bloco seguido de um ou mais catch cláusulas, que especificam os manipuladores de exceções diferentes. Quando uma exceção é lançada, o common language runtime (CLR) procura o catch instrução que manipula a exceção. Se o método de execução no momento não há como um catch Bloquear, a CLR examina o método que chamado o método atual, e assim por diante até a pilha de chamada. Se nenhum catch bloco for encontrado, e o CLR exibirá uma mensagem de exceção não tratada ao usuário e interrompe a execução do programa.

O try bloco contém o código protegido, que pode causar a exceção. O bloco é executado até que uma exceção seja gerada ou ele seja concluído com sucesso. Por exemplo, o seguinte tenta converter um null objeto gera a NullReferenceException exceção:

object o2 = null;
try
{
    int i2 = (int)o2;   // Error
}

Embora o catch cláusula pode ser usada sem argumentos para capturar qualquer tipo de exceção, esse uso não é recomendado. Em geral, você só deve capturar essas exceções que você sabe como recuperar. Portanto, você sempre deve especificar um argumento de objeto derivado de System.Exception por exemplo:

catch (InvalidCastException e) 
{
}

É possível usar mais de um específico catch cláusula a mesma instrução try-catch. Neste caso, a ordem da catch cláusulas é importante porque a catch cláusulas são examinadas em ordem. Capture as exceções mais específicas antes das menos específicas. O compilador produz um erro se você solicitar que sua catch bloqueia, de forma que um bloco posterior nunca pode ser alcançado.

A lança instrução pode ser usada em um catch bloco para relançar a exceção que é detectada pelo catch instrução. O exemplo a seguir extrai informações da fonte de um IOException exceção e em seguida, lança a exceção para o método pai.

catch (FileNotFoundException e)
{
    // FileNotFoundExceptions are handled here.
}
catch (IOException e)
{
    // Extract some information from this exception, and then 
    // throw it to the parent method.
    if (e.Source != null)
        Console.WriteLine("IOException source: {0}", e.Source);
    throw;
}

Você pode capturar uma exceção e lançar uma exceção diferente. Quando você fizer isso, especifique a exceção que é identificada como a exceção interna, como mostrado no exemplo a seguir.

catch (InvalidCastException e) 
{
    // Perform some action here, and then throw a new exception.
    throw new YourCustomException("Put your error message here.", e);
}

Você também pode relançar uma exceção quando uma condição especificada for verdadeira, conforme mostrado no exemplo a seguir.

catch (InvalidCastException e)
{
    if (e.Data == null)
    {
        throw;
    }
    else
    {
        // Take some action.
    }
 }

De dentro de um try Bloquear, inicializar somente as variáveis são declaradas aí. Caso contrário, uma exceção pode ocorrer antes da conclusão da execução do bloco. Por exemplo, no seguinte exemplo de código, a variável n é inicializada dentro do try bloco. Uma tentativa de usar esta variável fora do try bloco na Write(n) instrução gerará um erro do compilador.

static void Main() 
{
    int n;
    try 
    {
        // Do not initialize this variable here.
        n = 123;
    }
    catch
    {
    }
    // Error: Use of unassigned local variable 'n'.
    Console.Write(n);
}

Para obter mais informações sobre o problema, consulte try-catch-finally.

Exemplo

No exemplo a seguir, o try bloco contém uma chamada para o ProcessString método que pode causar uma exceção. O catch cláusula contém o manipulador de exceção que apenas exibe uma mensagem na tela. Quando o throw instrução é chamada de dentro de MyMethod, o sistema procurará o catch instrução e exibe a mensagem Exception caught.

    class TryFinallyTest
{
    static void ProcessString(string s)
    {
        if (s == null)
        {
            throw new ArgumentNullException();
        }
    }

    static void Main()
    {
        string s = null; // For demonstration purposes.

        try
        {            
            ProcessString(s);
        }

        catch (Exception e)
        {
            Console.WriteLine("{0} Exception caught.", e);
        }
    }
}
    /*
    Output:
    System.ArgumentNullException: Value cannot be null.
       at TryFinallyTest.Main() Exception caught.
     * */

Neste exemplo, duas instruções catch são usadas. A exceção mais específica, que vem primeiro, é detectada.

class ThrowTest3
{
    static void ProcessString(string s)
    {
        if (s == null)
        {
            throw new ArgumentNullException();
        }
    }

    static void Main()
    {
        try
        {
            string s = null;
            ProcessString(s);
        }
        // Most specific:
        catch (ArgumentNullException e)
        {
            Console.WriteLine("{0} First exception caught.", e);
        }
        // Least specific:
        catch (Exception e)
        {
            Console.WriteLine("{0} Second exception caught.", e);
        }
    }
}
/*
 Output:
 System.ArgumentNullException: Value cannot be null.
 at Test.ThrowTest3.ProcessString(String s) ... First exception caught.
*/

No exemplo anterior, se você iniciar com a cláusula catch menos específica, você receberá a mensagem de erro:

A previous catch clause already catches all exceptions of this or a super type ('System.Exception')

Entretanto, para capturar a exceção menos específica, substitua a instrução throw pela instrução a seguir:

throw new Exception();

Especificação da linguagem C#

Para obter mais informações, consulte C# Language Specification A especificação de linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Consulte também

Tarefas

Como: Lançar exceções explicitamente

Referência

C# Keywords

The try, catch, and throw Statements

Exception Handling Statements (C# Reference)

throw (C# Reference)

try-finally (C# Reference)

Conceitos

C# Programming Guide

Outros recursos

C# Reference

Histórico de alterações