- Visual Basic.NET- Herramientas de desarrollo .NET - Depuración de errores (debugging) -

En la programación, resulta de gran importancia la depuración de errores.
.NET permite, en forma muy confortable, probar paso a paso el código fuerte en el depurador de errores.
- el proceso de depuración es activado automáticamente, en cuanto el CLR (Common Language Runtime) detecte un error
- para esto, se activarán las instrucciones "stop" incorporadas en el código fuerte. Estas instrucciones se activarán al ejecutarse la sentencia donde se encuentre.
- en Visual Studio puede activarse la ejecución paso a paso del código fuerte al activarse el comando "Debugging" en el menú.
El siguiente ejemplo muestra como preparar el código fuerte para el debugging con la introducción de instrucciones "stop":

'************
'debug.vb
'************
Module test
Sub Main()
Stop 'iniciar el debugging
Microsoft.VisualBasic.MsgBox ("Ha funcionado!")
End Sub
End Module

Al traducir este archivo en un ejecutable, el compilador agrega una llamada al depurador de errores. Para poder visualizar el código en el depurador, tiene que traducirse la aplicación con la opción "/debug". El compilador de Visual Basic genera así un archivo ".pdb", el cual contiene informaciones adicionales (entre otras, la ubicación del código fuerte).
Los archivos traducidos con la opción "/debug", generan un archivo para base de datos ".pdb", el cual contiene paths absolutos para referenciar los códigos fuerte, por lo que no debe variarse el ambiente en que se generó.
Dado el caso que el sistema disponga .NET Framework SDK, contará con el depurador de línea de comandos "cordbg.exe", el cual encontrará (dependiendo de la versión con que cuente) normalmente en "C:\Programme\Microsoft.NET\SDK\v2.0\Bin".
Tenga en cuenta que para llamar el depurador, deberá establecer esta dirección en el path de la variable de entorno. De lo contrario, al llamarlo, recibirá un mensaje de error.
Abra la línea de comandos y ubíquese en la carpeta donde guardó el archivo a depurar y teclee

cordbg debug.exe

El resultado será la ventana que se muestra a continuación:



A partir de aquí, podrá realizar el debugging (depuración). Tecleando un signo de interrogación ( ? ) o "Help" obtendrá una ayuda (descripción del comando).
- El comando "s" hace que el debugger avance un paso adelante. Esto se refiere a pasos en las instrucciones MSIL del programa traducido. De encontrarse el código fuerte en la misma carpeta que el ejecutable (".exe"), el depurador devolverá las instrucciones del código fuerte.
- con el comando "go", el depurador ejecutará el programa sin interrupciones.
- Con el comando "exit" se concluirá el depurador.
De haber instalado .NET Framework SDK o Visual Studio .NET, contará con otro depurador de errores de superficie grafica en su sistema, el "Microsoft CLR-Debugger".
Al iniciar la aplicación que contiene el comando "stop" o al producirse un error en la ejecución, se iniciará el depurador.
De hecer uso a menudo del debuger, vale la pena crear un enlace directo con este desde el desktop.
Una vez iniciado el Microsoft CLR Debugger, escoja, en el menú, "Depurar / Programa a depurar", con lo que se habrirá una ventana de dialogo, en la cual podrá consignar el programa a depurar y los argumentos que sean necesarios.
Cierre la ventana de dialogo presionando el botón "Aceptar".
Hecho esto, el menú "Depurar" aparecerá con nuevos comandos.
Abra el menú "Depurar" y escoja el comando "Iniciar".
El depurador ejecutará el código hasta encontrar la instrucción "stop". A partir de aquí se interrumpirá la ejecución y el depurador asumirá el control de la aplicación.
Los comandos para depurar un programa los encontrará en el menú "Depurar". Entre ellos encontrará:
- Iniciar
- paso a paso por instrucciones
- paso a paso por procedimientos
- iniciar sin depurador
El siguiente ejemplo le servirá para probar el depurador:

'************
'Formula.vb (Versión para depurar)
'************
Option Strict
Imports System.Drawing
Imports System.Windows.Forms
' Para Debugger
Imports System.Diagnostics
 
Module Formular
Sub Main()
Stop
'crear formulario
Dim oForm As New frmHaupt()
'variables auxiliares
Dim i,j,k As Integer
'primer nombre del formulario
Dim Titel As String
 
'grabar el nombre del formulario
Titel = oForm.Text
'bucle para probar
For i = 1 To 3
'demora del bucle
For j = 1 To 6000
k = i * j
Next j
'número en el titulo
oForm.Text = Titel & " - " & i.ToString
'mostrar el formulario
oForm.ShowDialog ()
Next i
'número en el titulo
oForm.Text = Titel & " - Valor final - " & i.ToString
' .. y mostrar
Application.Run (oForm)
'Debug.Write ("Final de la prueba i = " & i.ToString)
MessageBox.Show ("Fin", "prueba del depurador")
End Sub
 
Public Class frmHaupt
'Aquí el código para la clase para crear el formulario
Inherits System.Windows.Forms.Form
'nuevo constructor para crear
Sub New()
MyBase.New()
Me.Text = "Formulario primitivo"
Me.Width = 300
Me.Height = 200
Me.Left = 200
Me.Top = 300
End Sub
End Class
End Module

El contenido del código es por el momento irrelevante. Debe servir solo al objetivo de probar el depurador.
Los programas guardan valores internamente, en variables. Estos valores se modifican durante el transcurso del programa. Para el programador, resulta una ayuda conocer el valor de una variable durante el desenvolvimiento de la aplicación. Es posible mostrar el valor de las variables en ventanas de dialogo. Más censillo resulta solicitar estos valores. Para esto siga los siguientes pasos:
- Abierto el depurador, inicie el programa. Su ejecución se interrumpirá al llegar a la sentencia con la instrucción "stop".
- Ponga dos "nuevos puntos de interrupción" en las filas 29 y 34 (simplemente haga clic en el borde de la línea), para interrumpir la ejecución del programa en esos puntos. Señale con el cursor los puntos de interrupción y recibirá una pequeña información sobre la misma.
- Pulse la tecla de función "F10" para ejecutar las instrucciones en modo "paso a paso por los procedimientos".
- Pulse la tecla de función "F11" para ejecutar las instrucciones en modo "paso a paso por las instrucciones" hasta llegar a la línea 23 "For i = …". Señale con el cursor sobre la variable " i " y a continuación sobre la variable "Titel". Al señalar con el cursor sobre una variable recibirá información sobre su valor. De no haberse ejecutado la instrucción, el valor de la variable se corresponderá con el de su inicialización "Nothing" ,"0" , etc. La visualización de valores numéricos puede expresarse en números decimales o hexadecimales. Para variar la expresión entre uno y otro, pulse el botón "Hex" en el menú del depurador.
- Pulse la tecla de función "F5" para continuar. Así se ejecutará el programa hasta llegar a la línea 29, donde se encuentra el primer punto de interrupción. Al señalar con el cursor la variable "j", comprobará que tiene el valor 5001, lo que indica que el bucle circuló 5000 veces.
- Pulse la tecla de función "F5" para continuar. El depurador ejecutará la sentencia "ShowDialog", mostrando el formulario. Mientra el formulario sea visible, el programa esperará la reacción del usuario.
- Cierre la ventana de dialogo, para que el programa continúe su ejecución hasta llegar al próximo punto de interrupción en la línea 34. Repita el paso anterior hasta que se hayan mostrado tres ventanas y el programa se ejecutará hasta el final.
En el caso de interrumpir la ejecución del programa se podrá comprobar el valor de las variables o sus propiedades, señalándolas con el cursor, lo que mostrará una pequeña información al respecto. Los puntos de interrupción le permitirán detener el programa en la sentencia predeterminada.
Los puntos de interrupción pueden ser sometidos a condiciones. Dado el caso en que se conveníen condicionantes a un punto de interrupción, el depurador comprobará estas al llegar la ejecución a ese lugar.
Para demostrar esto, tomemos el código ejemplo nuevamente, en el primer punto de interrupción.
Pongamos como condición que el index del bucle "i" sea mayor que 2.
Para realizar esto, haga lo siguiente:
- establezca los puntos de interrupción (haciendo un clic a la izquierda de la sentencia)
- abra el menú con las opciones de punto de interrupción (a través del botón de la ventana del depurador o a través del menú Depurador / Ventana)
- el depurador mostrará una ventana con los puntos de interrupción. Marque el punto de interrupción que desea manipular y pulse el botón derecho del ratón. Se abrirá un menú contextual donde podrá escoger "Condiciones …"
- consigne la condición de interrupción deseada y acepte con "OK"
Hecho esto podrá ejecutar el programa en el depurador con la función "Continuar".
El programa se detendrá en el punto de interrupción y podrá comprobar el valor de las variables o modificar el modo en que deberá continuar la ejecución.

Otorgarle valor a una variable y seguir su desenvolvimiento
Para otorgarle un valor a una variable abra la Ventana "Inmediato" (menú "Depurador / Ventana / Inmediato" o la combinación de teclas "Ctrl– Alt – I") y teclee la instrucción correspondiente para concederle un valor a la variable.
Para mostrar el valor de una variable (por ejemplo "Titel"), establezca dos puntos de interrupción en las sentencias correspondientes a las líneas 29 y 34.
Inicie la ejecución del programa en el depurador.
Al detenerse la ejecución en la línea 29, teclee en la ventana "Inmediato"

?Titel

y pulse Enter.
En la línea inmediata inferior aparecerá el valor de la variable, en este caso "Formulario Primitivo".
Al procesar programas extensos, resulta ventajoso observar los valores que adoptan determinadas expresiones o variables y relacionarlos en forma clara y precisa en una ventana. El depurador ofrece esta posibilidad.
Para observar los valores que van tomando determinada variable, haga lo siguiente:
- busque el comando "Observación rápida" (menú "Depurador / Observación rápida" o pulse la combinación de teclas "Ctrl + Alt + Q")
- teclee en el espacio "Expresión" el nombre de la variable que desea observar, digamos "Titel". A continuación presione el botón "nueva vigilancia". La ventana mostrará el valor actual de la variable en el espacio "Valor". Cierre la ventana de dialogo.
Durante la ejecución del programa, el depurador mostrará el valor que la variable irá adoptando. Además, esta ventana muestra el tipo de la variable. Al modificarse el valor, se mostrará el texto en rojo.
Puede definir hasta cuatro ventanas de observación.
En el caso de que el programa contenga procedimientos o funciones, es posible llamarlas. El depurador lleva internamente una lista, la cual puede ser mostrada. Para esto abra la ventana "Lista de llamadas" sobre el menú "Depurador / Ventanas / Lista de llamadas" con la combinación de teclas "Ctrl + Alt + C".
Esta lista refleja la jerarquía del proyecto. Cada registro consta del nombre del archivo que contiene el programa y el procedimiento llamado.
previo
Imprimir!
Ultima actualisación: Tue, 24 ▪ May ▪ 2011
próximo