Manejo de Errores
Manejo de Errores
Manejo de Errores
Índice
Descripción………………………………………….……..1
Lección: Tipos de errores………………….……….2
Lección: Uso del depurador………………………10
Lección: Gestión de excepciones……………..38
Manejo de errores y excepciones 1
Descripción
Crear
Escribir
Interfaz
Código
Tipos de errores
Uso de Visual Uso del depurador
Studio .NET
Manejo de excepciones
Acceso
A datos Depurar
e Implantar
Introducción A medida que los programas son más grandes y más complejos, es inevitable
que se produzcan un determinado número de errores. Incluso la programación
más cuidadosa puede producir errores involuntarios, también denominados
bugs. El proceso de encontrar y eliminar estos errores se denomina depuración
(debugging).
En este módulo, estudiaremos los tipos de errores que pueden ocurrir en un
programa y cómo utilizar el depurador de Microsoft® Visual Studio® .NET, las
diversas ventanas de depuración y la gestión estructurada de excepciones para
ayudar a diagnosticar, corregir y realizar el tratamiento de errores.
Objetivos En este módulo, aprenderemos a:
Definir y ver ejemplos de errores de sintaxis, tiempo de ejecución y lógica.
Depurar código utilizando el depurador de Visual Studio .NET.
Implementar en nuestra aplicación la gestión estructurada de excepciones.
2 Manejo de errores y excepciones
Objetivo de la lección En esta lección, aprenderemos a describir la diferencia entre errores de sintaxis,
de tiempo de ejecución y de lógica.
Manejo de errores y excepciones 3
Error
Error de
de sintaxis
sintaxis
Error
Error de
de sintaxis
sintaxis
Introducción El tipo más obvio de error es un error de sintaxis, que tiene lugar cuando
escribimos código de un modo no permitido por las reglas del lenguaje.
Algunos ejemplos más habituales incluyen una palabra clave mal escrita, la
omisión de puntuación requerida, o una construcción incorrecta (como una
instrucción For sin la correspondiente instrucción Next, o la palabra clave If en
una línea sin un operador condicional).
Encontrar errores de Visual Basic® .NET muestra los errores de sintaxis mientras escribimos cada
sintaxis instrucción del código de nuestra aplicación. La parte de código que contiene el
error aparece con un subrayado en forma de diente de sierra. Cuando colocamos
el cursor del ratón sobre el código subrayado, aparece un consejo con una breve
descripción del error junto al cursor.
Los errores de sintaxis son recogidos por el compilador, el cual muestra un
mensaje de error informándonos del problema. Si ignoramos los errores de
sintaxis mientras escribimos el código, podemos visualizar y abordarlos en
cualquier momento en la ventana de la Lista de tareas. Si intentamos generar
nuestra aplicación sin corregir los errores de sintaxis, la ventana de la Lista de
tareas mostrará todos los errores incluidos en la lista.
4 Manejo de errores y excepciones
Visualizar errores en la La ventana Lista de tareas incluye una descripción del error, la ruta al archivo
ventana Lista de tareas en el que se ha producido el error y el número de la línea del código que
contiene el error. La descripción del error es la misma información que
obtenemos si posicionamos el cursor del ratón sobre la parte subrayada del
código en el Editor de código.
Podemos editar los errores haciendo doble clic en la entrada correspondiente en
la Lista de tareas. El punto de inserción se posiciona en el archivo correcto y la
línea exacta donde se encuentra el error, de modo que podemos cambiar nuestro
código. En cuanto finalicemos los cambios y salgamos de la línea modificada,
se actualizarán las entradas de la ventana Lista de tareas.
En la ventana Lista de tareas, también podemos ver tareas que hemos creado
comentando nuestro código con la frase TODO.
Visualizar errores en la También podemos utilizar la ventana Resultados para ver los errores de
ventana de Resultados generación. Esta ventana muestra una lista de avisos, errores y el estado de
generación mientras Visual Studio .NET está generando la aplicación. Al final
del proceso de generación, proporciona un resumen, incluyendo la ubicación de
los errores de sintaxis (número de línea y archivo) y una breve descripción de
los problemas.
Manejo de errores y excepciones 5
Speed
Speed == Miles/Hours
Miles/Hours
'' If
If Hours
Hours == 0,
0, the
the statement
statement is
is
syntactically
syntactically correct,
correct, but
but the
the division
division
is
is an
an invalid
invalid operation
operation
Introducción Los errores de tiempo de ejecución son errores que ocurren cuando una
instrucción intenta realizar una operación que es imposible llevar a cabo; por
ejemplo, referenciar un objeto inaccesible. Los errores de tiempo de ejecución
apareen durante la ejecución del código.
Ejemplo de un error en Con frecuencia, los errores de tiempo de ejecución son el resultado de acciones
tempo de ejecución imprevistas. Por ejemplo, un usuario podría olvidar insertar un disquete en una
unidad, o seleccionar un archivo de entrada de datos no válido. Un error
habitual en tiempo de ejecución es intentar dividir por cero. Pensemos en el
siguiente código:
Velocidad = Kilómetros / Horas
Introducción Los errores lógicos son errores que se producen cuando una aplicación no se
comporta del modo previsto. Estos errores son especialmente difíciles de
encontrar porque es posible que no generen un mensaje de error. Una aplicación
puede tener un código válido sintácticamente y ejecutarse sin realizar ninguna
operación no válida, pero producir resultados incorrectos.
Ejemplo de error lógico El siguiente código contiene un error lógico que en algún momento provocará
un error de tiempo de ejecución.
Dim x As Integer = 2
Do While x < 10
' Code statements
x -= 1
Loop
Ë Ejecutar la aplicación
4. En la barra de herramientas, hacer clic en el botón Iniciar.
5. En la ventana Form1, hacer clic en Button1.
Se producirá una excepción no controlada de tipo
System.IndexOutOfRangeException.
6. En el cuadro de diálogo Microsoft Development Environment, hacer clic
en Break.
7. Mover el cursor del ratón sobre index en la línea de código seleccionada.
Observar que la sugerencia muestra 5 como valor de la variable index. La
variable index se incrementa en el bucle For desde 0 al resultado de
names.GetLength(0). El problema es que el método GetLength devuelve
el número de elementos en la dimensión de una matriz. Debido a que las
matrices se numeran desde cero, el valor devuelto por el método GetLength
necesita reducirse en 1 para el bucle For…Next.
8. Pulsar F8.
La flecha amarilla indica la línea de código que se ejecutará a continuación.
9. Pulsar F8.
Debido a que la longitud del nombre Brandon es mayor que el valor actual
de maxLen, la ejecución continúa en la siguiente línea.
10. Pulsar F8.
Observar que el nombre más largo (longestName) de la ventana Inspección
ahora contiene Brandon.
11. Pulsar F8.
12. Pulsar F8.
Observar que index se ha incrementado en 1. Sin embargo, la siguiente línea
que se ejecuta es la instrucción If y no el bucle For. Esto se debe a que el
bucle For ya se está ejecutando.
13. Pulsar F8.
Aunque Bob es un nombre más corto que Brandon, la ejecución continúa en
la siguiente línea. Esto se debe a que la variable maxLen no se ha
actualizado y todavía contiene 0. Éste es el error del código.
14. Detener la aplicación pulsando MAYÚSCULAS+F5.
15. Después de la instrucción de código
longestName = names(index)
Breakpoints
Breakpoints
Nota Para eliminar todos los puntos de interrupción al mismo tiempo, hacer
clic en Borrar todos los puntos de interrupción en el menú Depurar.
La ventana Puntos de La ventana Puntos de interrupción muestra una lista de todos los puntos de
interrupción interrupción establecidos actualmente en nuestro programa y sus propiedades.
En la ventana Puntos de interrupción, podemos establecer nuevos puntos de
interrupción, eliminar, habilitar o deshabilitar puntos de interrupción, modificar
las propiedades de un punto de interrupción, o ir al código fuente o
desensamblar el código correspondiente al punto de interrupción.
Propiedad
Propiedad
Condition
Condition
Propiedad
Propiedad
Hit
Hit Count
Count
Uso de la propiedad De modo predeterminado, el depurador detiene la ejecución del código cada vez
Recuento de visitas que se llega a un punto de interrupción. No obstante, algunos errores no
aparecen la primera vez que nuestro programa ejecuta un bucle, invoca una
función o accede a una variable. Por ello, es posible que deseemos detener la
ejecución sólo cuando se haya llegado al punto de interrupción un número
específico de veces. Este número se denomina recuento de visitas. Podemos
utilizar la propiedad Recuento de visitas para especificar cuántas veces se
alcanza el punto de interrupción antes de que el depurador detenga su ejecución.
Establecer la propiedad
Recuento de visitas
Ë Establecer la propiedad Recuento de visitas de un punto de
interrupción
6. En el menú Depurar, seleccionar Ventanas y, a continuación, hacer clic en
Puntos de interrupción.
7. Abrir el cuadro de diálogo Propiedades del punto de interrupción
seleccionando el punto de interrupción adecuado en la ventana Puntos de
interrupción y haciendo clic en Propiedades en la barra de
herramientas de la ventana Puntos de interrupción.
8. En el cuadro de diálogo Propiedades del punto de interrupción, hacer clic
en Recuento de visitas.
9. En el cuadro de diálogo Recuento de visitas al punto de interrupción, en
el cuadro Cuando el punto de interrupción se visita, hacer clic en el tipo
de prueba de recuento de visitas que desea realizar. Las opciones
disponibles son las siguientes:
a. interrumpir siempre
b. interrumpir cuando el recuento de visitas es igual a
Manejo de errores y excepciones 21
Stop
Stop Show
Show Next
Next Hexadecimal
Hexadecimal
Start
Start Step
Step Over
Over
Debugging
Debugging Statement
Statement Display
Display
Break
Break All
All Restart
Restart Step
Step Into
Into Step
Step Out
Out Breakpoints
Breakpoints
Uso de Paso a paso por Tanto Paso a paso por instrucciones como Paso a paso por procedimientos
instrucciones y Paso a ordenan al depurador que ejecute la siguiente línea de código. Estos comandos
paso por sólo se diferencian en un aspecto: la forma en que controlan las invocaciones a
procedimientos procedimientos.
Si la línea contiene una invocación a un procedimiento:
Paso a paso por instrucciones únicamente ejecuta la invocación, y se
detiene en la primera línea de código dentro del procedimiento.
Paso a paso por procedimientos ejecuta todo el procedimiento, y se
detiene en la primera línea de código fuera del procedimiento.
Uso de Paso a paso para Utilizar Paso a paso para salir cuando nos encontremos dentro de la
salir invocación a un procedimiento y se desee regresar al procedimiento de llamada.
Paso a paso para salir reanuda la ejecución de código hasta el retorno del
procedimiento, y se interrumpe en el punto de retorno del procedimiento de
llamada.
Uso de Ejecutar hasta el Podemos utilizar el comando Ejecutar hasta el cursor para ordenar al
cursor depurador que ejecute nuestra aplicación hasta alcanzar el punto de inserción
que hemos establecido haciendo clic en el Editor de código con el ratón. El
comando Ejecutar hasta el cursor no está disponible en el menú Depurar.
Para ejecutar este comando, hacer clic con el botón derecho en la ventana
fuente y, a continuación, hacer clic en Ejecutar hasta el cursor en el menú de
acceso directo.
Iniciar la acción de ir Para iniciar la depuración de una aplicación, podemos utilizar Iniciar, Paso a
paso a paso por el paso por instrucciones, Paso a paso por procedimientos o Ejecutar hasta el
código cursor.
Si hacemos clic en Iniciar, nuestra aplicación se iniciará y se ejecutará hasta
llegar a un punto de interrupción. Podemos interrumpir la ejecución en
cualquier momento para examinar valores, modificar variables, y examinar
el estado de nuestro programa.
Si hacemos clic en Paso a paso por instrucciones o Paso a paso por
procedimientos, nuestra aplicación se interrumpirá en la primera línea de
código ejecutable.
Si hacemos clic en Ejecutar hasta el cursor, nuestra aplicación se iniciará
y se ejecutará hasta llegar a un punto de interrupción o al lugar del punto de
inserción, lo que ocurra antes. En algunos casos, no se produce una
interrupción. Esto significa que la ejecución no llega en ningún momento a
la línea de código en la que se ha establecido el punto de inserción.
Manejo de errores y excepciones 25
Ventana
Ventana Utilice
Utilice esta
esta ventana
ventana para…
para…
para…
Ver
Ver variables
variables en
enla
lainstrucción
instrucciónactual
actual yytres
tres
Autos
Autos instrucciones
instrucciones antes
antes yydespués
despuésdedela
lainstrucción
instrucción
actual
actual
Ver
Ver elel histórico
históricode
dellamadas
llamadas aala
lalínea
líneade
decódigo
código
Call
CallStack
Stack que
queseseestáestádepurando
depurando
Locals
Locals Ver
Ver yymodificar
modificarvariables
variableslocales
locales
Crear
Crear una
unalista
listapersonalizada
personalizada de
devariables
variables yy
Watch
Watch expresiones
expresionesquequemonitorizar
monitorizar
Ver
Ver yymanipular
manipular cualquier
cualquierexpresión
expresiónwatch
watch
Introducción El depurador de Visual Studio .NET dispone de diversas ventanas que nos
permiten inspeccionar nuestro programa en detalle y modificar su estado. Las
ventanas Automático, Pila de llamadas, Variables locales e Inspección son las
ventanas de depuración que probablemente más utilizaremos.
Uso de la ventana Podemos utilizar la ventana Automático para visualizar variables en la
Automático instrucción actual y tres instrucciones anteriores y posteriores a la instrucción
actual. La instrucción actual es la instrucción en el lugar de ejecución actual (la
instrucción que se ejecutará a continuación si la ejecución continúa). También
podemos utilizar la ventana Automático para modificar el valor de una
variable.
Uso de la ventana Pila Podemos utilizar la ventana Pila de llamadas para ver el histórico de llamadas
de llamadas de la línea de código que se está depurando, incluyendo cualquier tipo de
parámetros y valores de parámetros. Se denomina pila de llamadas (call stack)
a la serie de procedimientos invocados dentro de una aplicación.
Uso de la ventana Podemos utilizar la ventana Variables locales para visualizar y modificar
Variables locales variables locales al contexto actual. Esta ventana proporciona información
explícita sobre objetos, como información sobre herencia.
¿Ventana Inspección o El depurador de Visual Studio .NET proporciona un cuadro de diálogo modal
cuadro de diálogo denominado Inspección rápida que ofrece una forma rápida de evaluar o
Inspección rápida? modificar una sola variable o expresión. Debido a que Inspección rápida es
modal, no podemos dejarlo abierto para inspeccionar una variable o expresión
mientras vamos recorriendo nuestro programa. Si deseamos inspeccionar una
variable o expresión mientras recorremos nuestro programa, agregaremos esa
variable o expresión a la ventana Inspección. No obstante, si simplemente
deseamos realizar un cálculo rápido que implique una o más variables, podemos
utilizar Inspección rápida.
Tarea
Tarea Solució
Solución
Solución Ejemplo
Ejemplo
Encabezar
Encabezarlalaexpresión
expresióncon
conun
un
Evaluar
Evaluarexpresiones
expresiones signo ?myVariable
?myVariable
signode
deinterrogación
interrogación(?)
(?)
Cambiar
Cambiaraamodo
modoInmediato
Inmediato Escribir
Escribirimmed
immeden enlalaventana,
ventana,sin
sin
elelsigno immed
immed
desde
desdemodo
modoComando
Comando signomayor
mayor que
que(>)(>)
Regresar
Regresaraamodo
modoComando
Comando Escribir
Escribir>cmd
>cmden
enlalaventana
ventana >cmd
>cmd
desde
desdemodo
modoInmediato
Inmediato
Entrar
Entrartemporalmente
temporalmenteen
enmodo
modo Escribir
Escribirelelcomando,
comando,precedido
precedidodel
del >alias
>alias
Comando
Comandodesde
desdemodo
modo signo
Inmediato signomayor
mayorque que(>)
(>)
Inmediato
Nota Debemos incluir el signo mayor que (>) cuando invocamos comandos de
Visual Studio .NET estando en modo Inmediato. Los comandos escritos en
modo Comando no van precedidos del signo mayor que.
32 Manejo de errores y excepciones
Ë Abrir el proyecto
• Abrir el proyecto DebugApplication.sln, que se encuentra en la carpeta
Starter dentro del fichero practs08.zip.
Esta aplicación calcula el número de palabras de una frase. El usuario
escribe una frase en un cuadro de texto de un formulario y hace clic en un
botón; a continuación, aparece un cuadro de mensaje informando al usuario
de cuantas palabras contiene la frase que se ha escrito.
La siguiente imagen muestra la aplicación que se está ejecutando.
Manejo de errores y excepciones 33
_________________________________________________________
_________________________________________________________
_________________________________________________________
_________________________________________________________
_________________________________________________________
34 Manejo de errores y excepciones
__________________________________________________________
__________________________________________________________
Nota Comprobar las respuestas antes de continuar con la práctica. Para revisar
las respuestas, podemos utilizar las que se proporcionan en el material del
estudiante, comparar las respuestas con otro estudiante o mostrarlas al profesor.
Para revisar las respuestas de las dos últimas preguntas, también podemos
establecer un punto de interrupción al principio del bucle While y utilizar el
comando Paso a paso por instrucciones (F8) para movernos paso a paso por el
código.
Manejo de errores y excepciones 35
_________________________________________________________
_________________________________________________________
4. Utilizar el comando Paso a paso por instrucciones (F8) para recorrer paso
a paso las líneas del código. A medida que recorremos el código, utilizar la
ventana Automático para examinar los valores de la variable y determinar
cuándo ocurre el error.
Puede utilizar las siguientes preguntas como ayuda para localizar el error
lógico:
a. ¿Cuál es el valor de location durante la primera repetición del bucle
While?
5.
__________________________________________________________
__________________________________________________________
__________________________________________________________
__________________________________________________________
__________________________________________________________
__________________________________________________________
Manejo de errores y excepciones 37
Ë Probar la aplicación
• Ejecutar y probar la aplicación en modo de depuración.
Archivos de solución Los archivos de solución se encuentran en la carpeta Solution dentro del fichero
practs08.zip.
38 Manejo de errores y excepciones
La clase Exception
¿Qué es la gestión estructurada de excepciones?
Cómo utilizar la instrucción Try…Catch
Cómo utilizar el bloque Finally
Cómo lanzar excepciones
Directrices para el uso de la gestión estructurada de
excepciones
La clase Exception
El .NET Framework proporciona el siguiente modelo de objeto de
excepciones:
Exception
Exception
SystemException
SystemException
OutOfMemoryException
OutOfMemoryException
IOException
IOException
FileNotFoundException
FileNotFoundException
ApplicationException
ApplicationException
¿Qué es una excepción? Una excepción es cualquier condición de error o comportamiento imprevisto
que se produce durante la ejecución de un programa y requiere la ejecución de
código fuera del flujo de control normal. Las excepciones pueden provocarse
por un fallo de nuestro código o de código invocado, porque los recursos del
sistema operativo no estén disponibles, por condiciones imprevistas que
encuentre el CLR, etc. Una excepción se lanza (en otras palabras, se origina)
desde el área del código donde se ha producido un problema.
La clase Exception En el .NET Framework, el entorno de ejecución crea un objeto que representa
una excepción cuándo ésta se produce. Las excepciones son objetos que
heredan de la clase base Exception. El .NET Framework define varias clases de
excepciones. Estas clases proporcionan información sobre excepciones de un
modo significativo y nos permiten recuperar información sobre cualquier
excepción que encontremos. Esta información nos ayuda a depurar eficazmente
nuestras aplicaciones.
La siguiente tabla describe algunas propiedades de la clase base Exception que
nos ayudarán a identificar la localización del código, tipo y causa de una
excepción. Cualquier excepción que herede de la clase base proporcionará estas
propiedades.
Propiedad Descripción
StackTrace Ofrece una lista de los métodos invocados que conducen a la excepción,
ayudándonos a encontrar en qué parte del código se produce el error.
Message Devuelve un mensaje de texto que describe el error. Utilizar esta propiedad para
recuperar información acerca de porqué se ha lanzado una excepción.
Podemos cambiar el texto para que un mensaje críptico sea más fácil de entender. Si
no proporcionamos una cadena de texto para el mensaje de error, se utilizará el valor
predeterminado.
HelpLink Obtiene o establece un enlace a un archivo asociado de Ayuda.
Source Obtiene o establece una cadena que contiene el nombre del objeto que causa el error
o el nombre del ensamblado en el que se originó la excepción.
40 Manejo de errores y excepciones
Con el uso de los bloques Try y Catch, separamos las instrucciones de control
de errores de las instrucciones lógicas principales. De esto modo, se facilita la
lectura y depuración del programa.
42 Manejo de errores y excepciones
Ejemplo de uso de El siguiente código proporciona un ejemplo de uso de un bloque Finally para
Try…Catch…Finally cerrar un archivo abierto.
En este ejemplo:
El bloque Try siempre se ejecuta.
• Si hay un error FileNotFoundException, el código del primer bloque
Catch se ejecuta a continuación, seguido del código del bloque Finally.
• Si se produce cualquier otro tipo de error, el código del segundo bloque
Catch se ejecuta a continuación, seguido del código del bloque Finally.
Si no hay ningún error, el código del bloque Finally se ejecuta después del
código del bloque Try.
Try
fs = New FileStream("data.txt", FileMode.Open)
Catch ex As FileNotFoundException
MessageBox.Show("Data File Missing")
Catch ex As Exception
MessageBox.Show(ex.Message)
Finally
If Not (fs Is Nothing) Then fs.Close( )
End Try
46 Manejo de errores y excepciones
If
If (day
(day << 1)
1) Or
Or (day
(day >> 365)
365) Then
Then
Throw
Throw New
New ArgumentOutOfRangeException(
ArgumentOutOfRangeException( ))
Else
Else
...
...
End
End If
If
Introducción La instrucción Throw crea una excepción que podemos controlar con el código
de la gestión estructurada de excepciones. En algunos casos, deberíamos utilizar
una instrucción Throw para lanzar una excepción, que puede ser atrapada
invocando código. Para entender cuando podríamos necesitar lanzar una
excepción, pensemos en el siguiente escenario.
Escenario utilizando la Cuando escribimos aplicaciones grandes, es una práctica habitual escribir
instrucción Throw código reutilizable: procedimientos Function y Sub que pueden utilizarse
repetidamente en la aplicación o en otras aplicaciones. Normalmente, una
función toma ciertos parámetros, realiza una tarea y puede devolver un valor.
Por ejemplo: una función que tome el día del año como un entero y devuelva la
fecha del calendario. Cuando pase el número 33, se supone que esta función
devolverá “2 de febrero”.
Como desarrolladores de esta función, necesitamos pensar cómo controlar el
caso de pasar a la función un dato no válido. Por ejemplo, si se pasa a la
función un número negativo, o un número mayor que 365 en caso de años no
bisiestos, se producirá un error, y el valor devuelto no será correcto.
La mejor solución a este problema es dependiente de la aplicación. En un caso
sencillo, podríamos pedir al usuario que introdujera la información correcta. Sin
embargo, si esta función es invocada por otra función en lugar de por un
usuario, la solución no es tan sencilla. En este caso, podemos escribir una
instrucción Throw que lance la excepción adecuada en caso de que el
argumento pasado a la función esté fuera de rango.
Ejemplo de uso de la El siguiente código utiliza la instrucción Throw para crear un error
instrucción Throw ArgumentOutOfRangeException:
If (day < 1) Or (day > 365) Then
Throw New ArgumentOutOfRangeException( )
Else
...
End If
Manejo de errores y excepciones 47
Ejemplo de control del En el siguiente ejemplo se lanza una excepción si la conexión no está cerrada.
mismo error utilizando
Try…Catch Try
conn.Close( )
Catch ex As InvalidOperationException
' Do something with the error or ignore it
End Try
Cuándo utilizar cada El método que decidamos utilizar para controlar errores potenciales depende de
método con qué frecuencia esperamos que se produzca un determinado evento. Si el
evento es realmente excepcional y es un error (como un error imprevisto de fin
de archivo), utilizar la gestión de excepciones es mejor porque se ejecuta menos
48 Manejo de errores y excepciones
Ë Ejecutar la aplicación
1. Abrir la solución Exceptions.sln, que se encuentra en la carpeta Exceptions.
Esta carpeta se puede encontrar dentro del fichero demos08.zip.
2. Abrir el Editor de código del formulario Exceptions.vb y establecer seis
puntos de interrupción: uno en la instrucción Try, y uno en cada instrucción
Catch en la rutina RunExceptions.
3. Ejecutar el proyecto Exceptions.
4. Hacer clic en el botón Overflow del formulario. El proceso de Visual Basic
se detendrá en el primer punto de interrupción.
5. Utilizar F8 para recorrer el código paso a paso en el bloque Try, y explique
los detalles del overflow. Explique que la clase OverflowException filtra la
excepción.
6. Recorrer el resto de código de la excepción del overflow. Cuando se muestre
el cuadro de mensaje, hacer clic en OK y pulsar F5 para proseguir con la
ejecución.
7. Mostrar todos los botones restantes del formulario de prueba (Divide by
zero, Index out of Range y Cast Error) del mismo modo:
a. Hacer clic en el botón adecuado del formulario.
b. Utilizar F8 para recorrer por el código y mostrar cómo se controlan las
excepciones en cada caso.
c. Hacer clic en OK y pulsar F5 para proseguir con la ejecución.
8. Cuando hayamos mostrado el control de excepciones para cada botón
finalizar la sesión de depuración cerrando el formulario.
9. Cerrar el entorno de desarrollo Visual Studio .NET.