Try...Catch...Instrução finally (Visual Basic)

Artigo
02/25/2013

Fornece uma maneira para manipular alguns ou todos os possíveis erros que podem ocorrer em um determinado bloco de código, quando código imóvel de execução.

Try
    [ tryStatements ]
    [ Exit Try ]
[ Catch [ exception [ As type ] ] [ When expression ]
    [ catchStatements ]
    [ Exit Try ] ]
[ Catch ... ]
[ Finally
    [ finallyStatements ] ]
End Try

Partes

Termo	Definição
tryStatements	Opcional.Instruções onde um erro pode ocorrer.Pode ser uma instrução composta.
Catch	Opcional.Vários blocos de Catch permitidos.Se uma exceção ocorrer ao processar o bloco de Try , cada declaração de Catch é examinada na ordem textual determinar se lida com a exceção, com exception que representa a exceção que foi lançada.
exception	Opcional.Qualquer nome de variável.O valor inicial de exception é o valor de erro gerado.Usado com Catch para especificar o erro capturado.Se omitido, a instrução de Catch captura qualquer exceção.
type	Opcional.Especifica o tipo de filtro da classe.Se o valor de exception é do tipo especificado por type ou um tipo derivado, o identificador transformações limite para o objeto de exceção.
When	Opcional.Uma declaração de Catch com uma cláusula de When captura exceções somente quando expression avalia a True.Uma cláusula de When é aplicada somente após verifique o tipo de exceção, e expression pode se referir ao identificador que representa a exceção.
expression	Opcional.Deve ser conversível implicitamente na Boolean.Qualquer expressão que descrever um filtro genérico.Normalmente usado para filtrar por engano o número.Usado com a palavra-chave de When para especificar as condições sob as quais o erro é capturado.
catchStatements	Opcional.Instruções para manipular erros que ocorrem no bloco associado de Try .Pode ser uma instrução composta.
Exit Try	Opcional.Palavras-chave que estoira estrutura de Try...Catch...Finally .A execução continua com o código imediatamente após a declaração de End Try .A declaração de Finally ainda será executada.Não permitido em blocos de Finally .
Finally	Opcional.Um bloco de Finally é executado sempre quando a execução permite que qualquer parte da declaração de Try...Catch .
finallyStatements	Opcional.A instrução que é executado após o outro processamento de erro ocorreu.
End Try	Finaliza a estrutura de Try...Catch...Finally .

Comentários

Se você pretende que uma exceção específica pode ocorrer durante uma determinada seção de código, coloque o código em um bloco de Try e usam um bloco de Catch para manter controle e tratar a exceção ocorre se.

Uma declaração de Try…Catch consiste em um bloco de Try seguido por um ou mais cláusulas de Catch , que especificam manipuladores para várias exceções.Quando uma exceção é lançada em um bloco de Try , Visual Basic procura pela instrução de Catch que lida com a exceção.Se uma instrução de Catch de correspondência não for encontrada, Visual Basic examina o método que chamou o método atual, e assim por diante até que a pilha de chamadas.Se nenhum bloco de Catch for encontrado, Visual Basic exibe uma mensagem de exceção sem tratamento para o usuário e para a execução do programa.

Você pode usar mais de uma declaração de Catch em uma instrução de Try…Catch .Se você fizer isso, a ordem das cláusulas de Catch é útil porque eles são examinados em ordem.Capturar exceções mais específicas antes de menos específicas.

As seguintes condições de instrução de Catch é ao menos específicas, e capturarão todas as exceções que derivam da classe de Exception .Você normalmente deve usar uma de essas variações como o último bloco de Catch na estrutura de Try...Catch...Finally , após capturado todas as exceções específicas que você espera.O fluxo de controle nunca pode alcançar um bloco de Catch que segue qualquer uma de essas variações.

type é Exception, por exemplo: Catch ex As Exception
A declaração não tem nenhum variável de exception , por exemplo: Catch

Quando uma declaração de Try…Catch…Finally está aninhado em outro bloco de Try , Visual Basic primeiro examina cada instrução de Catch no bloco interno de Try .Se nenhuma instrução de Catch de correspondência for encontrada, a pesquisa continua às instruções de Catch do bloco externo de Try…Catch…Finally .

Variáveis locais de um bloco de Try não estão disponíveis em um bloco de Catch blocos porque eles são separados.Se você desejar usar uma variável em mais de um bloco, declare a variável fora da estrutura de Try...Catch...Finally .

Dica
A declaração de Try…Catch…Finally está disponível como um trecho de código IntelliSense.Em o gerenciador de trechos de código, expanda Padrões de código - se para, cada um, a captura try, a propriedade, etc., e então Tratamento de erros (exceções).Para mais informações, consulte Trechos de código.

Bloco finally

Se você tiver uma ou mais instruções que devem executar antes de sair da estrutura Try use um bloco Finally.O controle passa para o bloco Finally logo antes de sair da estrutura Try…Catch.Isso é verdadeiro mesmo se uma exceção ocorre em qualquer lugar dentro da estrutura Try.

Um bloco de Finally é útil para executar qualquer código que é executando mesmo se houver uma exceção.O controle é passado para o bloco de Finally independentemente de como Try...Catch sai do bloco.

O código em um bloco de Finally executa mesmo se o seu código encontra uma instrução de Return em um bloco de Try ou de Catch .O controle não passa de um bloco Try ou Catch para o bloco Finally correpondente nos seguintes casos:

Instrução End está localizado no bloco de Try ou de Catch .
StackOverflowException é lançada no bloco de Try ou de Catch .

é inválido transferir explicitamente a execução em um bloco de Finally .Transferir a execução fora de um bloco de Finally é inválido, exceto com uma exceção.

Se uma instrução de Try não contém pelo menos um bloco de Catch , deve conter um bloco de Finally .

Dica
Se você não precisa capturar exceções específicas, a instrução de Using se comporta como um bloco de Try…Finally , e garante a liberação de recursos, independentemente de como você sai do bloco.Isso é verdadeiro mesmo com uma exceção não tratada.Para mais informações, consulte Usando instrução (Visual Basic).

Argumento de exceção

O argumento de exception do bloco de Catch é uma instância da classe de Exception ou de uma classe que deriva da classe de Exception .A instância de classe de Exception corresponde ao erro que ocorreu no bloco de Try .

As propriedades do objeto de Exception ajudam a identificar a causa e o local de uma exceção.Por exemplo, a propriedade lista de StackTrace os métodos que chamados que conduziu à exceção, ajudando você encontrar onde ocorreu o erro no código.Message retorna uma mensagem que descreve a exceção.HelpLink retorna um link para um arquivo de ajuda associado.InnerException retorna o objeto de Exception que causou a exceção atual, ou retorna Nothing se não houver nenhum Exceptionoriginal.

Considerações ao usar uma captura a instrução try…

Use uma instrução de Try…Catch para sinalizar somente a ocorrência de eventos ou incomuns não-antecipados do programa.As razões para essa incluem o seguinte:

Capturar exceções em tempo de execução cria a sobrecarga adicional, e é provável de ser mais lento do que significa verificando para evitar exceções.
Se um bloco de Catch não é tratado corretamente, a exceção não pode ser relatadas corretamente aos usuários.
Manipulação de exceção torna um programa mais complexo.

Você não precisa sempre uma instrução de Try…Catch de verificar se houver uma condição que é provável de ocorrer.O exemplo a seguir verifica se um arquivo existe antes de tentar abrir a.Isso reduz a necessidade para capturar uma exceção acionada pelo método de OpenText .

Private Sub TextFileExample(ByVal filePath As String)

    ' Verify that the file exists.
    If System.IO.File.Exists(filePath) = False Then
        Console.Write("File Not Found: " & filePath)
    Else
        ' Open the text file and display its contents.
        Dim sr As System.IO.StreamReader =
            System.IO.File.OpenText(filePath)

        Console.Write(sr.ReadToEnd)

        sr.Close()
    End If
End Sub

Certifique-se de que o código nos blocos de Catch pode relatar exceções corretamente para usuários, se através de log thread-safe ou apropriado para mensagens.Caso contrário, as exceções desconhecidas podem continuar.

Métodos de Async

Se você marcar um método com o modificador de Async , você pode usar o operador de espere no método.Uma instrução com o operador de Await suspende a execução do método até que a tarefa deve terminar.A tarefa representa trabalho contínuo.Quando a tarefa que está associada com o operador de Await concluir, a execução continua no mesmo método.Para mais informações, consulte Fluxo de controle em programas Async (C# e Visual Basic).

Uma tarefa retornada por um método de Async pode finalizar em um estado criticado, indicando que tiver terminado por causa de uma exceção sem tratamento.Uma tarefa também pode finalizar em um estado cancelado, que resulta em OperationCanceledException que está sendo gerada fora da expressão de espera.Para capturar um ou outro tipo de exceção, coloque a expressão de Await que está associada com a tarefa em um bloco de Try , e capturar a exceção no bloco de Catch .Um exemplo é apresentado posteriormente em este tópico.

Uma tarefa pode estar em um estado criticado porque as várias exceções eram responsáveis por sua crítica.Por exemplo, a tarefa pode ser o resultado de uma chamada a Task.WhenAll.Quando você espera uma tarefa, a exceção capturada é apenas uma das exceções, e você não pode prever que será exceção capturada.Um exemplo é apresentado posteriormente em este tópico.

Uma expressão de Await não pode ser dentro de um bloco de Catch ou bloco de Finally .

Iteradores

Uma função de iterador ou um acessador de Get executam uma iteração personalizado em uma coleção.Um iterador usa uma instrução de Produzir para retornar um de cada vez a cada elemento da coleção.Você chama uma função de iterador usando Para cada...Próxima instrução (Visual Basic).

Uma declaração de Yield pode estar dentro de um bloco de Try .Um bloco de Try que contém uma declaração de Yield pode ter blocos de Catch , e pode ter um bloco de Finally .Consulte “blocos try a seção no Visual Basic” de Iteradores (C# e Visual Basic) para um exemplo.

Uma declaração de Yield não pode ser dentro de um bloco de Catch ou um bloco de Finally .

Se o corpo de For Each (fora da função de iterador) gera uma exceção, um bloco de Catch na função de iterador não é executado, mas um bloco de Finally na função de iterador é executado.Um bloco de Catch dentro de uma função de iterador somente captura exceções que ocorrem dentro da função de iterador.

Situações de Confiança parcial

Em situações de confiança parcial, como um aplicativo hospedado em um compartilhamento de rede, Try...Catch...Finally não captura exceções de segurança que ocorre antes que o método que contém a chamada seja chamado.O seguinte exemplo, quando você colocar o em um compartilhamento de servidor e executá-lo de aí, gera erro “System.Security.SecurityException: Solicitação falha.” Para obter mais informações sobre as exceções de segurança, consulte a classe de SecurityException .

Try
    Process.Start("https://www.microsoft.com")
Catch ex As Exception
    MsgBox("Can't load Web page" & vbCrLf & ex.Message)
End Try

Em uma situação de confiança parcial, você precisa colocar a instrução de Process.Start em Subseparado.A chamada inicial a Sub falhará.Isso permite que Try...Catch para capturar-lo antes que Sub que contém Process.Start é iniciado e a exceção de segurança gerada.

Exemplo

O exemplo a seguir ilustra a estrutura de instrução de Try...Catch...Finally .

Public Sub TryExample()
    ' Declare variables.
    Dim x As Integer = 5
    Dim y As Integer = 0

    ' Set up structured error handling.
    Try
        ' Cause a "Divide by Zero" exception.
        x = x \ y

        ' This statement does not execute because program
        ' control passes to the Catch block when the
        ' exception occurs.
        MessageBox.Show("end of Try block")
    Catch ex As Exception
        ' Show the exception's message.
        MessageBox.Show(ex.Message)

        ' Show the stack trace, which is a list of methods
        ' that are currently executing.
        MessageBox.Show("Stack Trace: " & vbCrLf & ex.StackTrace)
    Finally
        ' This line executes whether or not the exception occurs.
        MessageBox.Show("in Finally block")
    End Try
End Sub

Em o exemplo, o método de CreateException gera NullReferenceException.O código que gera a exceção não estiver em um bloco de Try .Portanto, o método de CreateException não lida com a exceção.O método de RunSample lida com a exceção como a chamada para o método de CreateException está em um bloco de Try .

O exemplo inclui instruções de Catch para vários tipos de exceções, ordenados da mais específica para mais geral.

Public Sub RunSample()
    Try
        CreateException()
    Catch ex As System.IO.IOException
        ' Code that reacts to IOException.
    Catch ex As NullReferenceException
        MessageBox.Show("NullReferenceException: " & ex.Message)
        MessageBox.Show("Stack Trace: " & vbCrLf & ex.StackTrace)
    Catch ex As Exception
        ' Code that reacts to any other exception.
    End Try
End Sub

Private Sub CreateException()
    ' This code throws a NullReferenceException.
    Dim obj = Nothing
    Dim prop = obj.Name

    ' This code also throws a NullReferenceException.
    'Throw New NullReferenceException("Something happened.")
End Sub

O exemplo a seguir mostra como usar uma instrução de Catch When para filtrar utilizando uma expressão condicional.Se a expressão condicional for avaliada como True, o código no bloco de Catch executa.

Private Sub WhenExample()
    Dim i As Integer = 5

    Try
        Throw New ArgumentException()
    Catch e As OverflowException When i = 5
        Console.WriteLine("First handler")
    Catch e As ArgumentException When i = 4
        Console.WriteLine("Second handler")
    Catch When i = 5
        Console.WriteLine("Third handler")
    End Try
End Sub
' Output: Third handler

O exemplo tem uma instrução de Try…Catch que está contida em um bloco de Try .O bloco interno de Catch gera uma exceção que tem sua propriedade definida InnerException da exceção original.O bloco externo de Catch relata sua própria exceção e a exceção interna.

Private Sub InnerExceptionExample()
    Try
        Try
            ' Set a reference to a StringBuilder.
            ' The exception below does not occur if the commented
            ' out statement is used instead.
            Dim sb As System.Text.StringBuilder
            'Dim sb As New System.Text.StringBuilder

            ' Cause a NullReferenceException.
            sb.Append("text")
        Catch ex As Exception
            ' Throw a new exception that has the inner exception
            ' set to the original exception.
            Throw New ApplicationException("Something happened :(", ex)
        End Try
    Catch ex2 As Exception
        ' Show the exception.
        Console.WriteLine("Exception: " & ex2.Message)
        Console.WriteLine(ex2.StackTrace)

        ' Show the inner exception, if one is present.
        If ex2.InnerException IsNot Nothing Then
            Console.WriteLine("Inner Exception: " & ex2.InnerException.Message)
            Console.WriteLine(ex2.StackTrace)
        End If
    End Try
End Sub

O exemplo a seguir ilustra a manipulação de exceção para métodos de async.Para capturar uma exceção que se aplica a uma tarefa de async, a expressão de Await está em um bloco de Try do chamador, e a exceção é detectada no bloco de Catch .

Tire comentários da linha de Throw New Exception no exemplo para demonstrar manipulação de exceção.A exceção é detectada no bloco de Catch , a propriedade de IsFaulted de tarefa é definida como True, e a propriedade de Exception.InnerException de tarefa é definida para a exceção.

Tire comentários da linha de Throw New OperationCancelledException para demonstrar o que acontece quando você cancelar um processo assíncrono.A exceção é detectada no bloco de Catch , e a propriedade de IsCanceled de tarefa é definida como True.Em o entanto, em algumas circunstâncias que não se aplicam a esse exemplo, IsFaulted é definido como True e IsCanceled é definido como False.

Public Async Function DoSomethingAsync() As Task
    Dim theTask As Task(Of String) = DelayAsync()

    Try
        Dim result As String = Await theTask
        Debug.WriteLine("Result: " & result)
    Catch ex As Exception
        Debug.WriteLine("Exception Message: " & ex.Message)
    End Try

    Debug.WriteLine("Task IsCanceled: " & theTask.IsCanceled)
    Debug.WriteLine("Task IsFaulted:  " & theTask.IsFaulted)
    If theTask.Exception IsNot Nothing Then
        Debug.WriteLine("Task Exception Message: " &
            theTask.Exception.Message)
        Debug.WriteLine("Task Inner Exception Message: " &
            theTask.Exception.InnerException.Message)
    End If
End Function

Private Async Function DelayAsync() As Task(Of String)
    Await Task.Delay(100)

    ' Uncomment each of the following lines to
    ' demonstrate exception handling.

    'Throw New OperationCanceledException("canceled")
    'Throw New Exception("Something happened.")
    Return "Done"
End Function


' Output when no exception is thrown in the awaited method:
'   Result: Done
'   Task IsCanceled: False
'   Task IsFaulted:  False

' Output when an Exception is thrown in the awaited method:
'   Exception Message: Something happened.
'   Task IsCanceled: False
'   Task IsFaulted:  True
'   Task Exception Message: One or more errors occurred.
'   Task Inner Exception Message: Something happened.

' Output when an OperationCanceledException or TaskCanceledException
' is thrown in the awaited method:
'   Exception Message: canceled
'   Task IsCanceled: True
'   Task IsFaulted:  False

O exemplo a seguir ilustra a manipulação de exceção onde várias tarefas podem resultar em várias exceções.O bloco de Try tem a expressão de Await para a tarefa que o Task.WhenAll retornado.A tarefa é concluída quando as três tarefas que é aplicado a Task.WhenAll está concluída.

Cada uma das três tarefas causa de uma exceção.O bloco de Catch itera com exceções, que são encontrados na propriedade de Exception.InnerExceptions de tarefa que o Task.WhenAll retornado.

Public Async Function DoMultipleAsync() As Task
    Dim theTask1 As Task = ExcAsync(info:="First Task")
    Dim theTask2 As Task = ExcAsync(info:="Second Task")
    Dim theTask3 As Task = ExcAsync(info:="Third Task")

    Dim allTasks As Task = Task.WhenAll(theTask1, theTask2, theTask3)

    Try
        Await allTasks
    Catch ex As Exception
        Debug.WriteLine("Exception: " & ex.Message)
        Debug.WriteLine("Task IsFaulted: " & allTasks.IsFaulted)
        For Each inEx In allTasks.Exception.InnerExceptions
            Debug.WriteLine("Task Inner Exception: " + inEx.Message)
        Next
    End Try
End Function

Private Async Function ExcAsync(info As String) As Task
    Await Task.Delay(100)

    Throw New Exception("Error-" & info)
End Function

' Output:
'   Exception: Error-First Task
'   Task IsFaulted: True
'   Task Inner Exception: Error-First Task
'   Task Inner Exception: Error-Second Task
'   Task Inner Exception: Error-Third Task