Spędziłem kilka godzin, rozwiązując ten problem. Moje rozwiązanie opiera się na następujących życzeniach / wymaganiach:
- Nie używaj powtarzającego się standardowego kodu obsługi błędów we wszystkich akcjach kontrolera JSON.
- Zachowaj kody stanu HTTP (błąd). Czemu? Ponieważ problemy wyższego poziomu nie powinny wpływać na implementację niższego poziomu.
- Być w stanie uzyskać dane JSON, gdy na serwerze wystąpi błąd / wyjątek. Czemu? Ponieważ chciałbym uzyskać szczegółowe informacje o błędach. Np. Komunikat o błędzie, kod statusu błędu specyficzny dla domeny, ślad stosu (w środowisku debugowania / programowania).
- Łatwość obsługi po stronie klienta - najlepiej przy użyciu jQuery.
Tworzę HandleErrorAttribute (zobacz komentarze do kodu, aby uzyskać wyjaśnienie szczegółów). Kilka szczegółów, w tym „użycie”, zostało pominiętych, więc kod może się nie skompilować. Dodaję filtr do filtrów globalnych podczas inicjalizacji aplikacji w Global.asax.cs w ten sposób:
GlobalFilters.Filters.Add(new UnikHandleErrorAttribute());
Atrybut:
namespace Foo
{
using System;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Web;
using System.Web.Mvc;
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public sealed class FooHandleErrorAttribute : HandleErrorAttribute
{
private readonly TraceSource _TraceSource;
public FooHandleErrorAttribute(TraceSource traceSource)
{
if (traceSource == null)
throw new ArgumentNullException(@"traceSource");
_TraceSource = traceSource;
}
public TraceSource TraceSource
{
get
{
return _TraceSource;
}
}
public FooHandleErrorAttribute()
{
var className = typeof(FooHandleErrorAttribute).FullName ?? typeof(FooHandleErrorAttribute).Name;
_TraceSource = new TraceSource(className);
}
public override void OnException(ExceptionContext filterContext)
{
var actionMethodInfo = GetControllerAction(filterContext.Exception);
if(actionMethodInfo == null) return;
var controllerName = filterContext.Controller.GetType().FullName;
var actionName = actionMethodInfo.Name;
var traceMessage = string.Format(@"Unhandled exception from {0}.{1} handled in {2}. Exception: {3}", controllerName, actionName, typeof(FooHandleErrorAttribute).FullName, filterContext.Exception);
_TraceSource.TraceEvent(TraceEventType.Error, TraceEventId.UnhandledException, traceMessage);
if (actionMethodInfo.ReturnType != typeof(JsonResult)) return;
var jsonMessage = FooHandleErrorAttributeResources.Error_Occured;
if (filterContext.Exception is MySpecialExceptionWithUserMessage) jsonMessage = filterContext.Exception.Message;
filterContext.Result = new JsonResult
{
Data = new
{
message = jsonMessage,
stacktrace = MyEnvironmentHelper.IsDebugging ? filterContext.Exception.StackTrace : null
},
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
filterContext.ExceptionHandled = true;
filterContext.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
filterContext.HttpContext.Response.Cache.SetCacheability(HttpCacheability.NoCache);
base.OnException(filterContext);
}
private static MethodInfo GetControllerAction(Exception exception)
{
var stackTrace = new StackTrace(exception);
var frames = stackTrace.GetFrames();
if(frames == null) return null;
var frame = frames.FirstOrDefault(f => typeof(IController).IsAssignableFrom(f.GetMethod().DeclaringType));
if (frame == null) return null;
var actionMethod = frame.GetMethod();
return actionMethod as MethodInfo;
}
}
}
Opracowałem następującą wtyczkę jQuery, aby ułatwić obsługę po stronie klienta:
(function ($, undefined) {
"using strict"
$.FooGetJSON = function (url, data, success, error) {
/// <summary>
/// **********************************************************
/// * UNIK GET JSON JQUERY PLUGIN. *
/// **********************************************************
/// This plugin is a wrapper for jQuery.getJSON.
/// The reason is that jQuery.getJSON success handler doesn't provides access to the JSON object returned from the url
/// when a HTTP status code different from 200 is encountered. However, please note that whether there is JSON
/// data or not depends on the requested service. if there is no JSON data (i.e. response.responseText cannot be
/// parsed as JSON) then the data parameter will be undefined.
///
/// This plugin solves this problem by providing a new error handler signature which includes a data parameter.
/// Usage of the plugin is much equal to using the jQuery.getJSON method. Handlers can be added etc. However,
/// the only way to obtain an error handler with the signature specified below with a JSON data parameter is
/// to call the plugin with the error handler parameter directly specified in the call to the plugin.
///
/// success: function(data, textStatus, jqXHR)
/// error: function(data, jqXHR, textStatus, errorThrown)
///
/// Example usage:
///
/// $.FooGetJSON('/foo', { id: 42 }, function(data) { alert('Name :' + data.name)
/// </summary>
// Call the ordinary jQuery method
var jqxhr = $.getJSON(url, data, success)
// Do the error handler wrapping stuff to provide an error handler with a JSON object - if the response contains JSON object data
if (typeof error !== "undefined") {
jqxhr.error(function(response, textStatus, errorThrown) {
try {
var json = $.parseJSON(response.responseText)
error(json, response, textStatus, errorThrown)
} catch(e) {
error(undefined, response, textStatus, errorThrown)
}
})
}
// Return the jQueryXmlHttpResponse object
return jqxhr
}
})(jQuery)
Co mam z tego wszystkiego? Ostateczny wynik jest taki
- Żadna z moich akcji kontrolera nie ma wymagań dotyczących HandleErrorAttributes.
- Żadne z moich działań kontrolera nie zawiera powtarzającego się kodu obsługi błędów płyty kotłowej.
- Mam pojedynczy punkt kodu obsługi błędów, który pozwala mi łatwo zmieniać rejestrowanie i inne rzeczy związane z obsługą błędów.
- Prosty wymóg: akcje kontrolera zwracające JsonResult muszą mieć zwracany typ JsonResult, a nie jakiś typ podstawowy, taki jak ActionResult. Przyczyna: zobacz komentarz do kodu w FooHandleErrorAttribute.
Przykład po stronie klienta:
var success = function(data) {
alert(data.myjsonobject.foo);
};
var onError = function(data) {
var message = "Error";
if(typeof data !== "undefined")
message += ": " + data.message;
alert(message);
};
$.FooGetJSON(url, params, onSuccess, onError);
Komentarze są mile widziane! Pewnie kiedyś napiszę o tym rozwiązaniu ...