Uso de las clases Trace y Debug en Visual Basic .NET

Artículo
04/27/2022
Tiempo de lectura: 9 minutos

En este artículo se proporciona información sobre cómo usar las Debug clases y Trace en Visual Basic .NET.

Versión original del producto: Visual Basic .NET
Número de KB original: 313417

Resumen

En este artículo se muestra cómo usar las Debug clases y Trace . Estas clases están disponibles en microsoft .NET Framework. Puede usar estas clases para proporcionar información sobre el rendimiento de una aplicación durante el desarrollo de aplicaciones o después de la implementación en producción. Estas clases son solo una parte de las características de instrumentación que están disponibles en el .NET Framework.

Requisitos

En la lista siguiente se describen el hardware, el software, la infraestructura de red y los Service Pack recomendados que necesita:

Windows
Visual Basic .NET

En este artículo también se supone que está familiarizado con la depuración de programas.

Descripción de la técnica

Los pasos de la sección Crear un ejemplo con la clase Debug muestran cómo crear una aplicación de consola que usa la Debug clase para proporcionar información sobre la ejecución del programa.

Cuando se ejecuta el programa, puede usar métodos de la Debug clase para generar mensajes que ayuden a supervisar, detectar mal funcionamiento o proporcionar información de medición del rendimiento. De forma predeterminada, los mensajes que genera la Debug clase aparecen en la ventana Salida de la Microsoft Visual Studio Entorno de desarrollo integrado (IDE).

El código de ejemplo usa el WriteLine método para generar un mensaje seguido de un terminador de línea. Cuando se usa este método para generar un mensaje, cada mensaje aparece en una línea independiente en la ventana Salida.

Si usa el Assert método de la Debug clase , la ventana Salida muestra un mensaje solo si una condición especificada se evalúa como false. El mensaje también aparece en un cuadro de diálogo modal para el usuario. El cuadro de diálogo incluye el mensaje, el nombre del proyecto y el número de Debug.Assert instrucción. El cuadro de diálogo también incluye tres botones de comando:

Anular: la aplicación deja de ejecutarse.
Reintento: la aplicación entra en modo de depuración.
Omitir: la aplicación continúa. El usuario debe hacer clic en uno de estos botones para que la aplicación pueda continuar.

También puede dirigir la salida de la Debug clase a destinos distintos de la ventana Salida. La Debug clase tiene una colección denominada Listeners que incluye objetos Listener. Cada objeto Listener supervisa Debug la salida y dirige la salida a un destino especificado. Cada agente de escucha de la Listeners colección recibe cualquier salida que genere la Debug clase . Use la TextWriterTraceListener clase para definir objetos Listener. Puede especificar el destino de una TextWriterTraceListener clase a través de su constructor. Algunos posibles destinos de salida incluyen:

La ventana Consola mediante la System.Console.Out propiedad .
Un archivo de texto mediante la System.IO.File.CreateText("FileName.txt")) instrucción .

Después de crear un TextWriterTraceListener objeto, debe agregar el objeto a la Debug.Listeners colección para recibir Debug la salida.

Creación de un ejemplo con la clase Debug

Use Visual Basic .NET para crear un nuevo proyecto de aplicación de consola denominado conInfo. De forma predeterminada, se agrega un módulo público denominado Module1 al proyecto.
Para inicializar variables que contengan información sobre un producto, agregue las siguientes Dim instrucciones:
```
Dim sProdName As String = "Widget"
Dim iUnitQty As Integer = 100
Dim dUnitCost As Decimal = 1.03
```
Especifique el mensaje que la clase genera como primer parámetro de entrada del WriteLine método. Presione la combinación de teclas CTRL+ALT+O para asegurarse de que la ventana Salida está visible.
```
Debug.WriteLine("Debug Information-Product Starting ")
```
Para mejorar la legibilidad, use el Indent método para aplicar sangría a los mensajes posteriores en la ventana Salida:
```
Debug.Indent()
```

Para mostrar el contenido de las variables seleccionadas, use el método de la WriteLine siguiente manera:

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

También puede usar el WriteLine método para mostrar el espacio de nombres y el nombre de clase de un objeto existente. Por ejemplo, el código siguiente muestra el System.Xml.XmlDocument espacio de nombres en la ventana Salida:
```
Dim oxml As New System.Xml.XmlDocument()
Debug.WriteLine(oxml)
```
Para organizar la salida, puede incluir una categoría como un segundo parámetro de entrada opcional del WriteLine método. Si especifica una categoría, el formato del mensaje de la ventana Salida es "categoría: mensaje". Por ejemplo, la primera línea del código siguiente muestra "Campo: El nombre del producto es Widget" en la ventana Salida:
```
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")
```
La ventana Salida solo puede mostrar mensajes si una condición designada se evalúa como true mediante el WriteLineIf método de la Debug clase . La condición que se va a evaluar es el primer parámetro de entrada del WriteLineIf método. El segundo parámetro de WriteLineIf es el mensaje que aparece solo si la condición del primer parámetro se evalúa como true.
```
Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear")
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear")
```
Use el método Assert de la Debug clase para que la ventana Salida muestre el mensaje solo si una condición especificada se evalúa como false:
```
Debug.Assert(dUnitCost > 1, "Message will NOT appear")
Debug.Assert(dUnitCost < 1, "Message will appear")
```

Cree los TextWriterTraceListener objetos para la ventana Consola (tr1) y para un archivo de texto denominado Output.txt (tr2) y, a continuación, agregue cada objeto a la Debug Listeners colección:

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 mejorar la legibilidad, use el Unindent método para quitar la sangría de los mensajes posteriores que genera la Debug clase . Cuando se usan los Indent métodos y Unindent juntos, el lector puede distinguir la salida como grupo.
```
Debug.Unindent()
Debug.WriteLine("Debug Information-Product Ending")
```
Para asegurarse de que cada objeto Listener recibe toda su salida, llame al Flush método para los Debug búferes de clase:
```
Debug.Flush()
```

Uso de la clase Trace

También puede usar la Trace clase para generar mensajes que supervisen la ejecución de una aplicación. Las Trace clases y Debug comparten la mayoría de los mismos métodos para generar resultados, entre los que se incluyen:

WriteLine
WriteLineIf
Indent
Unindent
Assert
Flush

Puede usar las Trace clases y Debug por separado o juntas en la misma aplicación. En un proyecto de configuración de la solución de depuración, tanto como Trace Debug la salida están activas. El proyecto genera la salida de ambas clases a todos los objetos Listener. Sin embargo, un proyecto de configuración de solución de versión solo genera la salida de una Trace clase. El proyecto Release Solution Configuration omite cualquier Debug invocación de método de clase.

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

Comprobar que funciona

Asegúrese de que Debug es la configuración actual de la solución.
Si la ventana Explorador de soluciones no está visible, presione la combinación de teclas CTRL+ALT+L para mostrar esta ventana.
Haga clic con el botón derecho en conInfoy, a continuación, haga clic en Propiedades.
En el panel izquierdo de la página de propiedades conInfo , en la carpeta Configuración , asegúrese de que la flecha apunta a Depuración.
Encima de la carpeta Configuración , en el cuadro de lista desplegable Configuración, haga clic en Activo (Depurar) o Depurary, a continuación, haga clic en Aceptar.
Presione CTRL+ALT+O para mostrar la ventana Salida.
Presione la tecla F5 para ejecutar el código. Cuando aparezca el cuadro de diálogo Error de aserción, haga clic en Omitir.

En la ventana Consola, presione ENTRAR. El programa debe finalizar y la ventana Salida debe mostrar la siguiente salida:

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

La ventana Consola y el archivo Output.txt deben mostrar la siguiente salida:

(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

Solución de problemas

Si el tipo de configuración de la solución es Release, se omite la salida de la Debug clase.
Después de crear una TextWriterTraceListener clase para un destino determinado, TextWriterTraceListener recibe la salida de las Trace clases y Debug . Esto ocurre independientemente de si se usa el Add método de o Trace la Debug clase para agregar TextWriterTraceListener a la Listeners clase .
Si agrega un objeto Listener para el mismo destino en las Trace Debug clases y , cada línea de salida se duplica, independientemente de si Debug genera o Trace genera la salida.
```
Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)
Dim tr2 As New TextWriterTraceListener(System.Console.Out)
Trace.Listeners.Add(tr2)
```