1- Que son las excepciones y como se manejan
Es la indicación de un problema que ocurre durante la ejecución de un programa. El nombre excepción viene del hecho de que, aunque puede ocurrir un problema, este ocurre con poco frecuencia. Si la “regla”es que una instrucion generalmente se ejecuta en forma correcta, entonces la ocurrencia de un problema representa la “excepción a la regla”.
2- Cuando utilizar el manejo de excepciones
3 y 4- Ejemplo de manejo de excepciones manejando varios catch
El siguiente ejemplo utiliza el manejo de excepciones para procesar cualquier excepción DivideByZeroexception y FormatException que pueda surgir.
1 // Fig. 12.2: DivideByZeroTest.cs
2 // Exception handlers for FormatException and DivideByZeroException.
3 using System;
4 using System.Windows.Forms;
5
6 namespace DivideByZeroTest
7 {
8 public partial class DivideByZeroTestForm : Form
9 {
10 public DivideByZeroTestForm()
11 {
12 InitializeComponent();
13 } // end constructor
14
15 // obtain 2 integers from the user
16 // and divide numerator by denominator
17 private void DivideButton_Click( object sender, EventArgs e )
18 {
19 OutputLabel.Text = ""; // clear Label OutputLabel
20
21 // retrieve user input and calculate quotient
22 try
23 {
24 // Convert.ToInt32 generates FormatException
25 // if argument is not an integer
26 int numerator = Convert.ToInt32( NumeratorTextBox.Text );
27 int denominator = Convert.ToInt32( DenominatorTextBox.Text );
28
29 // division generates DivideByZeroException
30 // if denominator is 0
31 int result = numerator / denominator;
32
33 // display result in OutputLabel
34 OutputLabel.Text = result.ToString();
35 } // end try
36 catch ( FormatException )
37 {
38 MessageBox.Show( "You must enter two integers.",
39 "Invalid Number Format", MessageBoxButtons.OK,
40 MessageBoxIcon.Error );
41 } // end catch
42 catch ( DivideByZeroException divideByZeroExceptionParameter )
43 {
44 MessageBox.Show( divideByZeroExceptionParameter.Message,
45 "Attempted to Divide by Zero", MessageBoxButtons.OK,
46 MessageBoxIcon.Error );
47 } // end catch
48 } // end method DivideButton_Click
49 } // end class DivideByZeroTestForm
50 } // end namespace DivideByZeroTest
5 y 7- Ejemplo de finally y trow
class UsoDeExcepciones
{
static void Main()
{
// Caso 1: No ocurren excepciones en el metodo que se llamó
Console.WriteLine("Llamando a NoLanzaExcepcion");
NoLanzaExcepcion();
// Caso 2: Ocurre una excepción y se atrapa en el metodo que se llamó
Console.WriteLine("Llamando a LanzaExcepcionConCatch");
LanzaExcepcionConCatch();
// Caso 3: Ocurre una excepcion, pero no se atrapa en el metodo que se llamo,
// ya que no hay bloque catch.
Console.WriteLine("Llamado a LanzaExcepcionSinCatch");
// llama a LanzaExcepcionSinCatch
try
{
LanzaExcepcionSinCatch();
} // fin de try
catch
{
Console.WriteLine("Atrapó la excepción de " + "LanzaExcepcionSinCatch en Main");
} // fin de catch
// Caso 4: Ocurre una excepción y se atrapa en el metodo que se llamo,
// despues se vuelve a lanzar al que hizo la llamada.
Console.WriteLine("Llamando a LanzaExcepcionCatchLanzaDeNuevo");
// llama a LanzaExcepcionCatchLanzaDeNuevo
try
{
LanzaExcepcionCatchLanzaDeNuevo();
}
catch
{
Console.WriteLine("atrapó la excepción de " + "LanzaExcepcionCatchLanzaDeNuevo en Main");
Console.ReadLine();
} // fin de catch
} // fin del metodo Main
// no se lanzan excepciones
static void NoLanzaExcepcion()
{
// el bloque try no lanza excepciones
try
{
Console.WriteLine("En NoLanzaExcepcion");
} // fin de try
catch
{
Console.WriteLine("Este bloque catch nunca se ejecuta");
} // fin de catch
finally
{
Console.WriteLine("se ejecutó finally en NolanzaExcepcion");
} // fin de finally
Console.WriteLine("Fin de NoLanzaExcepcion");
} // fin de metodo NoLanzaExcepcion
//lanza la excepción y la atrapa en forma local
static void LanzaExcepcionConCatch()
{
// el bloque try lanza la excepcion
try
{
Console.WriteLine("En LanzaExcepcionConCatch");
throw new Exception("excepción en LanzaExcepcionConCatch");
} // fin de try
catch (Exception parametroExcepcion)
{
Console.WriteLine("Mensaje: " + parametroExcepcion.Message);
} // fin de catch
finally
{
Console.WriteLine("se ejecutó finally en LanzaExcepcionConCatch");
} // fin de finally
Console.WriteLine("Fin de LanzaExcepcionConCatch");
} // fin del metodo LanzaExcepcionConCatch
// lanza la excepción y no la atrapa en forma local
static void LanzaExcepcionSinCatch()
{
// lanza la excepcion, pero no la atrapa
try
{
Console.WriteLine("En LanzaExcepcionSinCatch");
throw new Exception("Excepción en LanzaExepcionSinCatch");
} // fin de try
finally
{
Console.WriteLine("Se ejecutó finally en" + "LanzaExcepcionSinCatch");
} // fin de finally
// codigo inalcanzable; error logico
Console.WriteLine("Fin de LanzaExcepcionSinCatch");
} // fin del metodo LanzaExcepcionSinCatch
// lanza la excepcion, la atrapa y la vuelve a lanzar
static void LanzaExcepcionCatchLanzaDeNuevo()
{
// el bloque try lanza la excepcion
try
{
Console.WriteLine("En LanzaExcepcionCatchLanzaDeNuevo");
throw new Exception("Exepción en LanzaExcepcionCatchLanzaDeNuevo");
} // fin de try
catch (Exception parametroExcepcion)
{
Console.WriteLine("Mensaje: " + parametroExcepcion);
// vuelve a lanzar la exepcion para procesarla despues
throw;
// codigo inalcanzable; error logico
} // fin de catch
finally
{
Console.WriteLine("se ejecutó finally en " + "LanzaExcepcionCatchLanzaDeNuevo");
} // fin de finally
// cualquier codigo que se coloque aqui nunca se ejecutara
Console.WriteLine("Fin de LanzaExcepcionCatchLanzaDeNuevo");
} // fin del metodo LanzaExcepcionCatchLanzaDeNuevo
} // fin de la clase UsoDeExcepciones
} // fin del namespace finally
6- Describir las clases de excepciones y sus propiedades
La clase Exception del espaciado de nombres System es la clase base de la jerarquía de clases de excepciones del .Net framework. Dos de las clases mas importantes que se derivan de Exception son ApplicationException y SystemException. ApplicationException es una clase base que los programadores pueden extender para crear clases de excepciones especificas para sus aplicaciones.
El CLR genera excepciones SystemException, que pueden ocurrir en cualquier punto durante la ejecución de un programa. Podemos evitar muchas d estas excepciones si codificamos las aplicaciones en forma apropiada. Por ejemplo, si un programa trata de acceder a un subíndice de arreglo fuera de rango, el CLR lanza una excepción de tipo IndexOutOfRangeException (una clase derivada de SystemException).
Los tipos de excepcines se derivan de la clase Exception, la cual tiene varias propiedades. Estas se utilizan con frecuencia para formular mensajes de error que indican una excepción atrapada. De las propiedades mas importantes son Message y StackTrace. La propiedad Message almacena el mensaje de error asociado con un objeto Exception. Este mensaje puede ser un mensaje predeterminado asociado con el tipo de excepción, o puede ser un mensaje personalizado que se pasa al cnstructo de un objeto Exception cuando este se lanza. La propiedad StackTrace contiene un objeto string que representa la pila de llamadas a los métodos. La propiedad StackTrace representa la serie de metoos que no han terminado de procesarse al momento en que ocurre la excepción.
La clase Exception tiene otras propiedades, incluyendo HelpLink, Source y TargetSite. La propiedad HelpLink especifica la ubicación del archivo de ayuda que describe el problema que ocurrió. Esta propiedad es null si no existe dicho archivo. La propiedad Source especifica el nombre de la aplicación en la que ocurrió la excepción. La propiedad TargetSite especifica el método en donde se origino la excepción.
8- Crear excepciones definidas por el usuario
En algunos casos tal ves sea conveniente crear nuevas clases de excepciones que sean especificas para los problemas que ocurran en sus programas. Las clases de excepciones definidas por el usuario deben derivarse de manera directa o indirecta de la clase ApplicationException, del espaciado de nombres System.
