Obsługa błędów ASP.NET MVC Ajax

Jak obsłużyć wyjątki zgłaszane w kontrolerze, gdy jquery ajax wywołuje akcję?

Na przykład chciałbym mieć globalny kod javascript, który jest wykonywany na jakimkolwiek wyjątku serwera podczas wywołania ajax, które wyświetla komunikat o wyjątku, jeśli jest w trybie debugowania lub po prostu zwykły komunikat o błędzie.

Po stronie klienta wywołam funkcję dotyczącą błędu Ajax.

Czy po stronie serwera muszę napisać niestandardowy filtr akcji?

Jeśli serwer wyśle ​​kod stanu inny niż 200, zostanie wykonane wywołanie zwrotne błędu:

$.ajax({
    url: '/foo',
    success: function(result) {
        alert('yeap');
    },
    error: function(XMLHttpRequest, textStatus, errorThrown) {
        alert('oops, something bad happened');
    }
});

i aby zarejestrować globalną obsługę błędów, możesz użyć $.ajaxSetup()metody:

$.ajaxSetup({
    error: function(XMLHttpRequest, textStatus, errorThrown) {
        alert('oops, something bad happened');
    }
});

Innym sposobem jest użycie JSON. Możesz więc napisać niestandardowy filtr akcji na serwerze, który wyłapuje wyjątki i przekształca je w odpowiedź JSON:

public class MyErrorHandlerAttribute : FilterAttribute, IExceptionFilter
{
    public void OnException(ExceptionContext filterContext)
    {
        filterContext.ExceptionHandled = true;
        filterContext.Result = new JsonResult
        {
            Data = new { success = false, error = filterContext.Exception.ToString() },
            JsonRequestBehavior = JsonRequestBehavior.AllowGet
        };
    }
}

a następnie udekoruj akcję kontrolera tym atrybutem:

[MyErrorHandler]
public ActionResult Foo(string id)
{
    if (string.IsNullOrEmpty(id))
    {
        throw new Exception("oh no");
    }
    return Json(new { success = true });
}

i na koniec przywołaj to:

$.getJSON('/home/foo', { id: null }, function (result) {
    if (!result.success) {
        alert(result.error);
    } else {
        // handle the success
    }
});

Po googlowaniu piszę prostą obsługę wyjątków w oparciu o filtr akcji MVC:

public class HandleExceptionAttribute : HandleErrorAttribute
{
    public override void OnException(ExceptionContext filterContext)
    {
        if (filterContext.HttpContext.Request.IsAjaxRequest() && filterContext.Exception != null)
        {
            filterContext.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
            filterContext.Result = new JsonResult
            {
                JsonRequestBehavior = JsonRequestBehavior.AllowGet,
                Data = new
                {
                    filterContext.Exception.Message,
                    filterContext.Exception.StackTrace
                }
            };
            filterContext.ExceptionHandled = true;
        }
        else
        {
            base.OnException(filterContext);
        }
    }
}

i napisz w global.ascx:

 public static void RegisterGlobalFilters(GlobalFilterCollection filters)
 {
      filters.Add(new HandleExceptionAttribute());
 }

a następnie napisz ten skrypt na układzie lub stronie wzorcowej:

<script type="text/javascript">
      $(document).ajaxError(function (e, jqxhr, settings, exception) {
                       e.stopPropagation();
                       if (jqxhr != null)
                           alert(jqxhr.responseText);
                     });
</script>

Na koniec powinieneś włączyć niestandardowy błąd. a potem ciesz się tym :)

Niestety żadna z odpowiedzi nie jest dla mnie dobra. Zaskakujące jest to, że rozwiązanie jest znacznie prostsze. Zwrot ze sterownika:

return new HttpStatusCodeResult(HttpStatusCode.BadRequest, e.Response.ReasonPhrase);

I obsłuż to jako standardowy błąd HTTP na kliencie, jak chcesz.

Zrobiłem szybkie rozwiązanie, ponieważ nie miałem czasu i zadziałało dobrze. Chociaż myślę, że lepszą opcją jest użycie filtru wyjątków, być może moje rozwiązanie może pomóc w przypadku, gdy potrzebne jest proste rozwiązanie.

Zrobiłem co następuje. W metodzie kontrolera zwróciłem JsonResult z właściwością „Success” wewnątrz Data:

    [HttpPut]
    public JsonResult UpdateEmployeeConfig(EmployeConfig employeToSave) 
    {
        if (!ModelState.IsValid)
        {
            return new JsonResult
            {
                Data = new { ErrorMessage = "Model is not valid", Success = false },
                ContentEncoding = System.Text.Encoding.UTF8,
                JsonRequestBehavior = JsonRequestBehavior.DenyGet
            };
        }
        try
        {
            MyDbContext db = new MyDbContext();

            db.Entry(employeToSave).State = EntityState.Modified;
            db.SaveChanges();

            DTO.EmployeConfig user = (DTO.EmployeConfig)Session["EmployeLoggin"];

            if (employeToSave.Id == user.Id)
            {
                user.Company = employeToSave.Company;
                user.Language = employeToSave.Language;
                user.Money = employeToSave.Money;
                user.CostCenter = employeToSave.CostCenter;

                Session["EmployeLoggin"] = user;
            }
        }
        catch (Exception ex) 
        {
            return new JsonResult
            {
                Data = new { ErrorMessage = ex.Message, Success = false },
                ContentEncoding = System.Text.Encoding.UTF8,
                JsonRequestBehavior = JsonRequestBehavior.DenyGet
            };
        }

        return new JsonResult() { Data = new { Success = true }, };
    }

Później w wywołaniu Ajax właśnie poprosiłem o tę właściwość, aby wiedzieć, czy mam wyjątek:

$.ajax({
    url: 'UpdateEmployeeConfig',
    type: 'PUT',
    data: JSON.stringify(EmployeConfig),
    contentType: "application/json;charset=utf-8",
    success: function (data) {
        if (data.Success) {
            //This is for the example. Please do something prettier for the user, :)
            alert('All was really ok');                                           
        }
        else {
            alert('Oups.. we had errors: ' + data.ErrorMessage);
        }
    },
    error: function (request, status, error) {
       alert('oh, errors here. The call to the server is not working.')
    }
});

Mam nadzieję że to pomoże. Szczęśliwy kod! : P

Zgodnie z odpowiedzią aleho, oto kompletny przykład. Działa jak urok i jest super prosty.

Kod kontrolera

[HttpGet]
public async Task<ActionResult> ChildItems()
{
    var client = TranslationDataHttpClient.GetClient();
    HttpResponseMessage response = await client.GetAsync("childItems);

    if (response.IsSuccessStatusCode)
        {
            string content = response.Content.ReadAsStringAsync().Result;
            List<WorkflowItem> parameters = JsonConvert.DeserializeObject<List<WorkflowItem>>(content);
            return Json(content, JsonRequestBehavior.AllowGet);
        }
        else
        {
            return new HttpStatusCodeResult(response.StatusCode, response.ReasonPhrase);
        }
    }
}

Kod JavaScript w widoku

var url = '@Html.Raw(@Url.Action("ChildItems", "WorkflowItemModal")';

$.ajax({
    type: "GET",
    dataType: "json",
    url: url,
    contentType: "application/json; charset=utf-8",
    success: function (data) {
        // Do something with the returned data
    },
    error: function (xhr, status, error) {
        // Handle the error.
    }
});

Mam nadzieję, że to pomoże komuś innemu!

Aby obsługiwać błędy wywołane wywołaniami AJAX po stronie klienta, przypisujesz funkcję do erroropcji wywołania Ajax.

Aby ustawić wartość domyślną globalnie, możesz użyć funkcji opisanej tutaj: http://api.jquery.com/jQuery.ajaxSetup .