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á sendo executado. Você pode informar ao depurador em quais exceções ou conjuntos de exceções interromper e em qual ponto deseja que o depurador seja interrompido (ou seja, pausar o depurador). Quando o depurador é interrompido, ele mostra onde a exceção foi gerada. Você também pode adicionar ou excluir exceções. Com uma solução aberta no Visual Studio, use Depurar > Windows > Configurações de Exceção para abrir a janela Configurações de Exceção.

Forneça manipuladores que respondem às exceções mais importantes. Se você precisar saber como adicionar manipuladores para exceções, confira Corrigir bugs escrevendo um código C# melhor. Além disso, saiba como configurar o depurador para sempre interromper a execução de algumas exceções.

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

• É gerada uma exceção que não é tratada.
• O depurador é configurado para interromper a execução antes que qualquer manipulador seja invocado.
• Você definiu Apenas Meu Código e o depurador está configurado para interromper qualquer exceção que não seja tratada no código do usuário.

Informar depurador para interromper quando uma exceção for gerada

O depurador pode interromper a execução no ponto em que uma exceção é gerada para você poder examinar a exceção antes que um manipulador seja invocado.

Na janela Configurações de Exceção (Depurar > Windows > Configurações de Exceção ), expanda o nó para uma categoria de exceções, como Exceções do Common Language Runtime. Em seguida, marque a caixa de seleção para uma exceção específica dentro dessa categoria, como System.AccessViolationException. Você também pode selecionar uma categoria inteira de exceções.

Se você selecionar uma exceção na janela Configurações de Exceção, a execução do depurador será interrompida sempre que a exceção for gerada, independentemente de ela ser tratada. Agora, a exceção é chamada de exceção de primeira chance. Por exemplo, aqui estão alguns cenários:

• No aplicativo de console C# a seguir, o método Main gera uma AccessViolationException dentro de um bloco try/catch.

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

  Se você tiver AccessViolationException verificado em Configurações de Exceção, a execução será interrompida na linha throw quando você executar esse código no depurador. Em seguida, você pode continuar a execução. O console deve exibir as duas linhas:

  caught exception
  goodbye
  

  mas não exibe a linha here.

• Um aplicativo de console C# faz referência a uma biblioteca de classes com uma classe que tem dois métodos. Um método gera uma exceção e a manipula, enquanto um segundo método gera a mesma exceção, mas não a manipula.

  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();
      }
  }
  

  Este é o método Main() do aplicativo de console:

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

  Se você tiver AccessViolationException verificado em Configurações de Exceção, a execução será interrompida na linha throw em ThrowHandledException() e ThrowUnhandledException() quando você executar esse código no depurador.

Para restaurar as configurações de exceção para os padrões, escolha o botão Restaurar a lista para as configurações padrão:

Informar depurador para continuar em exceções sem tratamento do usuário

Se você estiver depurando o código .NET ou JavaScript com Apenas Meu Código, poderá instruir o depurador a impedir a interrupção de exceções que não são tratadas no código do usuário, mas que são tratadas em outro lugar.

1. Na janela Configurações de Exceção, abra o menu de atalho clicando com o botão direito do mouse em um rótulo de coluna e selecione Mostrar Colunas > Ações Adicionais. (Se você desativou Apenas Meu Código, não verá este comando.) Uma terceira coluna chamada Ações Adicionais é exibida.

   

   

   Para uma exceção que mostra Continuar quando sem tratamento no código do usuário nesta coluna, o depurador continuará se essa exceção não for tratada no código do usuário, mas for tratada externamente.

2. Para alterar essa configuração para uma exceção específica, selecione a exceção, clique com o botão direito do mouse para mostrar o menu de atalho e selecione Continuar Quando Sem Tratamento no Código do Usuário. Você também pode alterar a configuração de uma categoria inteira de exceções, como exceções do Common Language Runtime inteiras).

   

   

Por exemplo, aplicativos Web ASP.NET lidam com exceções convertendo-as em um código de status HTTP 500 (Tratamento de exceção em ASP.NET Web API), o que pode não ajudar você a determinar a origem da exceção. No exemplo abaixo, o código do usuário faz uma chamada para String.Format() que gera um FormatException. A execução é interrompida da seguinte maneira:

Adicionar e excluir exceções

Você pode adicionar e excluir exceções. Para excluir um tipo de exceção de uma categoria, selecione a exceção e escolha o botão Excluir a exceção selecionada na lista (o sinal de menos) na barra de ferramentas Configurações de Exceção. Ou você pode clicar com o botão direito do mouse na exceção e selecionar Excluir no menu de atalho. Excluir uma exceção tem o mesmo efeito que ter a exceção desmarcada, isto é, o depurador não será interrompido quando a exceção for lançada.

Para adicionar uma exceção:

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

2. Escolha o botão Adicionar uma exceção à categoria selecionada (o sinal de adição).

   

   

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

   

   

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

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

As configurações de exceção são mantidas no arquivo .suo da solução, portanto, elas se aplicam a uma solução específica. Não é possível reutilizar configurações de exceção específicas entre soluções. Agora, apenas exceções adicionadas persistem; exceções excluídas não. Você pode adicionar uma exceção, fechar e reabrir a solução, e a exceção ainda estará lá. Mas, se você excluir uma exceção e fechar/reabrir a solução, a exceção reaparecerá.

A janela Configurações de Exceção dá suporte a tipos de exceção genéricos em C#, mas não no Visual Basic. Para interromper exceções como MyNamespace.GenericException<T>, você deve adicionar a exceção como MyNamespace.GenericException'1. Ou seja, se você criou uma exceção como este código:

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

Você pode adicionar a exceção às Configurações de Exceção usando o procedimento anterior:

Adicionar condições a uma exceção

Use a janela Configurações de Exceção para definir condições sobre exceções. As condições com suporte no momento incluem os nomes do módulo a serem incluídos ou excluídos para a exceção. Ao definir nomes de módulo como condições, você pode optar por interromper a exceção somente em determinados módulos de código. Você também pode optar por evitar a interrupção em módulos específicos.

Para adicionar exceções condicionais:

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

   

2. Para adicionar condições adicionais necessárias à exceção, selecione Adicionar Condição para cada nova condição. Linhas de condição adicionais são exibidas.

   

3. Para cada linha de condição, digite o nome do módulo e altere a lista de operadores de comparação para Igual a ou Diferente de. Você pode especificar curingas (\*) no nome para especificar mais de um módulo.

4. Se você precisar excluir uma condição, escolha o X no final da linha de condição.

Conteúdo relacionado

• Continuar a execução após uma exceção
  
• Como examinar um código de sistema após uma exceção
  
• Como usar verificações de tempo de execução nativas
  
• Introdução ao depurador