Rastreamento e depuração no Visual C sharp

Artigo
03/10/2024

Este artigo descreve como rastrear e depurar no Visual C# e fornece algumas etapas de exemplo para explicar as informações relacionadas.

Versão original do produto: Visual C#
Número de KB original: 815788

Resumo

Para obter uma versão do .NET do Microsoft Visual Basic deste artigo, confira Usar classes de rastreamento e depuração no Visual Basic .NET.

Este artigo refere-se ao sistema de namespace da Biblioteca de Classes .NET Framework. Diagnóstico e descreve como usar as Debug classes e Trace . Essas classes estão disponíveis no .NET Framework. Você pode usar essas classes para fornecer informações sobre o desempenho de um aplicativo durante o desenvolvimento do aplicativo ou após a implantação na produção. Essas classes são apenas uma parte dos recursos de instrumentação que estão disponíveis no .NET Framework.

Requisitos

A lista a seguir descreve os pacotes de serviço, software, infraestrutura de rede e hardware recomendados que você precisa:

Microsoft Windows
Microsoft Visual C#

Este artigo também pressupõe que você esteja familiarizado com a depuração do programa.

Descrição da técnica

As etapas na seção Criar um Exemplo com a Classe Depuração demonstram como criar um aplicativo de console que usa a Debug classe para fornecer informações sobre a execução do programa.

Quando o programa é executado, você pode usar métodos da Debug classe para produzir mensagens que ajudam você a monitorar a sequência de execução do programa, detectar defeitos ou fornecer informações de medição de desempenho. Por padrão, as mensagens que a Debug classe produz aparecem na janela Saída do Ambiente de Desenvolvimento Integrado do Visual Studio (IDE).

O código de exemplo usa o WriteLine método para produzir uma mensagem seguida por um terminador de linha. Quando você usa esse método para produzir uma mensagem, cada mensagem é exibida em uma linha separada na janela Saída.

Quando você usa o Assert método da Debug classe, a janela Saída exibe uma mensagem somente se uma condição especificada for avaliada como false. A mensagem também aparece em uma caixa de diálogo modal para o usuário. A caixa de diálogo inclui a mensagem, o nome do projeto e o Debug. Afirme o número da instrução. A caixa de diálogo também inclui os seguintes três botões de comando:

Abortar: O aplicativo para de ser executado.
Repetir: O aplicativo insere o modo de depuração.
Ignorar: O aplicativo prossegue. O usuário deve clicar em um desses botões antes que o aplicativo possa continuar.

Você também pode direcionar a saída da Debug classe para destinos diferentes da janela Saída. A Debug classe tem uma coleção Listeners que inclui Listener objetos.

Cada objeto Listener monitora Debug a saída e direciona a saída para um destino especificado.

Cada ouvinte da coleção Ouvinte recebe qualquer saída gerada pela Debug classe. Use a TextWriterTraceListener classe para definir Listener objetos. Você pode especificar o destino de uma TextWriterTraceListener classe por meio de seu construtor.

Alguns possíveis destinos de saída incluem o seguinte:

A janela Console usando a System.Console.Out propriedade.
Um arquivo de texto (.txt) usando a System.IO.File.CreateText("FileName.txt") instrução. Depois de criar um TextWriterTraceListener objeto, você deve adicionar o objeto ao Debug. Coleção de ouvintes para receber Debug a saída.

Criar um exemplo com a classe Depuração

Inicie o Visual Studio ou Visual C# Express Edition.
Crie um novo projeto de Aplicativo de Console do Visual C# chamado conInfo. O Class1 é criado no Visual Studio .NET. Program.cs é criado no Visual Studio 2005.
Adicione o namespace a seguir na parte superior da Classe1 ou Program.cs.
```
using System.Diagnostics;
```
Para inicializar variáveis para conter informações sobre um produto, adicione as seguintes instruções de declaração ao método Main:
```
string sProdName = "Widget";
int iUnitQty = 100;
double dUnitCost = 1.03;
```
Especifique a mensagem que a classe produz como o primeiro parâmetro de entrada do WriteLine método. Pressione a combinação de teclas CTRL+ALT+O para verificar se a janela Saída está visível.
```
Debug.WriteLine("Debug Information-Product Starting ");
```
Para legibilidade, use o Indent método para recuo de mensagens subsequentes na janela Saída:
```
Debug.Indent();
```

Para exibir o conteúdo das variáveis selecionadas, use o método da WriteLine seguinte maneira:

Debug.WriteLine("The product name is " + sProdName);
Debug.WriteLine("The available units on hand are" + iUnitQty.ToString());
Debug.WriteLine("The per unit cost is " + dUnitCost.ToString());

Você também pode usar o WriteLine método para exibir o namespace e o nome da classe para um objeto existente. Por exemplo, o código a seguir exibe o System.Xml.XmlDocument namespace na janela Saída:
```
System.Xml.XmlDocument oxml = new System.Xml.XmlDocument();
Debug.WriteLine(oxml);
```
Para organizar a saída, você pode incluir uma categoria como um parâmetro de entrada opcional e segundo do WriteLine método. Se você especificar uma categoria, o formato da mensagem da janela Saída será "categoria: mensagem". Por exemplo, a primeira linha do código a seguir exibe "Campo: o nome do produto é Widget" na janela Saída:
```
Debug.WriteLine("The product name is " + sProdName,"Field");
Debug.WriteLine("The units on hand are" + iUnitQty,"Field");
Debug.WriteLine("The per unit cost is" + dUnitCost.ToString(),"Field");
Debug.WriteLine("Total Cost is " + (iUnitQty * dUnitCost),"Calc");
```
A janela Saída só poderá exibir mensagens se uma condição designada for avaliada como true usando o WriteLineIf método da Debug classe. A condição a ser avaliada é o primeiro parâmetro de entrada do WriteLineIf método. O segundo parâmetro da WriteLineIf é a mensagem que aparece somente se a condição no primeiro parâmetro for avaliada como true.
```
Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear");
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear");
```
Use o método Assert da Debug classe para que a janela Saída exiba a mensagem somente se uma condição especificada for avaliada como false:
```
Debug.Assert(dUnitCost > 1, "Message will NOT appear");
Debug.Assert(dUnitCost < 1, "Message will appear since dUnitcost < 1 is false");
```

Crie os TextWriterTraceListener objetos para a janela Console (tr1) e para um arquivo de texto chamado Output.txt (tr2) e adicione cada objeto à coleção Ouvintes de Depuração:

TextWriterTraceListener tr1 = new TextWriterTraceListener(System.Console.Out);
Debug.Listeners.Add(tr1);

TextWriterTraceListener tr2 = new TextWriterTraceListener(System.IO.File.CreateText("Output.txt"));
Debug.Listeners.Add(tr2);

Para legibilidade, use o Unindent método para remover o recuo para mensagens subsequentes geradas pela Debug classe. Quando você usa os Indent métodos e Unindent juntos, o leitor pode distinguir a saída como grupo.
```
Debug.Unindent();
Debug.WriteLine("Debug Information-Product Ending");
```
Para garantir que cada Listener objeto receba toda a saída, chame o método Flush para os buffers de Debug classe:
```
Debug.Flush();
```

Usando a classe Trace

Você também pode usar a Trace classe para produzir mensagens que monitoram a execução de um aplicativo. As Trace classes e Debug compartilham a maioria dos mesmos métodos para produzir a saída, incluindo o seguinte:

WriteLine
Writelineif
Recuo
Unindent
Assert
Flush

Você pode usar as Trace classes e Debug separadamente ou juntas no mesmo aplicativo. Em um projeto de Configuração de Solução de Depuração, tanto quanto TraceDebug a saída estão ativas. O projeto gera a saída de ambas as classes para todos os Listener objetos. No entanto, um projeto de Configuração de Solução de Lançamento gera apenas a saída de uma Trace classe. O projeto Configuração da Solução de Versão ignora todas Debug as invocações de método de classe.

Trace.WriteLine("Trace Information-Product Starting ");
Trace.Indent();

Trace.WriteLine("The product name is "+sProdName);
Trace.WriteLine("The product name is"+sProdName,"Field" );
Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear");
Trace.Assert(dUnitCost > 1, "Message will NOT appear");

Trace.Unindent();
Trace.WriteLine("Trace Information-Product Ending");

Trace.Flush();

Console.ReadLine();

Verificar se ele funciona

Verifique se Depurar é a configuração da solução atual.
Se a janela Gerenciador de Soluções não estiver visível, pressione a combinação de teclas CTRL+ALT+L para exibir essa janela.
Clique com o botão direito do mouse em conInfo e clique em Propriedades.
No painel esquerdo da página de propriedade conInfo , na pasta Configuração , verifique se a seta aponta para Depuração.

Observação

No Visual C# 2005 e no Visual C# 2005 Express Edition, clique em Depurar na página conInfo .
Acima da pasta Configuração , na caixa de lista suspensa Configuração , clique em Ativo (Depuração) ou Depuração e clique em OK. No Visual C# 2005 e no Visual C# 2005 Express Edition, clique em Ativo (Depuração) ou Depurar na caixa lista suspensa Configuração na página Depuração e clique em Salvar no menu Arquivo .
Pressione CTRL+ALT+O para exibir a janela Saída .
Pressione a tecla F5 para executar o código. Quando a caixa de diálogo Falha de Declaração for exibida, clique em Ignorar.

Na janela Console , pressione ENTER. O programa deve ser concluído e a janela Saída deve exibir a saída que se assemelha à seguinte:

Debug Information-Product Starting
The product name is Widget
The available units on hand are100
The per unit cost is 1.03
System.Xml.XmlDocument
Field: The product name is Widget
Field: The units on hand are100
Field: The per unit cost is1.03
Calc: Total Cost is 103
This message WILL appear
---- DEBUG ASSERTION FAILED ----
---- Assert Short Message ----
Message will appear since dUnitcost < 1 is false
---- Assert Long Message ----

at Class1.Main(String[] args) <%Path%>\class1.cs(34)

The product name is Widget
The available units on hand are100
The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
The product name is Widget
Field: The product name isWidget
This message WILL appear
Trace Information-Product Ending

A janela Console e o arquivo Output.txt devem exibir a seguinte saída:

The product name is Widget
The available units on hand are 100
The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
The product name is Widget
Field: The product name is Widget
This message WILL appear
Trace Information-Product Ending

Observação

O arquivo Output.txt está localizado no mesmo diretório que o executável conInfo (conInfo.exe). Normalmente, essa é a pasta \bin em que a origem do projeto é armazenada. Por padrão, é C:\Documents and Settings\User login\My Documents\Visual Studio Projects\conInfo\bin No Visual C# 2005 e no Visual C# 2005 Express Edition, o arquivo Output.txt está localizado na pasta: C:\Documents and Settings\User login\My Documents\Visual Studio 2005\Projects\conInfo\conInfo\bin\Debug.

Lista de códigos completa

using System;
using System.Diagnostics;

class Class1
{
    [STAThread]
    static void Main(string[] args)
    {
        string sProdName = "Widget";
        int iUnitQty = 100;
        double dUnitCost = 1.03;
        Debug.WriteLine("Debug Information-Product Starting ");
        Debug.Indent();
        Debug.WriteLine("The product name is "+sProdName);
        Debug.WriteLine("The available units on hand are"+iUnitQty.ToString());
        Debug.WriteLine("The per unit cost is "+ dUnitCost.ToString());

        System.Xml.XmlDocument oxml = new System.Xml.XmlDocument();
        Debug.WriteLine(oxml);

        Debug.WriteLine("The product name is "+sProdName,"Field");
        Debug.WriteLine("The units on hand are"+iUnitQty,"Field");
        Debug.WriteLine("The per unit cost is"+dUnitCost.ToString(),"Field");
        Debug.WriteLine("Total Cost is "+(iUnitQty * dUnitCost),"Calc");

        Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear");
        Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear");

        Debug.Assert(dUnitCost > 1, "Message will NOT appear");
        Debug.Assert(dUnitCost < 1, "Message will appear since dUnitcost < 1 is false");

        TextWriterTraceListener tr1 = new TextWriterTraceListener(System.Console.Out);
        Debug.Listeners.Add(tr1);

        TextWriterTraceListener tr2 = new TextWriterTraceListener(System.IO.File.CreateText("Output.txt"));
        Debug.Listeners.Add(tr2);

        Debug.WriteLine("The product name is "+sProdName);
        Debug.WriteLine("The available units on hand are"+iUnitQty);
        Debug.WriteLine("The per unit cost is "+dUnitCost);
        Debug.Unindent();
        Debug.WriteLine("Debug Information-Product Ending");
        Debug.Flush();

        Trace.WriteLine("Trace Information-Product Starting ");
        Trace.Indent();

        Trace.WriteLine("The product name is "+sProdName);
        Trace.WriteLine("The product name is"+sProdName,"Field" );
        Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear");
        Trace.Assert(dUnitCost > 1, "Message will NOT appear");

        Trace.Unindent();
        Trace.WriteLine("Trace Information-Product Ending");

        Trace.Flush();

        Console.ReadLine();
    }
}

Solução de problemas

Se o tipo de configuração da solução for Release, a saída da Debug classe será ignorada.
Depois de criar uma TextWriterTraceListener classe para um destino específico, TextWriterTraceListener recebe a saída das Trace classes e Debug . Isso ocorre independentemente de você usar o Add método da Trace classe ou para Debug adicionar TextWriterTraceListener à Listeners classe.

Se você adicionar um Listeners objeto para o mesmo destino nas Trace classes e Debug , cada linha de saída será duplicada, independentemente de gerar Debug ou Trace gerar a saída.

TextWriterTraceListener myWriter = new TextWriterTraceListener(System.Console.Out);
Debug.Listeners.Add(myWriter);

TextWriterTraceListener myCreator = new TextWriterTraceListener(System.Console.Out);
Trace.Listeners.Add(myCreator);