public MiClase()
{
try
{
MiClase.MetodoEstatico();
}
catch (DivideByZeroException esepcion)
{
throw new DivideByZeroException("fallo2", esepcion);
}
}
public MiClase(int dec)
{
try
{
MiClase aux = new MiClase();
}
catch (DivideByZeroException e)
{
throw new UnaException("Constructor con parametro", e);
}
}
public MiClase(int numero)
{
try
{
MiClase objeto = new MiClase();
}
catch (DivideByZeroException esepcion)
{
throw new DivideByZeroException("fallo3", esepcion);
}
}
/*Generar la clase OtraClase con un método de instancia, donde se instancie un objeto
* MiClase y se capture la excepción anterior. Este método generará una excepción propia
* llamada MiException y la lanzará.*/
public static void CapturarExMiClase()
{
try
{
MiClase clase2 = new MiClase();
}
catch (UnaExcepcion e)
{
throw new MiExcepcion("mi excepcion", e);
}
}
public void UnMetodoDeInstancia()
{
try
{
MiClase otraClase = new MiClase(1);
}
catch (UnaExepcion ex)
{
throw new MiExcepcion("Mensaje MiExcepcion", ex);
}
}
public void MetodoInstancia()
{
try
{
MiClase clase = new MiClase(2);
}
catch (UnaException e)
{
throw new MiException("Metodo instancia", e);
}
}
public void Metodo()
{
try
{
MiClase m = new MiClase("");
}
catch (UnaExcepcion ex)
{
throw new MiExcepcion("Error Otra clase", ex);
}
}
/*En este segundo constructor instanciará otro objeto del tipo MiClase capturando su
* excepción. Crear una excepción propia llamada UnaException (utilizar innerException para
* almacenar la excepción original) y volver a lanzarla.*/
public MiClase(string nulo /*parametro sin uso, solo para poder sobrecargar*/)
{
try
{
MiClase clase = new MiClase();
}
catch (DivideByZeroException e)
{
throw new UnaExcepcion("una exepcion", e);
//caputuro la excepcion e y la guardo en una nueva excepcion para volver a lanzarla
}
}
public MiClase()
{
try
{
MiClase.MetodoEstatico();
}
catch (DivideByZeroException dbz)
{
throw dbz;
}
}
public MiClase(int a)
{
this.a = a;
try
{
MiClase nuevaClase = new MiClase();
}
catch (DivideByZeroException ex)
{
throw new UnaExepcion("Mensaje UnaExecion", ex);
}
}
/*Capturar la excepción del metodp estatico en un constructor de instancia y relanzarla hacia
* otro constructor de instancia.*/
public MiClase()
{
try
{
MiClase.LanzarDivideByZero();
//atrapo exepcion lanzada por metodo estatico
}
catch (DivideByZeroException e)
{
throw e;
//relanzo exepcion sin instanciarla de nuevo porque ya fue instanvciada en el metodo
}
}
public static void metodo()
{
int numero = 0;
try
{
MiClase objeto = new MiClase(numero);
}
catch (DivideByZeroException gato)
{
throw new UnaEsepcion("ececion nueva", gato);
}
}
static void Main(string[] args)
{
MiClase a = new MiClase();
MiClase b = new MiClase();
//catch (MiExcepcion e)
//{
// UnaExcepcion aux = new UnaExcepcion("Excepcion capturada en el main", e);
// try
// {
// throw aux;
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex.Message);
// Console.ReadLine();
// }
//}
//catch (DivideByZeroException e)
//{
// Exception primerConstructor = new Exception("Excepcion del metodo estático", e);
// try
// {
// throw primerConstructor;
// }
// catch (Exception ex)
// {
// Exception segundoConstructor = new Exception("Excepcion del primer bloque catch", ex);
// Console.WriteLine(segundoConstructor.Message);
// Console.ReadLine();
// }
//}
}