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 ele deve parar, e em qual ponto você deseja que o depurador pause (ou seja, faça uma pausa no depurador). Quando o depurador interrompe, ele mostra onde a exceção ocorreu. Você também pode adicionar ou excluir exceções. Com uma solução aberta no Visual Studio, use Depurar > Configurações de Exceção do Windows > 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, consulte Corrigir bugs escrevendo um código C# melhor. Além disso, saiba como configurar o depurador para sempre interromper a execução sempre que ocorrerem algumas exceções.

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

• Uma exceção é lançada e não é tratada.
• O depurador é configurado para interromper a execução antes que qualquer manipulador seja invocado.
• Você definiu Just My Code e o depurador está configurado para interromper qualquer exceção que não seja tratada no código do usuário.

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

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

Na janela Configurações de Exceção (Depurar > Configurações de Exceção do Windows>), expanda o nó para uma categoria de exceções, como Exceções de 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 lança um 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 você tiver AccessViolationException selecionado nas Configurações de Exceção, a execução será interrompida na linha throw quando você executar este código no modo de depuração. Em seguida, você pode continuar a execução. O console deve exibir ambas as linhas:

  caught exception
  goodbye
  

  mas não exibe a here linha.

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

  Aqui está 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 nas Configurações de Exceção, a throw execução será interrompida na linha 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 Restaurar a lista para o botão de configurações padrão :

Diga ao depurador para continuar em exceções não manipuladas pelo usuário

Se você estiver depurando código .NET ou JavaScript com Just My Code, poderá instruir o depurador para impedir a quebra em exceções que não são manipuladas no código do usuário, mas que são tratadas em outras partes do código.

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 Ações Adicionais de Colunas>. (Se você desativou Just My Code, não verá este comando.) Uma terceira coluna chamada Ações Adicionais é exibida.

   

   Para uma exceção que exibe Continuar quando não for tratada 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 Não Tratado no Código do Usuário. Você também pode alterar a configuração de uma categoria inteira de exceções, como todas as exceções do Common Language Runtime).

   

Por exemplo, aplicativos Web ASP.NET manipulam exceções convertendo-as em um código de status HTTP 500 (manipulação de exceções em ASP.NET Web API), o que pode não ser útil para determinar a origem da exceção. No exemplo abaixo, o código do usuário faz uma chamada para String.Format() a qual gera um FormatException. A execução é dividida 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 da 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 desativada, ou seja, o depurador não interromperá 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 símbolo de mais).

   

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 exceções de acesso à memória gpu, exceções de runtime do JavaScript ou categorias de 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, somente exceções adicionadas são mantidas; exceções excluídas não sã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 em exceções. As condições com suporte no momento incluem os nomes dos módulos para inclusão ou exclusão na exceção. Definindo 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 interrupções 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 extras 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 Equals ou Not Equals. 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 o código do sistema após uma exceção
  
• Como usar verificações de tempo de execução nativas
  
• Introdução ao depurador