Gerenciar exceções com o depurador no Visual Studio

Uma exceção é uma indicação de um estado de erro que ocorre enquanto um programa está a ser executado. Pode indicar ao depurador em que exceções ou conjuntos de exceções deve interromper, e em que ponto deseja que o depurador pare, ou seja, faça uma pausa. Quando o depurador falha, mostra-te onde foi lançada a exceção. Também pode adicionar ou eliminar exceções. Com uma solução aberta no Visual Studio, use Debug > Windows > Exception Settings para abrir a janela Exception Settings.

Fornecer manipuladores que respondam às exceções mais importantes. Se precisares de saber como adicionar handlers para exceções, vê Corrigir bugs escrevendo melhor código em C#. Além disso, saiba como configurar o depurador para interromper sempre a execução para algumas exceções.

Quando ocorre uma exceção, o depurador escreve uma mensagem de exceção na janela de Saída . Pode interromper a execução nos seguintes casos quando:

• É lançada uma exceção que não é tratada.
• O depurador está configurado para interromper a execução antes de qualquer handler ser invocado.
• Definiste Just My Code, e o depurador está configurado para interromper em qualquer exceção que não seja tratada no código do utilizador.

Diga ao depurador para interromper quando ocorrer uma exceção

O depurador pode interromper a execução no momento em que uma exceção é lançada, por isso pode examinar a exceção antes de um handler ser invocado.

Na janela de Definições de Exceção (Depurar > Definições de Exceções do Windows>), expanda o nó para uma categoria de exceções, como Exceções de Execução de Linguagem Comum. Depois seleciona a caixa de seleção para uma exceção específica dentro dessa categoria, como System.AccessViolationException. Também pode selecionar uma categoria inteira de exceções.

Se seleccionares uma exceção na janela Definições de Exceção, a execução do depurador será interrompida sempre que a exceção for lançada, independentemente de ser tratada ou não. Agora, a exceção chama-se exceção de primeira oportunidade. Por exemplo, aqui estão alguns cenários:

• Na aplicação de consola C# seguinte, o método Main lança uma AccessViolationException dentro de um try/catch bloco.

  static void Main(string[] args)
  {
      try
      {
          throw new AccessViolationException();
          Console.WriteLine("here");
      }
      catch (Exception e)
      {
          Console.WriteLine("caught exception");
      }
      Console.WriteLine("goodbye");
  }
  

  Se tiveres AccessViolationException ativado nas Definições de Exceção, a execução falha na throw linha quando executas este código no depurador. Depois podes continuar a execução. A consola deve mostrar ambas as linhas:

  caught exception
  goodbye
  

  Mas não mostra a linha here.

• Uma aplicação de consola C# faz referência a uma biblioteca de classes com uma classe que tem dois métodos. Um método lança uma exceção e trata dela, enquanto um segundo método lança a mesma exceção mas não a gere.

  public class Class1
  {
      public void ThrowHandledException()
      {
          try
          {
              throw new AccessViolationException();
          }
          catch (AccessViolationException ave)
          {
              Console.WriteLine("caught exception" + ave.Message);
          }
      }
  
      public void ThrowUnhandledException()
      {
          throw new AccessViolationException();
      }
  }
  

  Aqui está o método Main() da aplicação de consola:

  static void Main(string[] args)
  {
      Class1 class1 = new Class1();
      class1.ThrowHandledException();
      class1.ThrowUnhandledException();
  }
  

  Se tiver o AccessViolationException ativado nas Definições de Exceção, a execução interromper-se-á na throw linha tanto em ThrowHandledException() como em ThrowUnhandledException() quando executar este código no depurador.

Para restaurar as definições de exceção aos predefinidos, escolha o botão Restaurar a lista para as definições predefinidas :

Instrua o depurador para prosseguir após exceções não geridas pelo utilizador

Se estiveres a depurar código .NET ou JavaScript com Just My Code, podes dizer ao depurador para evitar falhas em exceções que não são tratadas no código do utilizador, mas que são tratadas noutros locais.

1. Na janela de Definições de Exceção , abra o menu de atalhos clicando com o botão direito no rótulo de uma coluna e depois selecione Mostrar Colunas > Ações Adicionais. (Se desligaste o Just My Code, não vais ver este comando.) Surge uma terceira coluna chamada Ações Adicionais .

   

   Para uma exceção que mostra Continuar quando não é tratado pelo código do utilizador nesta coluna, o depurador continua se essa exceção não for tratada pelo código do utilizador, mas é tratada externamente.

2. Para alterar esta definição para uma exceção específica, selecione a exceção, clique com o botão direito para mostrar o menu de atalho e selecione Continuar Quando Não Tratado no Código de Utilizador. Também pode alterar a definição para uma categoria inteira de exceções, como as exceções inteiras do Common Language Runtime).

   

Por exemplo, ASP.NET aplicações web tratam exceções convertendo-as para um código de estado HTTP 500 (Tratamento de exceções na ASP.NET Web API), o que pode não ajudar a determinar a origem da exceção. No exemplo abaixo, o código de utilizador faz uma chamada para String.Format() que lança um FormatException. Os pontos de interrupção da execução são os seguintes:

Adicionar e eliminar exceções

Podes adicionar e eliminar exceções. Para eliminar um tipo de exceção de uma categoria, selecione a exceção e escolha o botão Eliminar a exceção selecionada da lista (o sinal menos) na barra de ferramentas Definições de Exceção. Ou pode clicar com o botão direito na exceção e selecionar Eliminar no menu de atalho. Eliminar uma exceção tem o mesmo efeito que estar desmarcada, que é que o depurador não irá parar quando a exceção for lançada.

Para acrescentar uma exceção:

1. Na janela de Definições de Exceção , selecione uma das categorias de exceções (por exemplo, Common Language Runtime).

2. Escolhe o botão Adicionar uma exceção à categoria selecionada (o sinal mais).

   

3. Digite o nome da exceção (por exemplo, System.UriTemplateMatchException).

   

   A exceção é adicionada à lista (por ordem alfabética) e assinalada automaticamente.

Para adicionar uma exceção às categorias de Exceções de Acesso à Memória GPU, Exceções de Tempo de Execução JavaScript ou Exceções Win32, inclua o código de erro e a descrição.

As definições de exceção são mantidas no ficheiro .suo da solução, pelo que se aplicam a uma solução específica. Não podes reutilizar definições específicas de exceção entre soluções. Agora, somente as exceções adicionadas são mantidas; as exceções apagadas não permanecem. Pode adicionar uma exceção, fechar e reabrir a solução, e a exceção continuará lá. Mas se apagares uma exceção e fechares/reabrir a solução, a exceção reaparecerá.

A janela de Definições de Exceção suporta tipos genéricos de exceção em C#, mas não no Visual Basic. Para quebrar exceções como MyNamespace.GenericException<T>, deve adicionar a exceção como MyNamespace.GenericException'1. Isto é, se criou uma exceção como este código:

public class GenericException<T> : Exception
{
    public GenericException() : base("This is a generic exception.")
    {
    }
}

Pode adicionar a exceção às Definições de Exceção usando o procedimento anterior:

Adicionar condições a uma exceção

Use a janela de Definições de Exceção para definir condições nas exceções. As condições atualmente suportadas incluem o(s) nome(s) dos módulos a incluir ou excluir para a exceção. Ao definir nomes de módulos como condições, pode optar por quebrar para a exceção apenas em certos módulos de código. Pode escolher também evitar quebras em módulos específicos.

Para adicionar exceções condicionais:

1. Escolha o botão Editar condições na janela de Definições de Exceção, ou clique com o botão direito na exceção e escolha Editar Condições.

   

2. Para adicionar condições obrigatórias extra à exceção, selecione Adicionar Condição para cada nova condição. Aparecem linhas de condição adicionais.

   

3. Para cada linha de condição, escreva o nome do módulo e altere a lista de operadores de comparação para Igual ou Não Igual. Pode especificar wildcards (\*) no nome para especificar mais do que um módulo.

4. Se precisares de eliminar uma condição, escolhe o X no final da linha da condição.

Conteúdo relacionado

• Continuar a executar após uma exceção
  
• Como: Examinar o código do sistema após uma exceção
  
• Como: Usar verificações nativas de tempo de execução
  
• Introdução ao depurador