返回带有错误状态代码 MVC 的 JSON

Question

我试图按照此链接中的建议向控制器的调用返回错误，以便客户端可以采取适当的操作。 控制器由 javascript 通过 jquery AJAX 调用。 只有当我没有将状态设置为错误时，我才会返回 Json 对象。 这是示例代码

if (response.errors.Length > 0)
   Response.StatusCode = (int)HttpStatusCode.BadRequest;
return Json(response);

如果我不设置状态码，我会得到 Json。 如果我设置状态代码，我会返回状态代码，但不会返回 Json 错误对象。

更新我想将一个 Error 对象作为 JSON 发送，以便它可以处理 ajax 的错误回调。

Answer 1

我在这里找到了解决方案

我必须创建一个动作过滤器来覆盖 MVC 的默认行为

这是我的异常类

class ValidationException : ApplicationException
{
    public JsonResult exceptionDetails;
    public ValidationException(JsonResult exceptionDetails)
    {
        this.exceptionDetails = exceptionDetails;
    }
    public ValidationException(string message) : base(message) { }
    public ValidationException(string message, Exception inner) : base(message, inner) { }
    protected ValidationException(
    System.Runtime.Serialization.SerializationInfo info,
    System.Runtime.Serialization.StreamingContext context)
        : base(info, context) { }
}

请注意，我有初始化我的 JSON 的构造函数。 这是动作过滤器

public class HandleUIExceptionAttribute : FilterAttribute, IExceptionFilter
{
    public virtual void OnException(ExceptionContext filterContext)
    {
        if (filterContext == null)
        {
            throw new ArgumentNullException("filterContext");
        }
        if (filterContext.Exception != null)
        {
            filterContext.ExceptionHandled = true;
            filterContext.HttpContext.Response.Clear();
            filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
            filterContext.HttpContext.Response.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
            filterContext.Result = ((ValidationException)filterContext.Exception).myJsonError;
        }
    }

现在我有了动作过滤器，我将用过滤器属性装饰我的控制器

[HandleUIException]
public JsonResult UpdateName(string objectToUpdate)
{
   var response = myClient.ValidateObject(objectToUpdate);
   if (response.errors.Length > 0)
     throw new ValidationException(Json(response));
}

当错误被抛出时，实现 IExceptionFilter 的动作过滤器被调用，我在错误回调的客户端上取回 Json。

Answer 2

我发现的最简洁的解决方案是创建您自己的 JsonResult，它扩展了原始实现并允许您指定一个 HttpStatusCode：

public class JsonHttpStatusResult : JsonResult
{
    private readonly HttpStatusCode _httpStatus;

    public JsonHttpStatusResult(object data, HttpStatusCode httpStatus)
    {
        Data = data;
        _httpStatus = httpStatus;
    }

    public override void ExecuteResult(ControllerContext context)
    {
        context.RequestContext.HttpContext.Response.StatusCode = (int)_httpStatus;
        base.ExecuteResult(context);
    }
}

然后，您可以在控制器操作中使用它，如下所示：

if(thereWereErrors)
{
    var errorModel = new { error = "There was an error" };
    return new JsonHttpStatusResult(errorModel, HttpStatusCode.InternalServerError);
}

Answer 3

这个问题有一个非常优雅的解决方案，只需通过 web.config 配置您的站点：

<system.webServer>
    <httpErrors errorMode="DetailedLocalOnly" existingResponse="PassThrough"/>
</system.webServer>

来源： https : //serverfault.com/questions/123729/iis-is-overriding-my-response-content-if-i-manually-set-the-response-statuscode

Answer 4

基于 Richard Garside 的回答，这里是 ASP.Net Core 版本

public class JsonErrorResult : JsonResult
{
    private readonly HttpStatusCode _statusCode;

    public JsonErrorResult(object json) : this(json, HttpStatusCode.InternalServerError)
    {
    }

    public JsonErrorResult(object json, HttpStatusCode statusCode) : base(json)
    {
        _statusCode = statusCode;
    }

    public override void ExecuteResult(ActionContext context)
    {
        context.HttpContext.Response.StatusCode = (int)_statusCode;
        base.ExecuteResult(context);
    }

    public override Task ExecuteResultAsync(ActionContext context)
    {
        context.HttpContext.Response.StatusCode = (int)_statusCode;
        return base.ExecuteResultAsync(context);
    }
}

然后在您的控制器中，返回如下：

// Set a json object to return. The status code defaults to 500
return new JsonErrorResult(new { message = "Sorry, an internal error occurred."});

// Or you can override the status code
return new JsonErrorResult(new { foo = "bar"}, HttpStatusCode.NotFound);

Answer 5

一种向 Json 发送错误的简单方法是控制响应对象的 Http 状态码并设置自定义错误消息。

控制器

public JsonResult Create(MyObject myObject) 
{
  //AllFine
  return Json(new { IsCreated = True, Content = ViewGenerator(myObject));

  //Use input may be wrong but nothing crashed
  return Json(new { IsCreated = False, Content = ViewGenerator(myObject));  

  //Error
  Response.StatusCode = (int)HttpStatusCode.InternalServerError;
  return Json(new { IsCreated = false, ErrorMessage = 'My error message');
}

JS

$.ajax({
     type: "POST",
     dataType: "json",
     url: "MyController/Create",
     data: JSON.stringify(myObject),
     success: function (result) {
       if(result.IsCreated)
     {
    //... ALL FINE
     }
     else
     {
    //... Use input may be wrong but nothing crashed
     }
   },
    error: function (error) {
            alert("Error:" + erro.responseJSON.ErrorMessage ); //Error
        }
  });

Answer 6

设置 StatusCode 后，您必须自己返回 JSON 错误对象，就像这样......

if (BadRequest)
{
    Dictionary<string, object> error = new Dictionary<string, object>();
    error.Add("ErrorCode", -1);
    error.Add("ErrorMessage", "Something really bad happened");
    return Json(error);
}

另一种方法是拥有一个JsonErrorModel并填充它

public class JsonErrorModel
{
    public int ErrorCode { get; set;}

    public string ErrorMessage { get; set; }
}

public ActionResult SomeMethod()
{

    if (BadRequest)
    {
        var error = new JsonErrorModel
        {
            ErrorCode = -1,
            ErrorMessage = "Something really bad happened"
        };

        return Json(error);
    }

   //Return valid response
}

看看这里的答案

Answer 7

对我有用的东西（我从另一个 stackoverflow 响应中获取的）是设置标志：

Response.TrySkipIisCustomErrors = true;

Answer 8

您需要决定是否需要“HTTP 级别错误”（错误代码用于什么）或“应用程序级别错误”（您的自定义 JSON 响应用于什么）。

如果错误代码设置为非 2xx（成功范围），大多数使用 HTTP 的高级对象永远不会查看响应流。 在您的情况下，您明确将错误代码设置为失败（我认为是 403 或 500）并强制 XMLHttp 对象忽略响应正文。

修复 - 在客户端处理错误条件或不设置错误代码并返回带有错误信息的 JSON（有关详细信息，请参阅 Sbossb 回复）。

Answer 9

如果您的需求不像 Sarath 的那么复杂，您可以使用更简单的方法：

[MyError]
public JsonResult Error(string objectToUpdate)
{
   throw new Exception("ERROR!");
}

public class MyErrorAttribute : FilterAttribute, IExceptionFilter
{
   public virtual void OnException(ExceptionContext filterContext)
   {
      if (filterContext == null)
      {
         throw new ArgumentNullException("filterContext");
      }
      if (filterContext.Exception != null)
      {
         filterContext.ExceptionHandled = true;
         filterContext.HttpContext.Response.Clear();
         filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
         filterContext.HttpContext.Response.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
         filterContext.Result = new JsonResult() { Data = filterContext.Exception.Message };
      }
   }
}

Answer 10

一些响应依赖于抛出的异常并在 OnException 覆盖中处理它。 就我而言，如果用户传入了错误的 ID，我想返回错误请求等状态。 对我有用的是使用 ControllerContext：

var jsonResult = new JsonResult { JsonRequestBehavior = JsonRequestBehavior.AllowGet, Data = "whoops" };

ControllerContext.HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;

return jsonResult;

Answer 11

我正在运行 Asp.Net Web Api 5.2.7，看起来 JsonResult 类已更改为使用泛型和异步执行方法。 我最终改变了理查德加赛德的解决方案：

public class JsonHttpStatusResult<T> : JsonResult<T>
{
    private readonly HttpStatusCode _httpStatus;

    public JsonHttpStatusResult(T content, JsonSerializerSettings serializer, Encoding encoding, ApiController controller, HttpStatusCode httpStatus) 
    : base(content, serializer, encoding, controller)
    {
        _httpStatus = httpStatus;
    }

    public override Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        var returnTask = base.ExecuteAsync(cancellationToken);
        returnTask.Result.StatusCode = HttpStatusCode.BadRequest;
        return returnTask;
    }
}

按照理查德的例子，你可以像这样使用这个类：

if(thereWereErrors)
{
    var errorModel = new CustomErrorModel("There was an error");
    return new JsonHttpStatusResult<CustomErrorModel>(errorModel, new JsonSerializerSettings(), new UTF8Encoding(), this, HttpStatusCode.InternalServerError);
}

不幸的是，您不能对内容使用匿名类型，因为您需要将具体类型（例如： CustomErrorType ）传递给JsonHttpStatusResult初始值设定项。 如果您想使用匿名类型，或者你只是想成为真正的华而不实，您可以通过继承建立在这种解决方案ApiController到添加HttpStatusCode参数去的Json方法:)

public abstract class MyApiController : ApiController
{
    protected internal virtual JsonHttpStatusResult<T> Json<T>(T content, HttpStatusCode httpStatus, JsonSerializerSettings serializerSettings, Encoding encoding)
    {
        return new JsonHttpStatusResult<T>(content, httpStatus, serializerSettings, encoding, this);
    }

    protected internal JsonHttpStatusResult<T> Json<T>(T content, HttpStatusCode httpStatus, JsonSerializerSettings serializerSettings)
    {
        return Json(content, httpStatus, serializerSettings, new UTF8Encoding());
    }

    protected internal JsonHttpStatusResult<T> Json<T>(T content, HttpStatusCode httpStatus)
    {
        return Json(content, httpStatus, new JsonSerializerSettings());
    }
}

然后你可以像这样使用匿名类型：

if(thereWereErrors)
{
    var errorModel = new { error = "There was an error" };
    return Json(errorModel, HttpStatusCode.InternalServerError);
}

Answer 12

如果您只是使用 MVC，最简单的方法是使用 HttpStatusCodeResult。

public ActionResult MyAjaxRequest(string args)
    {
        string error_message = string.Empty;
        try
        {
            // successful
            return Json(args);
        }
        catch (Exception e)
        {
            error_message = e.Message;
        }

        return new HttpStatusCodeResult(500, error_message);
    }

当错误返回给客户端时，您可以按照自己的喜好显示或操作。

request.fail(function (jqXHR) {
        if (jqXHR.status == 500) {
            alert(jqXHR.statusText);
        }
    })

Answer 13

这是 ASP.NET v5+ 的 JsonResult 覆盖答案。 我已经测试过，它的工作原理与早期版本一样好。

public class JsonHttpStatusResult : JsonResult
{
    private readonly HttpStatusCode _httpStatus;

    public JsonHttpStatusResult(object data, HttpStatusCode httpStatus) : base(data)
    {
        _httpStatus = httpStatus;
    }

    public override Task ExecuteResultAsync(ActionContext context)
    {
        context.HttpContext.Response.StatusCode = (int)_httpStatus;
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        var services = context.HttpContext.RequestServices;
        var executor = services.GetRequiredService<IActionResultExecutor<JsonResult>>();
        return executor.ExecuteAsync(context, this);
    }
}