try-catch (Referência do C#) 

A demonstrativo try-catch consiste em um try bloco seguido por um ou mais catch cláusulas Especifique manipuladores de exceções diferentes. Quando uma exceção é lançada, o common linguagem tempo de execução (CLR) procura o catch demonstrativo que manipula essa exceção. Se o método atualmente em execução não contém tais um catch bloco, o CLR aborda o método que chamou o método corrente, e assim por diante cima na pilha de chamadas. Se nenhum catch bloco for encontrado e, em seguida, o CLR exibirá uma mensagem de exceção sem tratamento ao usuário e interrompe a execução do programa.

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

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

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

catch (InvalidCastException e) 
{
}

É possível usar mais de um determinado catch cláusula na mesma demonstrativo try-catch. Nesse caso, a ordem do catch cláusulas é importante porque o catch as cláusulas são examinadas em ordem. Capture as exceções mais específicas antes das menos específicas.O compilador produzirá um erro se você ordenar que seu catch bloqueia, de modo que um bloco posterior nunca irá ser alcançado.

A throw demonstrativo pode ser usada no catch bloco para relançar a exceção, que tenha sido detectada pela catch demonstrativo. Por exemplo:

catch (InvalidCastException e) 
{
    throw (e);    // Rethrowing exception e
}

Você também pode lançar uma nova exceção.Ao fazer isso, especifique a exceção que você capturar sistema autônomo a exceção interna:

catch (InvalidCastException e) 
{
   // Can do cleanup work here.
    throw new CustomException("Error message here.", e);
}

Se você quiser relançar a exceção atualmente tratada por um sem parâmetros catch cláusula, uso o throw demonstrativo sem argumentos. Por exemplo:

catch
{
    throw;
}

Quando dentro de um try bloquear, apenas inicializar variáveis que são declaradas nele; caso contrário, que pode ocorrer uma exceção antes de concluída a execução do bloco. Por exemplo, no exemplo de código a seguir, a variável x é inicializado dentro do try bloco. Uma tentativa de usar essa variável fora o try Bloquear na Write(x) demonstrativo gerará o erro do compilador: Uso de variável local não atribuída.

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

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

Exemplo

Neste exemplo, a try bloco contém uma telefonar para o ProcessString método que pode causar uma exceção. The catch cláusula contém o manipulador de exceção apenas exibirá uma mensagem na tela. Quando o throw demonstrativo é chamada de dentro MyMethod, o sistema procurará o catch demonstrativo 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 TryFinallyTest.Main() First exception caught.
*/

No exemplo anterior, se você iniciar com a cláusula catch menos específica, você obtém 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 as seções a seguir no Especificação da linguagem C#:

• 5.3.3.13 Instruções try-catch

• 8.10 A instrução try

• 16 Exceções

Consulte também

Tarefas

Como: Explicitamente lançar exceções

Conceitos

Guia de Programação C#

Referência

Palavras-chave C#

The try, capturar, and lançar Statements

Exceção tratamento instruções (referência C#)

Descartar referência (C#)

try-finally (Referência do C#)

Outros recursos

Referência C#