MVC3和WebApi错误处理

Question

I am editing an old project which is using MVC3. It has a Global.asax file which handles errors like this:

protected void Application_Error(object sender, EventArgs e)
{
    var currentController = " ";
    var currentAction = " ";
    var currentRouteData = RouteTable.Routes.GetRouteData(new HttpContextWrapper(Context));

    if (currentRouteData != null)
    {
        if (currentRouteData.Values["controller"] != null && !String.IsNullOrEmpty(currentRouteData.Values["controller"].ToString()))
            currentController = currentRouteData.Values["controller"].ToString();

        if (currentRouteData.Values["action"] != null && !String.IsNullOrEmpty(currentRouteData.Values["action"].ToString()))
            currentAction = currentRouteData.Values["action"].ToString();
    }

    var ex = Server.GetLastError();
    var controller = new ErrorController();
    var routeData = new RouteData();
    var action = "Index";

    var code = (ex is HttpException) ? (ex as HttpException).GetHttpCode() : 500;

    switch (code)
    {
        case 400:
            action = "BadRequest";
            break;
        case 401:
            action = "Unauthorized";
            break;
        case 403:
            action = "Forbidden";
            break;
        case 404:
            action = "NotFound";
            break;
        case 500:
            action = "InternalServerError";
            break;
        default:
            action = "Index";
            break;
    }

    Server.ClearError();
    Response.Clear();
    Response.StatusCode = code;
    Response.TrySkipIisCustomErrors = true;

    routeData.Values["controller"] = "Error";
    routeData.Values["action"] = action;

    controller.ViewData.Model = new HandleErrorInfo(ex, currentController, currentAction);
    ((IController)controller).Execute(new RequestContext(new HttpContextWrapper(Context), routeData));
}

This works fine when there is an error inside my MVC project. There is also a base class which makes calls to an external API like this:

/// <summary>
/// Used to make a Get request to a specified url
/// </summary>
/// <param name="url">The target url</param>
/// <returns>Returns a string</returns>
public async Task<string> MakeApiCall(string url)
{
    return await MakeApiCall(url, HttpMethod.GET, null);
}

/// <summary>
/// Used to make a Post request to a specified url
/// </summary>
/// <param name="url">The target url</param>
/// <param name="method">The Http method</param>
/// <param name="data">The object to send to the api</param>
/// <returns>Returns a string</returns>
public async Task<string> MakeApiCall(string url, HttpMethod method, object data)
{

    // Create our local variables
    var client = new HttpClient();
    var user = Session["AccessToken"];
    var authenticating = user == null;

    // If we are not authenticating, set our auth token
    if (!authenticating)
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Session["AccessToken"].ToString());

    // Check to see what HTTP method is being used
    switch (method)
    {
        case HttpMethod.POST:

            // If we are POSTing, then perform a post request
            return await PostRequest(client, url, data, authenticating);
        default:

            // If we are GETing, then perform a get request
            return await GetRequest(client, url);
    }
}

#region Helper methods

/// <summary>
/// Posts data to a specifed url
/// </summary>
/// <param name="client">The HttpClient used to make the api call</param>
/// <param name="url">The target url</param>
/// <param name="data">The object to send to the api</param>
/// <param name="authenticating">Used to set the content type when authenticating</param>
/// <returns>Returns a string</returns>
private async Task<string> PostRequest(HttpClient client, string url, object data, bool authenticating)
{

    // If the data is a string, then do a normal post, otherwise post as json
    var response = (data is string) ? await client.PostAsync(this.apiUrl + url, new StringContent(data.ToString())) : await client.PostAsJsonAsync(this.apiUrl + url, data);

    // If we are authenticating, set the content type header
    if (authenticating == true)
        response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");

    // Handle our response
    return await HandleResponse(response);
}

/// <summary>
/// Gets data from a specifed url
/// </summary>
/// <param name="client">The HttpClient used to make the api call</param>
/// <param name="url">The target url</param>
/// <returns>Returns a string</returns>
private async Task<string> GetRequest(HttpClient client, string url)
{

    // Perform the get request
    var response = await client.GetAsync(this.apiUrl + url);

    // Handle our response
    return await HandleResponse(response);
}

/// <summary>
/// Used to handle the api response
/// </summary>
/// <param name="response">The HttpResponseMessage</param>
/// <returns>Returns a string</returns>
private async Task<string> HandleResponse(HttpResponseMessage response)
{

    // Read our response content
    var result = await response.Content.ReadAsStringAsync();

    // If there was an error, throw an HttpException
    if (response.StatusCode != HttpStatusCode.OK)
        throw new HttpException((int)response.StatusCode, result);

    // Return our result if there are no errors
    return result;
}

#endregion

The issue I have with this approach is the HandleResponse method. When an API call is made, if the call fails it lands on this line:

// If there was an error, throw an HttpException
if (response.StatusCode != HttpStatusCode.OK)
    throw new HttpException((int)response.StatusCode, result);

which in turn is captured by the Application_Error method inside Global.asax . The problem with this, is that because this is an API call the controller can't redirect to the ErrorController ...

So my question is:

1. Can I somehow ignore the Global.asax error handling and just return JSON so that my JavaScript can decide what to do with the error OR
2. Is there a better way of doing this?

If you have any questions, please ask. I have tried to make sure the post is not just a wall of text.

Update 1

So, I have tried to use the AttributeFilter to help with this issue. I used 2 methods that 2 users suggested. First I created a custom Exception like this:

/// <summary>
/// Custom Api Exception
/// </summary>
public class ApiException : Exception
{

    /// <summary>
    /// Default constructor
    /// </summary>
    public ApiException()
    {
    }

    /// <summary>
    /// Constructor with message
    /// </summary>
    /// <param name="message">The error message as a string</param>
    public ApiException(string message)
        : base(message)
    {
    }

    /// <summary>
    /// Constructor with message and inner exception
    /// </summary>
    /// <param name="message">The error message as a string</param>
    /// <param name="inner">The inner exception</param>
    public ApiException(string message, Exception inner)
        : base(message, inner)
    {
    }
}

Then I updated my HandleResponse method in my base controller to look like this:

/// <summary>
/// Used to handle the api response
/// </summary>
/// <param name="response">The HttpResponseMessage</param>
/// <returns>Returns a string</returns>
private async Task<string> HandleResponse(HttpResponseMessage response)
{

    // Read our response content
    var result = await response.Content.ReadAsStringAsync();

    // If there was an error, throw an HttpException
    if (response.StatusCode != HttpStatusCode.OK)
        throw new ApiException(result);

    // Return our result if there are no errors
    return result;
}

Then I created a filter which I added to the FilterConfig which looked like this:

public class ExceptionAttribute : IExceptionFilter
{

    /// <summary>
    /// Handles any exception
    /// </summary>
    /// <param name="filterContext">The current context</param>
    public void OnException(ExceptionContext filterContext)
    {

        // If our exception has been handled, exit the function
        if (filterContext.ExceptionHandled)
            return;

        // If our exception is not an ApiException
        if (!(filterContext.Exception is ApiException))
        {

            // Set our base status code
            var statusCode = (int)HttpStatusCode.InternalServerError;

            // If our exception is an http exception
            if (filterContext.Exception is HttpException)
            {

                // Cast our exception as an HttpException
                var exception = (HttpException)filterContext.Exception;

                // Get our real status code
                statusCode = exception.GetHttpCode();
            }

            // Set our context result
            var result = CreateActionResult(filterContext, statusCode);

            // Set our handled property to true
            filterContext.ExceptionHandled = true;
        }
    }

    /// <summary>
    /// Creats an action result from the status code
    /// </summary>
    /// <param name="filterContext">The current context</param>
    /// <param name="statusCode">The status code of the error</param>
    /// <returns></returns>
    protected virtual ActionResult CreateActionResult(ExceptionContext filterContext, int statusCode)
    {

        // Create our context
        var context = new ControllerContext(filterContext.RequestContext, filterContext.Controller);
        var statusCodeName = ((HttpStatusCode)statusCode).ToString();

        // Create our route
        var controller = (string)filterContext.RouteData.Values["controller"];
        var action = (string)filterContext.RouteData.Values["action"];
        var model = new HandleErrorInfo(filterContext.Exception, controller, action);

        // Create our result
        var view = SelectFirstView(context, string.Format("~/Views/Error/{0}.cshtml", statusCodeName), "~/Views/Error/Index.cshtml", statusCodeName);
        var result = new ViewResult { ViewName = view, ViewData = new ViewDataDictionary<HandleErrorInfo>(model) };

        // Return our result
        return result;
    }

    /// <summary>
    /// Gets the first view name that matches the supplied names
    /// </summary>
    /// <param name="context">The current context</param>
    /// <param name="viewNames">A list of view names</param>
    /// <returns></returns>
    protected string SelectFirstView(ControllerContext context, params string[] viewNames)
    {
        return viewNames.First(view => ViewExists(context, view));
    }

    /// <summary>
    /// Checks to see if a view exists
    /// </summary>
    /// <param name="context">The current context</param>
    /// <param name="name">The name of the view to check</param>
    /// <returns></returns>
    protected bool ViewExists(ControllerContext context, string name)
    {
        var result = ViewEngines.Engines.FindView(context, name, null);

        return result.View != null;
    }
}

and finally I removed the logic from the Application_Error method in Global.asax hoping that that would work. But it didn't. I still get a document being returned when there is an ApiException.

Can anyone help me?

Answer 1

Can I somehow ignore the Global.asax error handling and just return JSON so that my JavaScript can decide what to do with the error

Since Global.asax is part of the ASP.NET pipeline, there is no native way to ignore it. You could resort to some hack maybe, but it would be better if you use the MVC and WebApi frameworks to solve the issue instead of relying antiquated ASP.NET behavior.

Is there a better way of doing this?

You can use Exception filters in both MVC and in WebApi . Each of these frameworks has their own separate configuration, which will allow you to keep the logic separate of each stack of exception filters.

Answer 2

If you like to accomplish what you are trying to do in minimum number of code then what you can do is instead of throwing an HttpException you can return a serialized JSON representing your exception in the form of string (since your method returns string) like following:

if (response.StatusCode != HttpStatusCode.OK)
    JsonConvert.SerializeObject("{ StatusCode : " + response.StatusCode.ToString() + "}");

Obviously, this is a hack and not recommended practice but it will not set of your Application_Error and you can also reply a JSON to your client code.

Better options would be to refactor your code to return HttpResponseMessage or use filter attributes, etc.