Inicio rápido: navegación del depurador (XAML y C#)

Este tutorial rápido muestra cómo navegar por las sesiones de depuración de Visual Studio. También muestra cómo ver y cambiar el estado del programa en una sesión.

Es para desarrolladores que no han depurado antes con Visual Studio y para aquellos que quieren aprender más sobre cómo navegar por una sesión de depuración de Visual Studio. No enseña cómo depurar. Los métodos del código de ejemplo se han diseñado únicamente para demostrar los procedimientos de depuración descritos en este tema. En ellos no se emplean los procedimientos recomendados para el diseño de aplicaciones o funciones. De hecho, pronto descubrirás que ni los métodos ni la propia aplicación sirven para gran cosa.

Las secciones de este tutorial rápido se diseñaron para ser lo más independientes entre sí que sea posible. Así, puedes omitir cualquier sección cuya información ya conozcas. Tampoco es obligatorio que crees una aplicación de ejemplo. Sin embargo, recomendamos que lo hagas, y te hemos facilitado el proceso lo más posible.

Métodos abreviados de teclado del depurador. La navegación del Depurador de Visual Studio está optimizada para el mouse y el teclado. Muchos de los pasos de este tema incluyen la tecla de aceleración o de método abreviado de teclado en una nota entre paréntesis. Por ejemplo, (teclado: F5) indica que al presionar la tecla F5 se iniciará o continuará la ejecución del depurador.

En este tema

Aprenderás a:

• Create the sample app

• Set and run to a breakpoint, step into a method, and examine program data

• Step into, over, and out of methods

• Set a conditional breakpoint, run to the cursor, and visualize a variable

• Edit and continue, recover from an exception

Crear la aplicación de ejemplo.

La depuración se aplica al código. Por eso, en la aplicación de ejemplo, el marco de aplicaciones de la Tienda Windows se usa solamente para crear un archivo de código fuente en el que puedas ver cómo funciona la navegación por una sesión de depuración y cómo se examina y cambia el estado de un programa. A todo el código que vas a invocar se le llama desde el constructor de la página principal. No se agrega ningún control ni se controla ningún evento.

Crea una aplicación de la Tienda Windows de C# predeterminada. Abre Visual Studio. En la página principal, elige el vínculo de Nuevo proyecto. En el cuadro de diálogo Nuevo proyecto, elige Visual C# en la lista Instalado y haz clic en Tienda Windows. En la lista de plantillas de proyecto, elige Aplicación. Visual Studio crea una solución y un proyecto nuevos. Luego, muestra el diseñador MainPage.xaml y el editor de código XAML.

Abre el archivo de origen MainPage.xaml.cs. Haz clic con el botón secundario en cualquier parte del editor de XAML y elige Ver código. Aparece el archivo de código subyacente MainPage.xaml.cs. Observa que el archivo contiene un solo método, el constructor MainPage().

Reemplaza el constructor MainPage con el código de ejemplo. Elimina el método MainPage(). Sigue este vínculo: Código de ejemplo de navegación del depurador (XAML y C#). Después, copia en el portapapeles el código mostrado en la sección C#. (Elige Atrás en el explorador o en el visor de la ayuda para volver a esta página de tutorial.) En el editor de Visual Studio, pega el código en el bloque partial class MainPage. Presiona CTRL+s para guardar el archivo.

Ahora, puedes seguir los ejemplos de este tema.

Establecer y ejecutar hasta un punto de interrupción, depurar un método paso a paso por instrucciones, y examinar los datos de programa

La manera más común de iniciar una sesión de depuración es elegir Iniciar depuración en el menú Depurar (teclado: F5). La ejecución comienza y continúa hasta que se alcanza un punto de interrupción, se suspende manualmente la ejecución, se produce una excepción o la aplicación finaliza.

Cuando la ejecución se suspende en el depurador, el valor de una variable activa se puede ver en una sugerencia de datos que aparece al mantener el mouse sobre la variable. También puedes abrir las ventanas Variables locales y Automático para ver listas de las variables activas y sus valores actuales. Puedes agregar una o más variables a una ventana Inspección para observar sus valores a medida que la aplicación continúa ejecutándose.

Después de suspender la ejecución de la aplicación (lo que también se llama interrumpir el depurador), tú controlas cómo se ejecuta el resto del código de programa. Puedes continuar línea por línea, pasar de una llamada de método al propio método, o ejecutar en un solo paso un método al que se ha llamado. Se llama a estos procedimientos al recorrer paso a paso la aplicación. También puedes reanudar la ejecución estándar de la aplicación hasta el siguiente punto de interrupción que has establecido, o hasta la línea donde hayas colocado el cursor. Puedes detener la sesión de depuración en cualquier momento. El depurador se ha diseñado para realizar las operaciones de limpieza necesarias y salir de la ejecución.

Ejemplo 1

En este ejemplo, se establece un punto de interrupción en el constructor MainPage del archivo MainPage.xaml.cs, se depura paso a paso el primer método, se consultan los valores de las variables y se detiene la depuración.

Establece un punto de interrupción. Establece un punto de interrupción en la instrucción methodTrack = "Main Page"; del constructor MainPage. Elige la línea en el margen interno sombreado del editor de código fuente (teclado: sitúa el cursor en la línea y presiona la tecla F9).

El icono de punto de interrupción aparece en el margen interno.

Ejecuta hasta el punto de interrupción. Inicia la sesión de depuración. Para ello, elige Iniciar depuración en el menú Depurar (teclado: F5).

La aplicación comienza a ejecutarse y suspende la ejecución inmediatamente antes de la instrucción donde has establecido el punto de interrupción. El icono de la línea actual que aparece en el margen identifica su ubicación. La instrucción actual se resalta.

Ahora, tú tienes el control de la ejecución de la aplicación. Puedes examinar el estado del programa a medida que recorres paso a paso sus instrucciones.

Depura el método paso a paso. En el menú Depurar, elige Paso a paso por instrucciones (teclado: F11).

Observa que el depurador se desplaza a la línea siguiente, que es una llamada al método Example1. Elige otra vez Paso a paso por instrucciones. El depurador se desplaza al punto de entrada del método Example1. Esto indica que el método se ha cargado en la pila de llamadas y que se ha asignado la memoria para las variables locales.

Cuando se depura paso a paso por instrucciones una línea de código, el depurador realiza una de las acciones siguientes:

• Si la instrucción siguiente no es una llamada a una función de la solución, el depurador ejecuta la instrucción, pasa a la instrucción siguiente y, después, suspende la ejecución.

• Si la instrucción es una llamada a una función de tu solución, el depurador va hasta el punto de entrada de la función a la que se llamó y, luego, suspende la ejecución.

Sigue depurando Example1 paso a paso por instrucciones, hasta el punto de salida. El depurador resalta la llave de cierre del método.

Examina los valores de las variables en las sugerencias de datos. Cuando mantienes el mouse sobre un nombre de variable, la sugerencia de datos muestra el nombre, el valor y el tipo de la variable.

Mantén el mouse sobre la variable a. Observa su nombre, valor y tipo de datos. Mantén el mouse sobre la variable methodTrack. También ahora, observa su nombre, valor y tipo de datos.

Examina los valores de las variables en la ventana Variables locales. En el menú Depurar, apunta a Ventanas y elige Variables locales. (Teclado: Alt+4).

La ventana Variables locales es una vista de árbol de los parámetros y las variables de la función. Las propiedades de una variable de objeto son los nodos secundarios del propio objeto. La variable this es un parámetro oculto en cada método de objeto que representa el propio objeto. En este caso, representa la clase MainPage. Dado que methodTrack es miembro de la clase MainPage, su valor y tipo de datos se muestran en una línea por debajo de this. Expande el nodo this para ver la información de methodTrack.

Agrega un observador para la variable methodTrack. La variable methodWatch se utiliza en este tutorial rápido para mostrar los métodos a los que se llama en los ejemplos. Para que sea más fácil ver el valor de la variable, agrégala a una ventana Inspección. Haz clic con el botón secundario en el nombre de variable en la ventana Variables locales y elige Agregar inspección.

Puedes inspeccionar múltiples variables en una ventana Inspección. Los valores de las variables inspeccionadas, igual que los valores de las ventanas Variables locales y de sugerencias de datos, se actualizan cada vez que se suspende la ejecución. También puedes agregar variables a la ventana Inspección desde el editor de código. Selecciona la variable que quieres inspeccionar, haz clic con el botón secundario y elige Agregar inspección.

Depurar un método paso a paso por instrucciones o por procedimientos y hasta salir

Al contrario que la depuración paso a paso por instrucciones de un método al que llamó un método primario, la depuración paso a paso por procedimientos ejecuta el método secundario y, después, suspende la ejecución del método de llamada cuando se reanuda el primario. Puedes depurar paso a paso por procedimientos un método si sabes bien cómo opera y estás seguro de que el problema que investigas no está relacionado con su ejecución.

Cuando se usa la depuración paso a paso por procedimientos en una línea de código que no contiene una llamada a un método, esa línea se ejecuta exactamente igual que con la depuración paso a paso por instrucciones.

Al depurar un método secundario paso a paso hasta salir, continúa su ejecución. Después, se suspende cuando el método vuelve a su método de llamada. Puede ser conveniente depurar una función larga paso a paso hasta salir si sabes con certeza que el resto de la función no es significativo.

La función se ejecuta cuando se depura paso a paso tanto por procedimientos como hasta salir.

Ejemplo 2

En este ejemplo, se depuran métodos paso a paso por instrucciones y por procedimientos, y hasta salir.

Llama al método Example2 del constructor MainPage. Edita el constructor MainPage y reemplaza la línea que aparece después de methodTrack = String.Empty; con Example2();.

Ejecuta hasta el punto de interrupción. Inicia la sesión de depuración. Para ello, elige Iniciar depuración en el menú Depurar (teclado: F5). El depurador suspende la ejecución en el punto de interrupción.

Depura la línea de código paso a paso por procedimientos. En el menú Depurar, elige Paso a paso por procedimientos (teclado: F10). El depurador ejecuta la instrucción methodTrack = "MainPage"; de la misma manera que si se depurase paso a paso por instrucciones.

Depura paso a paso por instrucciones Example2 y Example2_A. Presiona la tecla F11 para depurar paso a paso por instrucciones el método Example2. Sigue depurando las instrucciones de Example2 hasta alcanzar la línea int x = Example2_A();. Una vez más, depura paso a paso por instrucciones esta línea hasta alcanzar el punto de entrada de Example2_A. Sigue depurando paso a paso todas las instrucciones de Example2_A hasta que vuelvas a Example2.

Depura una función paso a paso por procedimientos. Observa que la línea siguiente de Example2, int y = Example2_A();, es básicamente igual que la anterior. Puedes depurarla paso a paso por procedimientos sin ningún problema. Presiona la tecla F10 para pasar de la reanudación de Example2 a esta segunda llamada a Example2_A. Presiona F10 para depurar este método paso a paso por procedimientos. Observa que la cadena methodTrack indica que el método Example2_A se ejecuta dos veces. También notarás que el depurador pasa inmediatamente a la línea siguiente. No suspende la ejecución en el punto donde se reanuda Example2.

Depura una función paso a paso hasta salir. Presiona la tecla F11 para depurar paso a paso por instrucciones el método Example2_B. Observa que Example2_B no es muy diferente de Example2_A. Para salir del método, elige Paso a paso para salir en el menú Depurar (teclado: Mayús+F11). Observa que la variable methodTrack indica que Example2_B se ha ejecutado y que el depurador ha regresado al punto donde se reanuda Example2.

Detén la depuración. En el menú Depurar, elige Detener depuración (teclado: Mayús+F5). Esto finaliza la sesión de depuración.

Establecer un punto de interrupción condicional, ejecutar hasta el cursor y ver una variable

Un punto de interrupción condicional especifica una condición que hace que el depurador suspenda la ejecución. La condición se especifica mediante cualquier expresión de código que se puede evaluar como verdadera o falsa. Por ejemplo, en un método al que se llama a menudo, podrías utilizar un punto de interrupción condicional para que el estado del programa se examinase solamente cuando una variable alcanzase un valor determinado.

Ejecutar hasta el cursor es igual que establecer un punto de interrupción único. Cuando se suspende la ejecución, puedes seleccionar una línea del código fuente y reanudar la ejecución hasta la línea seleccionada. Por ejemplo, mientras recorres paso a paso un bucle de un método, podrías determinar que el código del bucle funciona correctamente. En lugar de recorrer todas las iteraciones del bucle, puedes ejecutar hasta el cursor que está después de la ejecución del bucle.

A veces, es difícil ver el valor de una variable en la fila de una sugerencia de datos o en una ventana de variables. El depurador puede mostrar cadenas, HTML y XML en un visualizador de texto que presenta una vista con formato del valor en una ventana desplazable.

Ejemplo 3

En este ejemplo, se establece un punto de interrupción condicional para interrumpir la ejecución en una iteración concreta de un bucle y, después, ejecutar hasta el cursor situado después del bucle. También se ve el valor de una variable en un visualizador de texto.

Llama al método Example3 del constructor MainPage. Edita el constructor MainPage y reemplaza la línea que aparece después de methodTrack = String.Empty; con la línea Example3();.

Ejecuta hasta el punto de interrupción. Inicia la sesión de depuración. Para ello, elige Iniciar depuración en el menú Depurar (teclado: F5). El depurador suspende la ejecución en el punto de interrupción del método MainPage.

Depura paso a paso por instrucciones el método Example3. Elige Paso a paso por instrucciones en el menú Depurar (teclado: F11) hasta alcanzar el punto de entrada del método Example3. Sigue depurando el método paso a paso por instrucciones hasta que hayas recorrido en iteración uno o dos bucles del bloque for. Date cuenta de que tardarías mucho en recorrer paso a paso las 1000 iteraciones.

Establece un puntos de interrupción condicional. En el margen interno izquierdo de la ventana de código, haz clic con el botón secundario en la línea x += i; y elige Condición. Activa la casilla Condición y escribe i == 500; en el cuadro de texto. Elige la opción Es True y elige Aceptar. El punto de interrupción permite comprobar el valor de la 500ª iteración del bucle for.

El aspa blanca te permite distinguir el icono de un punto de interrupción condicional.

Ejecuta hasta el punto de interrupción. En el menú Depurar, elige Continuar (teclado: F5). En la ventana Variables locales, confirma que el valor actual de i es 500. Observa que la variable s está representada como una sola línea y es mucho más larga que la ventana.

Muestra una variable de cadena. Haz clic en el icono de lupa en la columna de Valor de s.

Aparece la ventana del visualizador de texto. El valor de la cadena se muestra como una cadena de varias líneas.

Ejecuta hasta el cursor. Haz clic con el botón secundario en la línea methodTrack += "->Example3"; y elige Ejecutar hasta el cursor (teclado: lleva el cursor a la línea; Ctrl+F10). El depurador completa las iteraciones del bucle y, después, suspende la ejecución en la línea.

Detén la depuración. En el menú Depurar, elige Detener depuración (teclado: Mayús+F5). Esto finaliza la sesión de depuración.

Editar y continuar, recuperarse de una excepción

En algunas circunstancias, cuando se interrumpe el código del Depurador de Visual Studio, tienes la oportunidad de cambiar el valor de las variables e incluso la lógica de las instrucciones. Esta funcionalidad se denomina editar y continuar.

Editar y continuar puede resultar especialmente útil cuando se interrumpe en una excepción. En lugar de tener que detener y reiniciar la depuración de un procedimiento largo e intrincado para evitar la excepción, puedes "rebobinar" la excepción para desplazar la ejecución hasta el punto inmediatamente anterior al lugar donde se produjo la excepción y, después, cambiar la variable o la instrucción que genera el error y continuar con la sesión de depuración actual en un estado que ya no produzca una excepción.

Aunque puedes usar editar y continuar en escenarios muy variados, resulta complicado especificar las condiciones concretas que no admiten esta funcionalidad, porque dependen del lenguaje de programación, del estado actual de la pila de programas, y de la capacidad de cambiar el estado sin dañar el proceso. La mejor manera de determinar si se admite un cambio de edición es intentarlo, sin más. El depurador te hará saber inmediatamente si el cambio no se admite.

Ejemplo 4

En este ejemplo, ejecutarás el depurador hasta una excepción, rebobinarás la excepción, corregirás la lógica del método y, después, cambiarás el valor de una variable para poder seguir ejecutando el método.

Llama al método Example4 del constructor MainPage. Edita el constructor MainPage() y reemplaza la línea que aparece después de methodTrack = String.Empty; con la línea Example4();.

Ejecuta hasta la excepción. Inicia la sesión de depuración. Para ello, elige Iniciar depuración en el menú Depurar (teclado: F5). Presiona F5 otra vez para reanudar la ejecución. El depurador suspende la ejecución en la excepción del método Example4 y muestra un cuadro de diálogo de excepción.

Cambia la lógica del programa. Es evidente que el error está en la condición if: el valor de x deberá cambiarse cuando x sea igual a 0; no cuando x sea distinto de cero. Elige Interrumpir para corregir la lógica del método. Cuando intentes editar la línea, aparecerá otro cuadro de diálogo.

Elige Editar y cambia la línea if (x != 0) por if (x == 0). El depurador conserva en el archivo de origen los cambios que se hacen en la lógica del programa.

Cambia el valor de la variable. Examina el valor de x en una sugerencia de datos o en la ventana Variables locales. Sigue siendo 0 (cero). Si intentas ejecutar la instrucción que produjo la excepción original, lo único que conseguirás es que se produzca otra vez. Puedes cambiar el valor de x. En la ventana Variables locales, haz doble clic en la columna Valor de la fila x. Cambia el valor 0 por 1.

Presiona la tecla F11 para depurar paso a paso la instrucción que antes produjo una excepción. Observa que la línea se ejecuta sin errores. Presiona F11 otra vez.

Detén la depuración. En el menú Depurar, elige Detener depuración (teclado: Mayús+F5). Esto finaliza la sesión de depuración.

Vea también

Conceptos

Iniciar una sesión de depuración (Visual C++, Visual C# y Visual Basic)

Desencadenar eventos de suspensión, reanudación y en segundo plano en aplicaciones de la Tienda Windows

Depurar aplicaciones de la Tienda Windows