Rastrear e depurar no Visual C sharp

2024-12-14

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

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

Resumo

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

Este artigo refere-se ao sistema de namespace da biblioteca de classes do .NET Framework. Diagnostica 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 disponíveis no .NET Framework.

Requisitos

A lista a seguir descreve o hardware, o software, a infraestrutura de rede e os service packs recomendados de 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 de 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 classe para produzir mensagens que ajudam a monitorar a sequência de execução do programa, detectar falhas ou fornecer informações de medição de Debug desempenho. Por padrão, as mensagens que a Debug classe produz aparecem na janela Saída do IDE (Ambiente de Desenvolvimento Integrado) do Visual Studio.

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

Quando você usa o Assert Debug método da classe, a janela Saída exibe uma mensagem somente se uma condição especificada for avaliada como falsa. 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. Asserção do número da instrução. A caixa de diálogo também inclui os três botões de comando a seguir:

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

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

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

Cada Listener na coleção Listener 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 destinos de saída possíveis 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 adicioná-lo ao Debug. Listeners para receber Debug a saída.

Criar um exemplo com a classe Debug

Inicie o Visual Studio ou o Visual C# Express Edition.
Crie um novo projeto de Aplicativo de Console do Visual C# chamado conInfo. Class1 é criado no Visual Studio .NET. Program.cs é criado no Visual Studio 2005.
Adicione o namespace a seguir na parte superior em Class1 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 certificar-se de que a janela Saída esteja visível.
```
Debug.WriteLine("Debug Information-Product Starting ");
```
Para facilitar a leitura, use o método para recuar Indent 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 segundo parâmetro de entrada opcional 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 verdadeira usando o WriteLineIf Debug método da classe. A condição a ser avaliada é o primeiro parâmetro de entrada do WriteLineIf método. O segundo parâmetro de WriteLineIf é a mensagem que aparece somente se a condição no primeiro parâmetro for avaliada como verdadeira.
```
Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear");
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear");
```
Use o método Assert da classe para que a janela Saída exiba a mensagem somente se uma condição especificada for avaliada Debug como falsa:
```
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 Debug Listeners:

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 facilitar a leitura, use o Unindent método para remover o recuo das mensagens subsequentes geradas pela Debug classe. Quando você usa os Indent métodos e os Unindent métodos 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 sua saída, chame o método Flush para os buffers de Debug classe:
```
Debug.Flush();
```

Usando a classe de rastreamento

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

WriteLine
WriteLineIf
Indentar
Sem recuo
Assert
Liberar

Você pode usar as Trace classes e separadamente Debug ou em conjunto no mesmo aplicativo. Em um projeto de Configuração de Solução de Depuração, a saída e a Trace Debug saída estão ativas. O projeto gera saída de ambas as classes para todos os Listener objetos. No entanto, um projeto de Configuração de Solução de Versão gera apenas a saída de uma Trace classe. O projeto de Configuração da Solução de Versão ignora todas as Debug 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();

Verifique se funciona

Verifique se Depurar é a configuração atual da solução.
Se a janela do 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 propriedades 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 listagem suspensa Configuração , clique em Ativo (Depurar) ou Depurar e clique em OK. No Visual C# 2005 e no Visual C# 2005 Express Edition, clique em Ativo (Depurar) ou Depurar na caixa de listagem suspensa Configuração na página Depurar 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 na Asserçã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 semelhante à 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 onde a origem do projeto é armazenada. Por padrão, ela é 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.

Listagem de código 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();
    }
}

Solucionar 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 o recebe a saída do e das Trace Debug classes. Isso ocorre independentemente de você usar o Add Trace método da ou a Debug classe para 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 ou Debug 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);

Compartilhar via