Control de errores en ASP.NET MVC: Handle Exceptions.

En este tutorial aprenderemos acerca del control de errores en nuestra aplicación. Para llegar a este punto es necesario que previamente tengamos unos conocimientos en ASP.NET y MVC . Si no sabes lo que es un proyecto ASP.NET/MVC o no has creado ninguno, antes de ver este post te recomiendo que visites otros tutoriales sobre los primeros pasos, y una vez que tengas tu aplicación, visita este tutorial para saber cómo controlar las excepciones de tu proyecto. 

Una aplicación web puede dar lugar a diversos tipos de errores, y pueden deberse a muchas cosas distintas. 

Cuando un error ocurre, nuestra aplicación genera una página de error predeterminada con información acerca de éste, por ejemplo, si es una página no encontrada (error 404) o si es un fallo de acceso a la base de datos. 

Aquí vemos un ejemplo con una página de error 404 predeterminada. 

A través del control de errores (Handle Exceptions), le iremos diciendo a nuestra aplicación qué mensaje queremos que muestre con cada tipo de error que nos aparezca. 

¿Por qué es importante el control de errores? 

Estética:

Primeramente, queremos que nuestra aplicación final muestre mensajes personalizados según el estilo que estemos siguiendo, ya sea de un cliente o nuestro. 

Seguridad:

No queremos que nuestra excepción facilite información sensible acerca de nuestras rutas y base de datos a los usuarios, o nuestras configuraciones. Las páginas que sacan las aplicaciones de ASP.NET Web Forms cuando hay un error no controlado son llamadas también «pantallas amarillas de la muerte» (YSOD: Yellow Screen Of Death). 

En este ejemplo, solo con permitir a esta pantalla por defecto aparecer, le estamos poniendo en bandeja a cualquier posible atacante información sobre la estructura de nuestra base de datos que debería ser confidencial, como el tipo de datos que usamos o los nombres de tablas y campos. Además, en la última línea (donde pone Source File), estamos mostrando cual es la ruta física donde están almacenados los archivos de nuestra aplicación en el servidor. 

Formas de control de errores:

Hay varias maneras distintas de controlar nuestras excepciones en ASP.NET MVC. 

Según como queramos manejar el error y de qué error se trate, usaremos una o varias de estas opciones: 

Usar Try-catch 

Nunca dejes este mensaje de error a la vista, a parte de ser poco estético podría comprometer la seguridad de tu sitio. 

Usar el atributo [HandleError] en las acciones y los controladores. 

El action filter HandleError, ofrecido por ASP.NET MVC, en el controlador redirige todas las excepciones a la página Error.aspx por defecto ubicada en Views/Shared, aunque podemos indicarle otra vista en el atributo. 

Usar el método Application_Error() en Global.asax.  

A través de Application_Error() podríamos definir un comportamiento para los errores de la aplicación que sean incontrolables por filter o por onException.  

Para ello, podemos tener un controlador con una serie de vistas, por ejemplo: Index, NotFound, Forbidden y Default.  

De esta manera, en caso de error, podemos redirigir a una vista personalizada, y también podemos realizar alguna acción, a través del controlador, antes de finalizar la petición.  

Por otro lado, también podemos utilizar este método de forma conjunta con HandleError para cubrir todas las excepciones posibles. 

Sobrescribir el método OnException. 

Si lo que queremos es utilizar un atributo común para todas las excepciones, le indicamos al método OnException qué queremos que haga en caso de excepción, para ello lo sobrescribimos cambiando lo que queramos modificar. 

Sobrescribir el atributo [HandleError] 

También podemos sobrescribir el action filter HandleError, por ejemplo incluyendo las HttpExceptions, y ampliar así su funcionalidad. 

Tipos de excepciones:

Como he dicho, podemos usar una o varias opciones según el tipo de excepción: 

Excepciones de tipo HttpException: 

Errores 400 – Errores del cliente (url incorrecta etc) 

Errores 500 – Errores del servidor 

Son excepciones globales:

– Usamos Application_Error en global.asax

– Sobrescribimos OnException 

Excepciones personalizadas:

– Habilitamos customErrors en el archivo web.config de la aplicación. 

– Utilizamos el action filter HandleError en el controlador.

Práctica:

Ahora veremos un ejemplo práctico: crearemos dos páginas de error. Para ello te iré guiando paso a paso. 

La primera página será para manejar un error de la rama HttpException. En este caso elegiré el error 404 (página no encontrada) por lo sencillo que resulta generarlo, ya que solo tendremos que abrir nuestra aplicación en el explorador e indicarle una ruta errónea. Lo que queremos es que al introducir mal la url no nos lleve a la página por defecto, sino a una que hayamos diseñado nosotros. 

Después crearemos otra vista de error para ir a ella en caso de que error que se genere sea cualquier otro, así manejaremos todos los demás errores. Esto es sólo un ejemplo, y en una aplicación real no te recomiendo hacer esta mala práctica, lo ideal es manejar el máximo de errores posibles por separado. 

Para los ejemplos he creado un proyecto llamado Tutorial_HandleExceptions que puedes descargar aquí. 

https://github.com/MartaMCSD2020/Tutorial_HandleExceptions

Si quieres crearlo conmigo de cero (te lo recomiendo, para ponerlo en práctica), estoy usando Visual Studio 2019 y he elegido una aplicación web ASP.NET (.NET Framework) con carpetas MVC. 

También puedes ir viendo los pasos en el vídeo. 

Empecemos con el error 404. 

Página no encontrada:

Vista

Lo primero que voy a hacer es crear una carpeta para las vistas que se llame Error. 

Dentro creare la primera vista, Error404. 

Esta vista es la que podremos decorar como queramos, y será lo que el usuario vea cuando escriba mal una ruta dentro de la aplicación. 

Borro su contenido y agrego mi plantilla de bootstrap con una página de error ya creada. 

Esto no es necesario, podría dejarla como está. Es simplemente por estética. 

Controlador

Una vez ya tengo mi vista creada, creo un controlador para poder visualizarla. 

El controlador se llamará como la carpeta, ErrorController, y la acción a realizar será la vista, Error404. 

Lo único que tengo que decirle a la acción es que muestre la vista. 

Application_Error()

Ahora por último tenemos que indicar en la aplicación que si hay un error 404 no queremos que nos lleve a la página por defecto, sino a nuestra nueva vista. 

Antes os expliqué que para personalizar los errores teníamos que ir a web.config y añadirle esta línea: 

En este caso no será necesario, así que lo dejaremos en off. 

Iremos global.asax y, debajo del método Application_Start, nos crearemos el método de control de errores, llamado Application_Error() 

Buscaremos la última excepción generada, que será como decir que cuando se genere una excepción, esa, que será la última, será la que manejaremos. Después de manejarla vamos a borrarla. 

Convertimos la excepción a HttpException, y podremos usar el método GetHttpCode() que nos dirá de qué código de error se trata. 

 Le diremos que si se trata de un error 404, la acción del controlador será la que nos lleva a nuestra plantilla de bootstrap. 

 Ya con la variable, que contiene el nombre de nuestra acción guardada, podemos borrar el error. 

Ahora nos creamos los datos de nuestra ruta. Toda ruta necesita una acción y un controlador, que son los que hemos creado al principio. 

Como estamos manejando errores, el controlador siempre va a ser el de nuestra carpeta Error, que es donde están nuestras vistas de error. 

Y para la accion tenemos nuestra variable, que ahora tiene el nombre de nuestra vista 404. 

Añadimos los valores a la ruta. 

Y le indicamos al controlador ErrorController que lo ejecute. 

Y ya está. Ya podemos cargar la aplicación y escribir mal una ruta para ver nuestra vista. 

Errores Generales

Ahora para el resto de errores, repetiremos los pasos que hemos seguido para el error 404, pero en este caso, llamaremos a la vista, por ejemplo, ErrorGeneral y en el ErrorController le añadimos la accion ErrorGeneral. 

Volvemos a global.asax donde tenemos nuestro método de control de errores y añadimos un else a nuestro if que nos lleve a nuestra nueva vista.

Así, cualquier error que no sea nuestro 404, mostrará nuestra nueva página. 

 Por último y como bonus final, os dejo una serie de consejos a tener en cuenta cuando os dispongáis a controlar las excepciones de vuestra aplicación. 

• Intenta manejar los errores de forma individual, en vez de tener una misma respuesta para todos. Utiliza una respuesta para todos solo con aquellos que no hayas podido tener en cuenta. 

• No dejes una «YSOD» por defecto, ya que ese mensaje revelaría demasiada información. Procura guardar la información en algún sitio accesible únicamente por los encargados del soporte y la depuración. 

• Procura llevar un registro de errores que sea privado, y mantenerte revisándolo para adelantarte a los errores antes de que salgan a la luz. 

Muchas gracias por visitar el blog de Tajamar, espero que mi tutorial te haya servido de ayuda.

Hay más publicaciones de alumnos compartiendo sus conocimientos, te invito a visitarlos y seguir aprendiendo.

Autora: Marta Valdés Azcárraga

Curso: Microsoft MCSA Web Applications + Microsoft MCSD App Builder + Xamarin 

Centro: Tajamar 

Año académico: 2019-2020 

Código / recursos utilizados / Otros datos de interés: https://github.com/MartaMCSD2020/Tutorial_HandleExceptions

Linkedin: https://www.linkedin.com/in/marta-vald%C3%A9s-563548196/