Usar classes de rastreamento e depuração no Visual Basic .NET

Artigo
03/20/2024

Este artigo fornece informações sobre como usar as Debug classes e Trace no Visual Basic .NET.

Versão original do produto: Visual Basic .NET
Número de KB original: 313417

Resumo

Este artigo demonstra como usar as Debug classes e Trace . Essas classes estão disponíveis no microsoft .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:

Windows
Visual Basic .NET

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 for executado, você pode usar métodos da Debug classe para produzir mensagens que ajudam a monitorar, 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 Microsoft 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.

Se você usar o Assert método da Debug classe, a janela Saída exibirá 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 número da Debug.Assert instrução. A caixa de diálogo também inclui três botões de comando:

Abortar: o aplicativo para de ser executado.
Repetição: o aplicativo insere o modo de depuração.
Ignore: 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 saída da Debug classe para destinos diferentes da janela Saída. A Debug classe tem uma coleção chamada Listeners que inclui objetos Listener. Cada objeto Listener monitora Debug a saída e direciona a saída para um destino especificado. Cada ouvinte da Listeners coleção recebe qualquer saída gerada pela Debug classe. Use a TextWriterTraceListener classe para definir objetos Listener. Você pode especificar o destino de uma TextWriterTraceListener classe por meio de seu construtor. Alguns possíveis destinos de saída incluem:

A janela Console usando a System.Console.Out propriedade.
Um arquivo de texto usando a System.IO.File.CreateText("FileName.txt")) instrução.

Depois de criar um TextWriterTraceListener objeto, você deve adicionar o objeto à Debug.Listeners coleção para receber Debug a saída.

Criar um exemplo com a classe Depuração

Use o Visual Basic .NET para criar um novo projeto de Aplicativo de Console chamado conInfo. Um módulo público nomeado Module1 é adicionado ao projeto por padrão.
Para inicializar variáveis para conter informações sobre um produto, adicione as seguintes Dim instruções:
```
Dim sProdName As String = "Widget"
Dim iUnitQty As Integer = 100
Dim dUnitCost As Decimal = 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 garantir que a janela Saída esteja 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)
Debug.WriteLine("The per unit cost is " & dUnitCost)

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:
```
Dim oxml As 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, "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")
```

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

Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)

Dim tr2 As 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 objeto Listener receba toda a sua saída, chame o Flush método 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:

WriteLine
WriteLineIf
Indent
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 objetos Listener. 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.
Acima da pasta Configuração , na caixa de lista suspensa Configuração, clique em Ativo (Depuração) ou Depuração e clique em OK.
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 seguinte saída:

Debug Information-Product Starting
    The product name is Widget
    The available units on hand are 100
    The per unit cost is 1.03
    System.Xml.XmlDocument
    Field: The product name is Widget
    Field: The units on hand are 100
    Field: The per unit cost is 1.03
    Calc: Total cost is 103
    This message WILL appear
    ---- DEBUG ASSERTION FAILED ----
---- Assert Short Message ----
Message will appear
---- Assert Long Message ----

at Module1.Main() C:\Documents and Settings\Administrator\My
Documents\Visual Studio Projects\conInfo\Module1.vb(29)

    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

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

(The Output.txt file is located in the same directory as the conInfo
executable, conInfo.exe. Normally this is the \bin folder of where the
project source has been stored. By default that would be C:\Documents and
Settings\User login\My Documents\Visual Studio Projects\conInfo\bin)
    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

Lista de código completa

Module Module1
    Sub Main()
        Dim sProdName As String = "Widget"
        Dim iUnitQty As Integer = 100
        Dim dUnitCost As Decimal = 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)
        Debug.WriteLine("The per unit cost is " & dUnitCost)

        Dim oxml As 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, "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")

        Dim tr1 As New TextWriter`Trace`Listener(System.Console.Out)
        Debug.Listeners.Add(tr1)

        Dim tr2 As 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()
    End Sub
End Module

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 objeto Listener 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.
```
Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)
Dim tr2 As New TextWriterTraceListener(System.Console.Out)
Trace.Listeners.Add(tr2)
```