Pages d'erreur personnalisées sur asp.net MVC3

Je développe un site Web de base MVC3 et je recherche une solution pour gérer les erreurs et rendre des vues personnalisées pour chaque type d'erreur. Imaginez donc que j'ai un contrôleur "Erreur" où son action principale est "Index" (page d'erreur générique) et ce contrôleur aura quelques actions supplémentaires pour les erreurs qui peuvent apparaître à l'utilisateur comme "Handle500" ou "HandleActionNotFound".

Ainsi, chaque erreur qui peut survenir sur le site Web peut être gérée par ce contrôleur "Erreur" (exemples: "Contrôleur" ou "Action" introuvable, 500, 404, dbException, etc.).

J'utilise le fichier Sitemap pour définir les chemins du site Web (et non l'itinéraire).

Cette question a déjà été répondue, ceci est une réponse à Gweebz

Ma dernière méthode applicaiton_error est la suivante:

protected void Application_Error() {
//while my project is running in debug mode
if (HttpContext.Current.IsDebuggingEnabled && WebConfigurationManager.AppSettings["EnableCustomErrorPage"].Equals("false"))
{
    Log.Logger.Error("unhandled exception: ", Server.GetLastError());
}
else
{
    try
    {
        var exception = Server.GetLastError();

        Log.Logger.Error("unhandled exception: ", exception);

        Response.Clear();
        Server.ClearError();
        var routeData = new RouteData();
        routeData.Values["controller"] = "Errors";
        routeData.Values["action"] = "General";
        routeData.Values["exception"] = exception;

        IController errorsController = new ErrorsController();
        var rc = new RequestContext(new HttpContextWrapper(Context), routeData);
        errorsController.Execute(rc);
    }
    catch (Exception e)
    {
        //if Error controller failed for same reason, we will display static HTML error page
        Log.Logger.Fatal("failed to display error page, fallback to HTML error: ", e);
        Response.TransmitFile("~/error.html");
    }
}
}

Voici un exemple de la façon dont je gère les erreurs personnalisées. Je définis un ErrorsControlleravec des actions gérant différentes erreurs HTTP:

public class ErrorsController : Controller
{
    public ActionResult General(Exception exception)
    {
        return Content("General failure", "text/plain");
    }

    public ActionResult Http404()
    {
        return Content("Not found", "text/plain");
    }

    public ActionResult Http403()
    {
        return Content("Forbidden", "text/plain");
    }
}

puis je m'abonne au Application_Errorin Global.asaxet j'appelle ce contrôleur:

protected void Application_Error()
{
    var exception = Server.GetLastError();
    var httpException = exception as HttpException;
    Response.Clear();
    Server.ClearError();
    var routeData = new RouteData();
    routeData.Values["controller"] = "Errors";
    routeData.Values["action"] = "General";
    routeData.Values["exception"] = exception;
    Response.StatusCode = 500;
    if (httpException != null)
    {
        Response.StatusCode = httpException.GetHttpCode();
        switch (Response.StatusCode)
        {
            case 403:
                routeData.Values["action"] = "Http403";
                break;
            case 404:
                routeData.Values["action"] = "Http404";
                break;
        }
    }

    IController errorsController = new ErrorsController();
    var rc = new RequestContext(new HttpContextWrapper(Context), routeData);
    errorsController.Execute(rc);
}

Voici plus d'articles Comment créer des pages d'erreur personnalisées avec MVC http://kitsula.com/Article/MVC-Custom-Error-Pages .

Vous pouvez également le faire dans le fichier Web.Config. Voici un exemple qui fonctionne dans IIS 7.5.

     <system.webServer>
          <httpErrors errorMode="DetailedLocalOnly" defaultResponseMode="File">
                <remove statusCode="502" subStatusCode="-1" />
                <remove statusCode="501" subStatusCode="-1" />
                <remove statusCode="412" subStatusCode="-1" />
                <remove statusCode="406" subStatusCode="-1" />
                <remove statusCode="405" subStatusCode="-1" />
                <remove statusCode="404" subStatusCode="-1" />
                <remove statusCode="403" subStatusCode="-1" />
                <remove statusCode="401" subStatusCode="-1" />
                <remove statusCode="500" subStatusCode="-1" />
                <error statusCode="500" path="/notfound.html" responseMode="ExecuteURL" />
                <error statusCode="401" prefixLanguageFilePath="" path="/500.html" responseMode="ExecuteURL" />
                <error statusCode="403" prefixLanguageFilePath="" path="/403.html" responseMode="ExecuteURL" />
                <error statusCode="404" prefixLanguageFilePath="" path="/404.html" responseMode="ExecuteURL" />
                <error statusCode="405" prefixLanguageFilePath="" path="/405.html" responseMode="ExecuteURL" />
                <error statusCode="406" prefixLanguageFilePath="" path="/406.html" responseMode="ExecuteURL" />
                <error statusCode="412" prefixLanguageFilePath="" path="/412.html" responseMode="ExecuteURL" />
                <error statusCode="501" prefixLanguageFilePath="" path="/501.html" responseMode="ExecuteURL" />
                <error statusCode="502" prefixLanguageFilePath="" path="/genericerror.html" responseMode="ExecuteURL" />
           </httpErrors>
</system.webServer>

Je vois que vous avez ajouté une valeur de configuration pour EnableCustomErrorPageet que vous vérifiez également IsDebuggingEnabledsi vous souhaitez exécuter ou non votre gestion des erreurs.

Puisqu'il existe déjà une <customErrors/>configuration dans ASP.NET (qui est destinée exactement à cet effet), il est plus facile de dire simplement:

    protected void Application_Error()
    {
        if (HttpContext.Current == null) 
        {
                // errors in Application_Start will end up here                
        }
        else if (HttpContext.Current.IsCustomErrorEnabled)
        {
                // custom exception handling
        }
    }

Ensuite, dans la configuration, vous mettez <customErrors mode="RemoteOnly" />ce qui est sûr à déployer comme ça, et lorsque vous avez besoin de tester votre page d'erreur personnalisée, vous la définissez sur<customErrors mode="On" /> que vous puissiez vérifier qu'elle fonctionne.

Notez que vous devez également vérifier si HttpContext.Currentest null car une exception dans Application_Startcette méthode sera toujours sa cette méthode bien qu'il n'y ait pas de contexte actif.

Vous pouvez afficher une page d'erreur conviviale avec le code d'état http correct en implémentant le module User Friendly Exception Handling de Jeff Atwood avec une légère modification du code d'état http. Cela fonctionne sans aucune redirection. Bien que le code date de 2004 (!), Il fonctionne bien avec MVC. Il peut être entièrement configuré dans votre web.config, sans aucune modification du code source du projet MVC.

La modification requise pour renvoyer le statut HTTP d'origine plutôt qu'un 200statut est décrite dans cet article de forum connexe .

Fondamentalement, dans Handler.vb, vous pouvez ajouter quelque chose comme:

' In the header...
Private _exHttpEx As HttpException = Nothing

' At the top of Public Sub HandleException(ByVal ex As Exception)...
HttpContext.Current.Response.StatusCode = 500
If TypeOf ex Is HttpException Then
    _exHttpEx = CType(ex, HttpException)
    HttpContext.Current.Response.StatusCode = _exHttpEx.GetHttpCode()
End If

J'utilise MVC 4.5 et j'avais des problèmes avec la solution de Darin. Remarque: la solution de Darin est excellente et je l'ai utilisée pour trouver ma solution. Voici ma solution modifiée:

protected void Application_Error(object sender, EventArgs e)
{           
var exception = Server.GetLastError();
var httpException = exception as HttpException;
Response.StatusCode = httpException.GetHttpCode();

Response.Clear();
Server.ClearError();


if (httpException != null)
{
    var httpContext = HttpContext.Current;

    httpContext.RewritePath("/Errors/InternalError", false);

    // MVC 3 running on IIS 7+
    if (HttpRuntime.UsingIntegratedPipeline)
    {
        switch (Response.StatusCode)
        {
            case 403:
                httpContext.Server.TransferRequest("/Errors/Http403", true);
                break;
            case 404:
                httpContext.Server.TransferRequest("/Errors/Http404", true);
                break;
            default:
                httpContext.Server.TransferRequest("/Errors/InternalError", true);
                break;
        }
    }
    else
    {
        switch (Response.StatusCode)
        {
            case 403:
                httpContext.RewritePath(string.Format("/Errors/Http403", true));
                break;
            case 404:
                httpContext.RewritePath(string.Format("/Errors/Http404", true));
                break;
            default:
                httpContext.RewritePath(string.Format("/Errors/InternalError", true));
                break;
        }

        IHttpHandler httpHandler = new MvcHttpHandler();
        httpHandler.ProcessRequest(httpContext);
    }
}
}