Gestion des erreurs ASP.NET

Décembre 2016


Introduction


Nous proposons dans ce qui suit de traiter les exceptions survenues côté client web dans les pages ASP.NET et en particulier aussi dans les pages en technologie AJAX. Il s’agit donc de capturer et de traiter les erreurs JavaScripts en évitant les erreurs gênants et parfois même bloquant chez notre client web.

Pré-requis


On suppose que nos lecteurs ont un minimum de connaissances avec la plateforme .NET et avec les pages ASP.NET en technologie AJAX. En outre, on se base dans ce qui suit sur le Framework.NET 3.5 avec l’IDE Microsoft Visual Studio 2008.

Gestion classique des erreurs ASP.NET avec le fichier Global.asax


Le fichier « Global.asax » nous offre la possibilité de centraliser la gestion des erreurs en capturant toute erreur non gérée dans notre application web. Ce ci nous permet par exemple de rediriger notre utilisateur web vers une page personalisée traitant l’erreur en cours en fonction de son type.
Si par exemple on force une erreur dans un événement de click d’un bouton ASP.NET :
protected void btn_Click(object sender, EventArgs e)
{
    throw new Exception("Exception générée pour test !");
}

L’exception n’étant pas gérée dans la méthode, on peut toujours la capturer dans la méthode « Application_Error » du fichier « Global.asax » :
protected void Application_Error(object sender, EventArgs e)
{
    // Capturer la dernière erreur survenue
    Exception exception = Server.GetLastError().GetBaseException();
    try
    {
        // Mettre l'erreur dans la mémoire de la session
        Context.Session["Excep"] = exception;
        // Rediriger notre appel vers la page d'erreur
        this.Response.Redirect("~/PageDErreur.aspx");
    }
    catch (Exception innerEx)
    {
        string errorMsg = "Une erreur s'est produite lors du traitement de l'exception : " + exception.Message + ". ";
        errorMsg += Environment.NewLine + innerEx.ToString();
    }
}


Bien entendu, on doit d’habitude ajouter dans notre fonction de gestion d’erreur une mise en log et si nécessaire un traitement du cas par cas en fonction de la nature de l’exception levée.
Finalement, on peut rediriger notre utilisateur web vers une page d’erreur affichant un message adéquat.

Gestion des erreurs survenues côté client en technologie AJAX


En travaillant en technologie AJAX, on a toujours tendance à enrichir notre client web avec du code JavaScript, ce qui augmente le risque des erreurs au niveau du client. Il serait dans ce cas préconisé de capturer et de gérer toute erreur JavaScript et éventuellement de la mettre en log ou de l’envoyer par email à un technicien afin d’assurer le suivi et la maintenance du site ou de l’application web.
Commençant par la simulation d’une exception JavaScript sur le click d’un bouton. Notre bouton est le suivant :
<input type="button" value="Test d'erreur JavaScript" onclick="javascript: testDErreurJavaScript();" />
En appelant notre fonction JavaScript on génére l’erreur comme suit :
function testDErreurJavaScript() {
    try {
        throw 'Test d'erreur JavaSript !';
    }
    catch (exception) {
        alert(exception);
    }
}


Ici on a décidé de gérer notre exception au niveau de la fonction appelée, mais supposons actuellement qu’on a des erreurs potentiellement possibles et qu’on ne gère pas obligatoirement à toute reprise. C’est le cas si on simule notre exception de la manière qui suit :
function testDErreurJavaScript() {
    throw 'Test d'erreur JavaSript !';
}

Dans ce cas, on peut profiter de l’événement « onerror » de l’objet JavaScript « window » comme suit :
window.onerror = function() {
    alert('An error has occurred!')
    return true;
}


Ceci nous permettrait de capturer toute erreur JavaScript non gérée et pouvant se présenter dans notre code client.
Après capture de l’erreur, le plus adéquat serait bien sure de transmettre l’événement au serveur pour une gestion plus élaborée ; à savoir, une mise en log, une alerte par email au webmaster, etc.
Pour se faire, on va opter pour l’appel d’un service web ASP.NET en lui transmettant les informations nécessaires. Le choix d’un appel AJAX, nous offre l’avantage de garder le fonctionnement de notre page correctement même après l'avènement de l’erreur.
Construisons alors notre service web :
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;

namespace ApplicationWebAjax
{
    /// <summary>
    /// Summary description for ServiceWebAjax
    /// </summary>
    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]
    // To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line. 
    [System.Web.Script.Services.ScriptService]
    public class ServiceWebAjax : System.Web.Services.WebService
    {
        [WebMethod(EnableSession=true)]
        public string GereException(string errorMsg, string url, int lineNumber)
        {
            // Ici ajouter votre code de mise en log, ...
            return "Erreur traitée au niveau serveur !";
        }
    }
}

Bien entendu, vous aurez à ajouter votre traitement spécifique en fonction des attentes de votre application. Par la suite, on doit modifier notre événement « onerror » comme suit :
window.onerror = function(errorMsg, url, lineNumber) {
    ApplicationWebAjax.ServiceWebAjax.GereException(errorMsg, url, lineNumber, GereException_SucceededCallback, FailedCallback);
    alert(errorMsg);
    return true;
}

On note la présence des paramètres « url » et « lineNumber » très utiles lors de la spécification de notre exception.
Il faut en outre ajouter les fonctions traitant les retours de notre appel AJAX soit en succès soit en échec :
function GereException_SucceededCallback(resultat) {
    document.getElementById('testDiv').innerHTML += '<b>' + resultat + '</b><br />';
}

function FailedCallback(error) {
    var stackTrace = error.get_stackTrace();
    var message = error.get_message();
    var statusCode = error.get_statusCode();
    var exceptionType = error.get_exceptionType();
    var timedout = error.get_timedOut();
    alert("Stack Trace: " +  stackTrace + "nr" +
            "Service Error: " + message + "nr" +
            "Status Code: " + statusCode + "nr" +
            "Exception Type: " + exceptionType + "nr" +
            "Timedout: " + timedout);
}

Conclusion


L’article présenté ici vous offre des connaissances de base pour la capture et la gestion des erreurs en ASP.NET mais toute application nécessite l’introduction de spécificité en fonction des besoins. Ceci doit être complété dans certains cas d’un système de mise en log et d’un envoi automatique d’emails d’alertes.

A voir également :

Ce document intitulé «  Gestion des erreurs ASP.NET  » issu de CommentCaMarche (www.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.