Depuración de una aplicación con Visual C# Express

Conceptos del lenguaje Visual C#

Cómo depurar una aplicación con Visual C# Express

Esta página ha sido extraída de los archivos de ayuda locales instalados con Visual C# Express y como tal es documentación preliminar que está sujeta a cambios en futuras versiones.

El propósito de este tema es familiarizarnos con los aspectos básicos de uso del depurador de Visual C# Express, y aprenderemos mediante la práctica. No buscaremos un error real concreto, sino que utilizaremos el depurador para obtener información sobre la aplicación del Kit de Bienvenida de Visual C# (Salvapantallas).

Procedimiento

Para empezar a depurar el Kit de Bienvenida de Visual C#, haremos lo siguiente:

Iniciar Visual C# Express.
En el menú File, hacer clic en New, y a continuación hacer clic en Project.
Aparecerá el cuadro de diálogo New Project.
Seleccionar el tipo de aplicación ScreenSaver, y hacer clic en OK.
Se carga el Kit de Bienvenida en Visual C# Express.
En el menú Debug, hacer clic en Step Into.
Este comando provoca que Visual C# Express construya y ejecute el Kit de Bienvenida. Sin embargo, en lugar de ejecutarse normalmente, el código del Kit de Bienvenida se detiene en la primera línea de código.
Esto es lo que hace Step Into: nos permite desplazarnos por el código línea a línea, a diferencia de ejecutar el código normalmente. Cuando se pausa la ejecución de nuestro código, se encuentra en un "estado de interrupción". El comando se denomina Step Into porque si la próxima sentencia es una llamada a función, el depurador saltará hacia ella.
Observemos la línea de código resaltada en la ventana de código fuente Program.cs. En el margen izquierdo, podemos ver una flecha amarilla. Esto nos muestra la próxima sentencia que se ejecutará, también denominada punto de ejecución.
Ahora, observemos la ventana Locals. Si no está visible, podemos abrirla abriendo el menú Debug, haciendo clic en Windows, y seleccionando Locals.
La ventana Locals muestra las variables locales para la función actual. Vemos que hay una entrada en la lista: arg. Observemos cómo la ventana Locals nos muestra el valor y el tipo de la variable.
En la parte inferior de la ventana Locals hay una ficha denominada Watch. Hacer clic sobre ella.
La ventana Locals se remplaza con la ventana Watch. Observar que la ventana Watch no tiene ninguna entrada. Mientras que el depurador rellena la ventana Locals automáticamente, la ventana Watch es un lugar dónde podemos añadir nuestras propias entradas: cosas que queremos examinar.
Hacer clic en la primera fila bajo el encabezado Name, y escribir:
```
args.
```

Tras escribir el punto, aparece una lista que contiene todos los miembros de args.

Hacer clic en el miembro Length y aparecerá una descripción de args.Length.
Hacer doble clic en Length.
La lista desaparece, y ahora args.Length aparece en la columna Name.
Presionar Entrar.
Acabamos de añadir args.Length a la ventana Watch. Observemos que podemos visualizar el valor y el tipo en este punto.
Hacer clic en la siguiente fila de la columna Name y añadir args.IsReadOnly a la ventana Watch.
Desplazarse una fila hacia abajo en la columna Name y hacer clic de nuevo. Esta vez, escribir args.Length+20, y presionar Enter.
Como podemos ver, Name puede contener expresiones, así como nombres de variables. El depurador evalúa la expresión y escribe el resultado en la columna Value.
Ahora, podemos mover el puntero del ratón hacia atrás hasta la ventana de código fuente Program.cs. Ubicar el cursor del ratón directamente sobre args.Length en la línea resaltada, y mantenerla allí durante un instante.
Casi inmediatamente, veremos un pequeño cuadro que muestra el nombre y el valor de la variable. Este cuadro se denomina sugerencia de datos, o DataTip. Los DataTips son un modo rápido y fácil de obtener información sobre nuestro código. Utilizar un DataTip es más rápido que añadir una entrada a la ventana Watch, pero la ventana Watch nos permite mantener una lista de variables y expresiones a la que nos podemos referir más adelante.
En el menú Debug, hacer clic en Step Into de nuevo, o presionar la techa F11.
Observar que la siguiente sentencia ha cambiado. Como args.Length es igual a cero, la prueba if ha fallado y la ejecución prosigue hacia abajo hasta la cláusula else.
Evaluar los pasos siguientes para averiguar qué habría pasado si la prueba (args.Length > 0) hubiese funcionado.
Desplazarse hacia arriba hasta encontrar la primera línea de código tras
```
if (args.Length > 0)
```
Su aspecto es similar al siguiente:
```
string arg = args [0].ToLower(CultureInfo.InvariantCulture).Trim
```
Hacer clic con el botón secundario sobre esa línea de código y hacer clic en Set Next Statement que aparece en el menú contextual.
Observar que la sentencia sobre la que hemos hecho clic se ha convertido en la próxima sentencia.
Hacer clic en Step Into, o presionar F11 una vez más.
Algo no está bien. Aparece un cuadro de diálogo, indicándonos que hemos obtenido una excepción IndexOutOfRange.
Este cuadro se denomina Asistente de Excepciones. Observemos la información que nos muestra. Nos indica que la excepción se ha producido porque un índice estaba fuera de los límites de la matriz y no se ha capturado la excepción; dicho de otro modo, que no ha sido capturada y corregida por un procesador de excepciones. También nos proporciona una lista de sugerencias de diagnóstico, que son temas de ayuda a los que podemos acudir para obtener más información sobre la excepción.
Esto ha sido diseñado así por dos razones. La primera es para mostrarnos el Asistente de Excepciones . La segunda es para mostrarnos que el comando Set Next Statement es muy potente como herramienta para la depuración, pero debería ser utilizada cuidadosamente. Necesitamos entender nuestro código para saber dónde podemos utilizar Set Next Statement con seguridad.
Ahora podemos arreglar este desorden, siguiendo los próximos pasos.
Hacer clic en la casilla de cierre para eliminar el Asistente de Excepciones.
Desplazarse de nuevo hacia abajo hasta la cláusula else, hacer clic con el botón secundario en la llamada a ShowScreenSaver, y hacer clic en Set Next Statement.
La llamada a ShowScreenSaver se resalta de nuevo como la siguiente sentencia.
Hacer clic en Step Into, o presionar F11.
La siguiente sentencia cambia de nuevo. Hemos pasado de Main a la función static void ShowScreenSaver.
Observar la ventana Watch. Las variables y la expresión que introdujimos están en gris y aparece un signo de exclamación. Las marcas en gris y la exclamación indican que uno de los valores que queremos examinar está desactualizado. En este caso, se debe a que hemos introducido una nueva función y las variables están fuera del rango.
Observar la siguiente línea de código, que crea un nuevo objeto ScreenSaverForm.
```
ScreenSaverFrom screenSaver = new ScreenSaverForm();
```
Seleccionar Step Into, o presionar F11.
Nos encontramos ahora en el constructor de ScreenSaverForm.
No queremos depurar este constructor, por lo que salimos de aquí.
Desde el menú Debug, hacer clic en Step Out.
Nos encontramos de nuevo en la función ShowScreenSaver.
Podíamos haber evitado acceder a la llamada seleccionando Step Over en lugar de Step Into. El comando Step Over debería haber accedido dentro de la llamada, a continuación detenerse (ejecución interrumpida) tras la llamada en lugar de acceder dentro de ella.
Como podemos ver, nos hemos detenido varias veces. No es necesario depurar un largo programa línea por línea. Utilizaremos otra característica más del depurador: los puntos de interrupción.
Hacer clic con el botón secundario sobre la siguiente línea de código.
Desde el menú de acceso directo, seleccionar Breakpoint y hacer clic en Insert Breakpoint.
Aparece al margen un punto rojo que representa un glifo de punto de interrupción. Si hiciésemos clic con el botón secundario en el glifo del punto de interrupción, podríamos eliminar o deshabilitarlo. Sin embargo, no lo haremos.
En el menú Debug, hacer clic en Stop Debugging.
De esta forma, finalizará la sesión de depuración. A continuación, empezaremos una nueva.
En el menú Debug, hacer clic en Start.
Observar cómo la aplicación se inicia y se ejecuta hasta llegar al punto de interrupción que hemos establecido. Los puntos de interrupción son a la depuración lo que los marcadores son a la lectura. Podemos establecer un punto de interrupción en el lugar de nuestra aplicación que queramos interrumpir. Podemos establecer tantos puntos de interrupción como queramos.
Ahora, examinemos la ventana Call Stack. Si no está visible, en el menú Debug, hacer clic en Call Stack para visualizarla.
Podemos ver un glifo de punto de interrupción y un puntero de ejecución amarillo en la ventana Call Stack así como la ventana de código fuente. La ventana Call Stack es una herramienta útil cuando queremos examinar las llamadas que nuestro código ha realizado y averiguar cómo hemos llegado a la ubicación actual.
En el menú Debug, hacer clic en Continue.
Se ejecuta el salvapantallas. Seleccionar Continue durante una sesión de depuración es similar a seleccionar Start para empezar una sesión de depuración.
El salvapantallas debería finalizar su ejecución por sí mismo. Si no lo hace, en el menú Debug, hacer clic en Break All, o escribir Ctrl+Alt+Break, y a continuación hacer clic en Stop Debugging.
Hemos llegado al final del ejercicio. Para aprender más sobre cómo utilizar el depurador, consultar el Debugger Roadmap en la documentación local de Visual C# Express.