Carson63000 Carson63000 - 4 months ago 23x
Ajax Question

Catching errors from calling ASP.NET WebMethod with malformed Json

We have an older ASP.NET WebForms application which performs AJAX request by using jQuery

calls on the client side, calling static methods in the page code-behind decorated with

If an unhandled exception occurs within the WebMethod, it does not fire the
event and is thus not picked up by our error logger (ELMAH). This is well known and not a problem - we have all WebMethod code wrapped in try-catch blocks with exceptions being manually logged to ELMAH.

However, there is one case that has me stumped. If malformed Json is posted to the WebMethod URL, it throws an exception before entering our code, and I can't find any way to trap this.

e.g. this WebMethod signature

public static string LeWebMethod(string stringParam, int intParam)

Normally called with a Json payload like:

{"stringParam":"oh hai","intParam":37}

I tried a test using Fiddler to edit the payload to the malformed Json:

{"stringParam":"oh hai","intPara

And got the following
error response from
sent to the client (this is in a simple test app running locally with no custom errors):

{"Message":"Unterminated string passed in. (32): {\"stringParam\":\"oh hai\",\"intPara","StackTrace":" at
System.Web.Script.Serialization.JavaScriptObjectDeserializer.DeserializeString()\r\n at
System.Web.Script.Serialization.JavaScriptObjectDeserializer.DeserializeMemberName()\r\n at
System.Web.Script.Serialization.JavaScriptObjectDeserializer.DeserializeDictionary(Int32 depth)\r\n at
System.Web.Script.Serialization.JavaScriptObjectDeserializer.DeserializeInternal(Int32 depth)\r\n at
System.Web.Script.Serialization.JavaScriptObjectDeserializer.BasicDeserialize(String input, Int32 depthLimit, JavaScriptSerializer serializer)\r\n at
System.Web.Script.Serialization.JavaScriptSerializer.Deserialize(JavaScriptSerializer serializer, String input, Type type, Int32 depthLimit)\r\n at
System.Web.Script.Serialization.JavaScriptSerializer.Deserialize[T](String input)\r\n at
System.Web.Script.Services.RestHandler.GetRawParamsFromPostRequest(HttpContext context, JavaScriptSerializer serializer)\r\n at
System.Web.Script.Services.RestHandler.GetRawParams(WebServiceMethodData methodData, HttpContext context)\r\n at
System.Web.Script.Services.RestHandler.ExecuteWebServiceCall(HttpContext context, WebServiceMethodData methodData)","ExceptionType":"System.ArgumentException"}

It's still not firing the
event, and it never enters our code so we can't log the error ourselves.

I found a similar question which got a pointer to the blog post "How to create a global exception handler for a Web Service" but that appears to only be valid for SOAP webservices, not AJAX GETs/POSTs.

Is there some similar way to attach a custom handler in my situation?


According to the reference source, the internal RestHandler.ExecuteWebServiceCall method catches all exceptions thrown by GetRawParams and simply writes them to the response stream, which is why Application_Error isn't invoked:

internal static void ExecuteWebServiceCall(HttpContext context, WebServiceMethodData methodData) {
    try {
        IDictionary<string, object> rawParams = GetRawParams(methodData, context);
        InvokeMethod(context, methodData, rawParams);
    catch (Exception ex) {
        WriteExceptionJsonString(context, ex);

The only workaround I can think of is to create an output filter that intercepts and logs the output:

public class PageMethodExceptionLogger : Stream
    private readonly HttpResponse _response;
    private readonly Stream _baseStream;
    private readonly MemoryStream _capturedStream = new MemoryStream();

    public PageMethodExceptionLogger(HttpResponse response)
        _response = response;
        _baseStream = response.Filter;

    public override void Close()
        if (_response.StatusCode == 500 && _response.Headers["jsonerror"] == "true")
            _capturedStream.Position = 0;
            string responseJson = new StreamReader(_capturedStream).ReadToEnd();
            // TODO: Do the actual logging.


    public override void Flush()

    public override long Seek(long offset, SeekOrigin origin)
        return _baseStream.Seek(offset, origin);

    public override void SetLength(long value)

    public override int Read(byte[] buffer, int offset, int count)
        return _baseStream.Read(buffer, offset, count);

    public override void Write(byte[] buffer, int offset, int count)
        _baseStream.Write(buffer, offset, count);
        _capturedStream.Write(buffer, offset, count);

    public override bool CanRead { get { return _baseStream.CanRead; } }
    public override bool CanSeek { get { return _baseStream.CanSeek; } }
    public override bool CanWrite { get { return _baseStream.CanWrite; } }
    public override long Length { get { return _baseStream.Length; } }

    public override long Position
        get { return _baseStream.Position; }
        set { _baseStream.Position = value; }

In Global.asax.cs (or in an HTTP module), install the filter in Application_PostMapRequestHandler:

protected void Application_PostMapRequestHandler(object sender, EventArgs e)
    HttpContext context = HttpContext.Current;
    if (context.Handler is Page && !string.IsNullOrEmpty(context.Request.PathInfo))
        string contentType = context.Request.ContentType.Split(';')[0];
        if (contentType.Equals("application/json", StringComparison.OrdinalIgnoreCase))
            context.Response.Filter = new PageMethodExceptionLogger(context.Response);