I UNIVERSIDAD AUTONOMA DE CHIAPAS

FCA. DE CONT. Y ADMON

COMPUS I
LIC. SISTEMAS COMPUTACIONALES

Manejo de excepciones.

CATEDRATICO:

KATHIANE TOLEDO VALDEZ

ALUMNOS:

WILBER ALDAIR ALEGRIA MENDEZ

MIGUEL GUADALUPE ESQUICA MOLINA.

A 27 DE ABRIL DEL 2019, TUXTLA GUTIERREZ, CHIAPAS

1 POO: Manejo de excepciones

Ìndice
Excepciones................................................................................................................................ 2

La jerga de las excepciones .................................................................................................... 3

Uso del objeto de excepción................................................................................................... 4

Clasificación de las excepciones ............................................................................................ 5

Bloques catch múltiples ......................................................................................................... 6

Lanzar una excepción ............................................................................................................. 6

Bibliografía................................................................................................................................. 8

1
2 POO: Manejo de excepciones

Excepciones
La forma "clásica" del control de errores es usar instrucciones "if", que vayan comprobando
cada una de las posibles situaciones que pueden dar lugar a un error, a medida que estas
situaciones llegan. Esto tiende a hacer el programa más difícil de leer, porque la lógica de la
resolución del problema se ve interrumpida por órdenes que no tienen que ver con el problema
en sí, sino con las posibles situaciones de error. Por eso, los lenguajes modernos, como C#,
permiten una alternativa: el manejo de "excepciones".

La idea es la siguiente: "intentaremos" dar una serie de pasos, y al final de todos ellos
indicaremos qué hay que hacer en caso de que alguno no se consiga completar. Esto permite
que el programa sea más legible que la alternativa "convencional".

Como dijimos antes, las cosas pueden salir mal. ¿Pero realmente necesitamos una herramienta
especial para manejar los errores? ¿No podríamos simplemente utilizar la instrucción if? Quizá
todo se solucionaría si empleáramos un código como éste:

if algo sale mal

manejar el problema
else
manejar la situación normal
Aquí hemos utilizado una mezcla de castellano coloquial y sintaxis de C# para establecer el
punto principal. Pero si tenemos varias invocaciones a métodos, cualquiera de las cuales podría
producir un error, la lógica se vuelve tan compleja que podría viciar incluso el “caso normal”.
Así, lo que habría sido una secuencia simple:

MétodoA()
MétodoB()
MétodoC()
se convertiría en:

MétodoA()
if MétodoA tuvo errores
manejar el problema del MétodoA
else
MétodoB()
if MétodoB() tuvo errores
manejar el problema del MétodoB
else
MétodoC()
if MétodoC tuvo errores
manejar el problema del MétodoC

2
3 POO: Manejo de excepciones

Los casos de error (que esperamos no ocurran muy seguido) dominan la lógica, y su
complejidad puede hacer que los programadores se muestren reacios a utilizar este código. De
hecho, las herramientas de C# para manejar excepciones nos permiten apegarnos a la
codificación para el caso normal, y manejar las excepciones en un área separada del programa.

La jerga de las excepciones

Las excepciones se inician, o se lanzan, y se detectan, o atrapan, en cualquie r parte del
programa. C# cuenta con las palabras clave throw, try y catch para llevar a cabo estas tareas.
Nuestro análisis comenzará por el caso más simple: cómo atrapar una excepción iniciada por
una clase de biblioteca.

Lo haremos dividiendo el fragmento de programa en dos bloques:

• En un primer bloque, indicaremos los pasos que queremos "intentar" (try).

• A continuación, detallaremos las posibles situaciones de error (excepciones) que
queremos "interceptar" (catch), y lo que se debe hacer en ese caso.

El código que tiene el riesgo de levantar la excepción debe ser colocado en el bloque de try.
Por ejemplo, en nuestro caso colocaremos lo siguiente:

// Codigo peligroso, lo colocamos en try para

// administrar la excepcion
try
{
// Hacemos la division
r = b / a;
}

El código adentro de try tiene dos opciones: levantar o no la excepción. Si la excepción se

levanta entonces en el bloque de catch podemos colocar el código que se encargue de evitar que
el programa termine inesperadamente. Aquí podemos poner código que corrija lo ocurrido. En
nuestro caso, no hay mucho que hacer, simplemente podemos enviar un mensaje al usuario y
dar un valor adecuado a la variable de resultado.

catch (Exception e)
{
// Aqui colocamos el codigo que salva la aplicacion
Console.WriteLine(“No es posible dividir entre cero”);
r = 0;
}

3
4 POO: Manejo de excepciones

Vemos que este bloque tiene un parámetro llamado e. Adentro de este parámetro podemos
encontrar información relacionada con la excepción. Lo que coloquemos en el interior del
bloque depende de la lógica de nuestra aplicación. Si no hubiera excepción el código adentro
del bloque catch no se ejecuta. Tenemos otro bloque llamado finally. Este bloque es opcional.
El código que se coloque en el bloque finally se ejecuta siempre sin importar si la excepción se
llevó a cabo o no. Siempre se ejecuta una vez que try o catch han finalizado de ejecutarse.
Finally puede ser utilizado para limpiar o liberar cualquier recurso que se haya utilizado en try
o catch. En nuestro caso puede utilizarse simplemente para darle al usuario el valor del
resultado.

finally
{
// Mostramos el resultado
Console.WriteLine(“El resultado es {0}”, r);
}

Uso del objeto de excepción

Al atrapar una excepción sabemos de antemano que algo salió mal. El objeto de excepción
contiene información adicional al respecto. Para averiguarla podemos usar la propiedad
Message y el método ToString, como en el siguiente ejemplo:

catch (FormatException objetoExcepción)

{
MessageBox.Show(objetoExcepción.Message);
MessageBox.Show(Convert.ToString(objetoExcepción));

La propiedad Message provee una cadena de texto corta que expone un mensaje de error
descriptivo. En este ejemplo el mensaje de la cadena de texto es:

//La cadena de entrada no tiene el formato correcto.

El método ToString devuelve una cadena con varias líneas. La primer línea es como el mensaje
mencionado anteriormente, y las otras son un rastreo de pila, mismo que empieza en el método
en donde ocurrió la excepción y recorre en sentido inverso los métodos que se invocaron y que
conducen a la excepción. El rastreo termina al encontrar un bloque catch que coincida con la
excepción. Muchas de estas líneas están relacionadas con métodos y bibliotecas del sistema de
C#, pero entre ellos encontrará información relacionada con su código. El elemento clave es el

4
5 POO: Manejo de excepciones

número de línea de su programa que se señala. Es ahí en donde se originó directamente la

excepción, o indirectamente mediante una invocación a un método.

Clasificación de las excepciones

En esta sección exploraremos las diversas clases de excepciones incluidas en la biblioteca de
C#. Básicamente la biblioteca nos proporciona una lista de nombres de clases de excepciones,
pero si no hay una adecuada podemos crear nuestra propia excepción. A pesar de esta
posibilidad, aquí no abordaremos el proceso de creación de nuevas excepciones, pues
confiamos en que usted podrá encontrar una que le sea útil dentro de la biblioteca. La herencia
se utiliza para clasificar los errores en tipos distintos. Hay una gran cantidad de clases de
excepciones predefinidas; en la Figura aparece una pequeña selección de las más comunes. He
aquí cómo interpretar la figura. Todas las excepciones heredan de la clase Exception; una de
esas clases es IOException, la cual a su vez se divide en otras subclases, en el sentido de que
EndOfStreamException y FileNotFoundException también son herederas de IOException. A
medida que aumenta la indentación o sangría de los nombres, las excepciones se vuelven más
específicas. La razón de este sistema de clasificación es que podemos optar por atrapar un solo
tipo de excepción (como sucede con EndOfStreamException) o todo un conjunto de
excepciones (como con IOException).

5
6 POO: Manejo de excepciones

Bloques catch múltiples

Nuestro ejemplo del cuadrado únicamente utilizó un bloque “catch”. Sin embargo, es posible
emplear varios bloques “catch” con un solo bloque try. Si lo hacemos, la regla establece que el
bloque catch más específico debe ir primero, seguido de los casos más generales. En el siguie nte
ejemplo dividimos 100 entre un número introducido por el usuario en un cuadro de texto.
Decidimos atrapar primero la excepción de división entre cero, después las excepciones de
formato, y al final cualquier excepción restante. Los tres bloques “catch” deben estar en el orden
siguiente:

private void button3_Click(object sender, EventArgs e)

{
int inferior, superior = 100;
try
{
inferior = Convert.ToInt32(textBox1.Text);
MessageBox.Show("Al dividir entre 100 obtenemos " +
Convert.ToString(superior / inferior));
}
catch (DivideByZeroException objetoExcepción)
{
MessageBox.Show("Error: imposible dividir entre cero: vuelva a
introducir los datos");
}
catch (FormatException objetoExcepción)
{
MessageBox.Show("Error en el número: vuelva a introducirlo");
}
catch (SystemException objetoExcepción)
{
MessageBox.Show(objetoExcepción.ToString());
}
}

Cabe mencionar que si invirtiéramos el orden de los últimos dos bloques “catch” nunca podría
detectarse una excepción FormatException, ya que estaría cubierta por la clase
SystemException.

Lanzar una excepción

En esta sección codificaremos un método que inicia (o lanza) una excepción. La tarea del
método es convertir una cadena que contiene "diez", "cien" o "mil" en su entero equivale nte.
Con el propósito de que este método sea útil en diversas situaciones, iniciaremos una excepción.

6
7 POO: Manejo de excepciones

Esto permitirá al invocador del método decidir sobre el curso de acción a tomar. En este caso
optaremos por lanzar una instancia de la clase FormatException. He aquí el código:

private void button6_Click(object sender, EventArgs e)

{
MessageBox.Show(Convert.ToString
(PalabraANúmero("cXien")));
}
private int PalabraANúmero(string palabra)
{
int resultado = 0;
if (palabra == "diez")
{
resultado = 10;
}
else if (palabra == "cien")
{
resultado = 100;
}
else if ( palabra == "mil")
{
resultado = 1000;
}
else
{
throw (new FormatException ("Entrada incorrecta: PalabraANúmero"));
}
return resultado;
}

A menudo la instrucción throw se ejecuta como resultado de una instrucción if; lo que hace es
crear una nueva instancia de la clase de excepción especificada, e iniciar una búsqueda tratando
de encontrar un bloque catch que coincida. Cuando se crea una nueva excepción es posible
proveer una cadena de mensaje alternativa, misma que el método que atrapó la excepción es
capaz de obtener mediante la propiedad Message.

7
8 POO: Manejo de excepciones

Bibliografía
Bell, D. and Parr, M. (2011). C# para estudiantes. México: Pearson Educación.

Landa Cosio, N. (2010). C#. Buenos Aires: Fox Andina.

Cabanes Nacho. (S/Ñ). Introducción a la programación con C#.