Exemplo n.º 1
0
 public MiClase()
 {
     try
     {
         MiClase.MetodoEstatico();
     }
     catch (DivideByZeroException esepcion)
     {
         throw new DivideByZeroException("fallo2", esepcion);
     }
 }
Exemplo n.º 2
0
 public MiClase(int dec)
 {
     try
     {
         MiClase aux = new MiClase();
     }
     catch (DivideByZeroException e)
     {
         throw new UnaException("Constructor con parametro", e);
     }
 }
Exemplo n.º 3
0
 public MiClase(int numero)
 {
     try
     {
         MiClase objeto = new MiClase();
     }
     catch (DivideByZeroException esepcion)
     {
         throw new DivideByZeroException("fallo3", esepcion);
     }
 }
Exemplo n.º 4
0
        /*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);
     }
 }
Exemplo n.º 6
0
 public void MetodoInstancia()
 {
     try
     {
         MiClase clase = new MiClase(2);
     }
     catch (UnaException e)
     {
         throw new MiException("Metodo instancia", e);
     }
 }
Exemplo n.º 7
0
 public void Metodo()
 {
     try
     {
         MiClase m = new MiClase("");
     }
     catch (UnaExcepcion ex)
     {
         throw new MiExcepcion("Error Otra clase", ex);
     }
 }
Exemplo n.º 8
0
 /*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
     }
 }
Exemplo n.º 9
0
        public MiClase()
        {
            try
            {
                MiClase.MetodoEstatico();
            }

            catch (DivideByZeroException dbz)
            {
                throw dbz;
            }
        }
Exemplo n.º 10
0
 public MiClase(int a)
 {
     this.a = a;
     try
     {
         MiClase nuevaClase = new MiClase();
     }
     catch (DivideByZeroException ex)
     {
         throw new UnaExepcion("Mensaje UnaExecion", ex);
     }
 }
Exemplo n.º 11
0
 /*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
     }
 }
Exemplo n.º 12
0
        public static void metodo()
        {
            int numero = 0;

            try
            {
                MiClase objeto = new MiClase(numero);
            }
            catch (DivideByZeroException gato)
            {
                throw new UnaEsepcion("ececion nueva", gato);
            }
        }
Exemplo n.º 13
0
        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();
            //    }

            //}
        }