104 - Excepciones propias

La librería .Net proporciona gran cantidad de clases que manejan casi cualquier tipo de excepción, pero no estamos obligados a utilizar solo esas clases sino que podemos crear nuestras propias excepciones.

Si queremos crear una excepción deberemos heredar de Exception o de alguna de sus subclases.

Veamos con un ejemplo como crear una clase que herede de Exception, luego en otra clase lanzar una excepción de la nueva clase creada y finalmente llamar al método que lanza la excepción.

Problema:

Confeccionar una clase que administre una lista tipo pila (se debe poder insertar, extraer e imprimir los datos de la pila).

En el método extraer lanzar una excepción si la pila se encuentra vacía, crear una excepción propia que herede de Exception.

Clase: PilaVaciaException

public class PilaVaciaException extends Exception {

    public PilaVaciaException(String mensaje) {
        super("Problema:" + mensaje);
    }

}

La clase 'PilaVaciaException' hereda de la clase 'Exception', esto significa que quien lance una excepción de este tipo luego deberá ser capturada en forma obligatoria.

Clase: Pila

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PruebaExcepcion10
{
    public class PilaVaciaException : Exception
    {

        public PilaVaciaException(String mensaje) : base("Problema:" + mensaje)
        {
        }

    }

    public class Pila
    {
        class Nodo
        {
            public int info;
            public Nodo sig;
        }

        private Nodo raiz;

        public Pila()
        {
            raiz = null;
        }

        public void Insertar(int x)
        {
            Nodo nuevo;
            nuevo = new Nodo();
            nuevo.info = x;
            if (raiz == null)
            {
                nuevo.sig = null;
                raiz = nuevo;
            }
            else
            {
                nuevo.sig = raiz;
                raiz = nuevo;
            }
        }

        public int Extraer()
        {
            if (raiz != null)
            {
                int informacion = raiz.info;
                raiz = raiz.sig;
                return informacion;
            }
            else
            {
                throw new PilaVaciaException("No hay mas elementos en la pila");
            }
        }

        public bool Vacia()
        {
            return raiz == null;
        }
        public void Imprimir()
        {
            Nodo reco = raiz;
            Console.WriteLine("Listado de todos los elementos de la pila.");
            while (reco != null)
            {
                Console.Write(reco.info + "-");
                reco = reco.sig;
            }
            Console.WriteLine();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Pila pila1 = new Pila();
            pila1.Insertar(10);
            pila1.Insertar(40);
            pila1.Insertar(3);
            try
            {
                while (!pila1.Vacia())
                    Console.WriteLine("Extraemos de la pila:" + pila1.Extraer());
                Console.WriteLine("Extraemos de la pila:" + pila1.Extraer());
            }
            catch (PilaVaciaException ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.ReadKey();
        }
    }
}

El método 'Extraer' lanza una excepción de tipo 'PilaVaciaException' en caso que la pila se encuentre vacía:

        public int Extraer()
        {
            if (raiz != null)
            {
                int informacion = raiz.info;
                raiz = raiz.sig;
                return informacion;
            }
            else
            {
                throw new PilaVaciaException("No hay mas elementos en la pila");
            }
        }

En la Main donde creamos un objeto de la clase 'Pila' insertamos 3 enteros:

            Pila pila1 = new Pila();
            pila1.Insertar(10);
            pila1.Insertar(40);
            pila1.Insertar(3);

Seguidamente dentro de un bloque try/catch atrapamos si ocurre una excepción de tipo 'PilaVaciaException', esto ocurre cuando finaliza el while y volvemos a llamar al método Extraer, siendo que la pila se encuentra vacía:

            try
            {
                while (!pila1.Vacia())
                    Console.WriteLine("Extraemos de la pila:" + pila1.Extraer());
                Console.WriteLine("Extraemos de la pila:" + pila1.Extraer());
            }
            catch (PilaVaciaException ex)
            {
                Console.WriteLine(ex.Message);
            }

Tenemos una salida similar a esta:

Problema propuesto

1. Plantear una clase llamada 'Termometro' que defina un atributo llamado temperatura. Lanzar una excepción propia llamada 'TemperaturaFueraRangoException' si se intenta fijar una temperatura con un valor menor a -192 o superior a 100.

Solución

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PruebaExcepcion11
{
    public class TemperaturaFueraRangoException : Exception
    {
        public TemperaturaFueraRangoException(String mensaje) : base(mensaje)
        {
        }
    }

    public class Termometro
    {
        private float temperatura;
        public float Temperatura
        {
            get
            {
                return temperatura;
            }
            set
            {
                if (value < -192 || value > 100)
                    throw new TemperaturaFueraRangoException($"La temperatura {value} esta fuera del rango [-192,100]");
                temperatura = value;
            }
        }

        public Termometro(float temperatura)
        {
            Temperatura = temperatura;
        }

        public void imprimir()
        {
            Console.WriteLine("La temperatura actual del termometro es " + temperatura);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Termometro termometro1 = new Termometro(30);
                termometro1.imprimir();
                termometro1.Temperatura = -200;
                termometro1.imprimir();
            }
            catch (TemperaturaFueraRangoException ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.ReadKey();
        }
    }
}