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 $.ajax() calls on the client side, calling static methods in the page code-behind decorated with [WebMethod] attributes.

If an unhandled exception occurs within the WebMethod, it does not fire the Application_Error 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 ArgumentException error response from JavaScriptObjectDeserializer 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()rn   at
System.Web.Script.Serialization.JavaScriptObjectDeserializer.DeserializeMemberName()rn   at
System.Web.Script.Serialization.JavaScriptObjectDeserializer.DeserializeDictionary(Int32 depth)rn   at 
System.Web.Script.Serialization.JavaScriptObjectDeserializer.DeserializeInternal(Int32 depth)rn   at 
System.Web.Script.Serialization.JavaScriptObjectDeserializer.BasicDeserialize(String input, Int32 depthLimit, JavaScriptSerializer serializer)rn   at 
System.Web.Script.Serialization.JavaScriptSerializer.Deserialize(JavaScriptSerializer serializer, String input, Type type, Int32 depthLimit)rn   at 
System.Web.Script.Serialization.JavaScriptSerializer.Deserialize[T](String input)rn   at 
System.Web.Script.Services.RestHandler.GetRawParamsFromPostRequest(HttpContext context, JavaScriptSerializer serializer)rn   at 
System.Web.Script.Services.RestHandler.GetRawParams(WebServiceMethodData methodData, HttpContext context)rn   at 
System.Web.Script.Services.RestHandler.ExecuteWebServiceCall(HttpContext context, WebServiceMethodData methodData)","ExceptionType":"System.ArgumentException"}

It’s still not firing the Application_Error 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?


Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

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);

Method 2

This article suggests that there are two ways to extend WebMethods of which the SoapExtension is the easier. This other one shows an example how to write a SoapExtension. It looks like the place where you can do message validation.

Method 3

When you say that you have static methods on the page code-behind marked with WebMethod and you say that you use $.ajax, that sounds just wrong. But I’ll give the benefit of the doubt, as I don’t know the particularities of you system.

Anyway, please test this:

  • You should have a ScriptManager on your page looking like this: (**1)
  • Then in that place where you have your $.ajax call, call you Page Method like this: (**2)


<asp:ScriptManager ID="smPageManager"

PageMethods.LeWebMethod("hero", 1024, function(response){
}, function(error){

Know using ASP.NET Ajax Library the proper way, give it a test, and see if the error reports back to you properly.

P.S: Sorry for the bookmark style notation, but SO, seems be experiencing some malfunction right now.


Reading this post, seems to explain the problem you are facing:

(…) If the request is for a class that implements System.Web.UI.Page and it is a rest method call, the WebServiceData class (that was explained in a previous post) is used to call the requested method from the Page. After the method has been called, the CompleteRequest method is called, bypassing all pipeline events and executing the EndRequest method. This allows MS AJAX to be able to call a method on a page instead of having to create a web service to call a method. (…)

Try to use the ASP.NET JavaScript Proxies, to check if you can capture the error using Microsoft Generated Code.

Method 4

These links might help you to handle the error on the client side,




then you could trigger a control event from client side to pass the error through the server and do the logging.

Method 5

Here is a solution that replaces the internal RestHandler implementation with my own version. You can log the exception in the WriteExceptionJsonString method. This uses an answer provided on Dynamically replace the contents of a C# method? to swap out the method. I’ve confirmed it works for me if I add a call to ReplaceRestHandler in my Global.asax Application_Start method. Haven’t run this very long or in production so use at your own risk.

using System;
using System.Collections.Specialized;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Web;
using Newtonsoft.Json;

namespace Royal.Common.WebStuff
    public static class RestHandlerUtils
        internal static void WriteExceptionJsonString(HttpContext context, Exception ex, int statusCode)
            string charset = context.Response.Charset;
            context.Response.StatusCode = statusCode;
            context.Response.StatusDescription = HttpWorkerRequest.GetStatusDescription(statusCode);
            context.Response.ContentType = "application/json";
            context.Response.AddHeader("jsonerror", "true");
            context.Response.Charset = charset;
            context.Response.TrySkipIisCustomErrors = true;
            using (StreamWriter streamWriter = new StreamWriter(context.Response.OutputStream, new UTF8Encoding(false)))
                if (ex is TargetInvocationException)
                    ex = ex.InnerException;
                var error = new OrderedDictionary();
                error["Message"] = ex.Message;
                error["StackTrace"] = ex.StackTrace;
                error["ExceptionType"] = ex.GetType().FullName;

        public static void ReplaceRestHandler()
            var methodToInject = typeof(RestHandlerUtils).GetMethod("WriteExceptionJsonString",
                BindingFlags.NonPublic | BindingFlags.Static);
            var asm = typeof(System.Web.Script.Services.ScriptMethodAttribute).Assembly;
            var rhtype = asm.GetType("System.Web.Script.Services.RestHandler");
            var methodToReplace = rhtype
                .GetMethod("WriteExceptionJsonString", BindingFlags.NonPublic | BindingFlags.Static, null,
                    new Type[] {typeof(HttpContext), typeof(Exception), typeof(int)}, null);


                if (IntPtr.Size == 4)
                    int* inj = (int*) methodToInject.MethodHandle.Value.ToPointer() + 2;
                    int* tar = (int*) methodToReplace.MethodHandle.Value.ToPointer() + 2;
                    *tar = *inj;
                    long* inj = (long*) methodToInject.MethodHandle.Value.ToPointer() + 1;
                    long* tar = (long*) methodToReplace.MethodHandle.Value.ToPointer() + 1;
                    *tar = *inj;

Method 6

@MichaelLiu’s answer is great but breaks in classic mode (works in integrated mode). This is because of _response.Headers["jsonerror"] which is not supported in classic mode. I left that check off and still seems to work fine for me since all status 501 should be errors anyway. Can’t think of a scenario where that extra check is needed.

All methods was sourced from or, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

0 0 votes
Article Rating
Notify of

Inline Feedbacks
View all comments
Would love your thoughts, please comment.x