Click here to Skip to main content
Click here to Skip to main content

Handling Larger JSON String Values in .NET and Avoiding Exceptions

By , 13 May 2013
Rate this:
Please Sign up or sign in to vote.

Working with JSON within Web Services recently has become the latest and greatest simply because it plays so nicely with others and can often be very easily serialized and de-serialized to fit your needs (plus AJAX and it are basically BFFs).

There is just something rewarding about having a massive collection of complex objects that can be throw into a simple string and passed across however you see fit and then completely regenerated in its original collection in just a handful of code.

However sometimes these strings can get big and I mean really big, like exceeding default values big and when this happens, exceptions happen. This post will cover a few ways that you can prevent nasty InvalidOperationExceptions that may look something like this with ease :

JsonMaxLength Error

You may encounter this error when attempt to pass large JSON Objects around.

The Problem

You decide that paging data is for losers (it’s not) and decide to pull a graph of all of the data within your database, which will hypothetically contains thousands of complex objects, each with additional properties of their own (basically a ton of data). If your dataset is large enough (which it is) you’ll find yourself quickly exceeding the bounds that your Serializer can handle and you’ll be met with an exception and no data.

The Solution

There are three basic methods of handling this depending on your current environment :

  1. Setting the MaxJsonLength property default value within your web.config. (This will only apply to web-services that handle JSON)
  2. Setting the MaxJsonLength property of a JavascriptSerializer object to perform your serialization.
  3. If you are using MVC4 to handle returning your JSON values, you may want to override the default JsonResult() ActionResult and change the maximum size manually.

Either of these changes will help you avoid any bumps in the road when passing across your large JSON values.

Option I: The MaxJsonLength Property for handling JSON in Web Services

The MaxJsonLength property which can be set within the web.config of your application controls the maximum size of the JSON strings that are accepted by the JsonSerializer class. The default value is  102400 characters.

In order to increase the size of this value – you can just add the following code to your web.config file and set it to the value that you desire :

<configuration> 
   <system.web.extensions>
       <scripting>
           <webServices>
               <!-- Update this value to change the value to a larger value 
                        that can accommodate your JSON Strings -->
               <jsonSerialization maxJsonLength="86753090" />
           </webServices>
       </scripting>
   </system.web.extensions>
</configuration> 

It is important to know that this setting within the web.config will only apply to actual Web Services that handle your JSON strings using the internal JsonSerializer. If you are still encountering issues after applying this change, you will likely want to continue reading and consider using an instance of the JsonSerializer class to handle setting this value.

Option II: Using the JavaScriptSerialzier and the MaxJsonLength Property to Handle Serializing JSON Values

Using an instance of a JavascriptSerializer will not actually inherit the previously defined within the web.config (as the web.config only applies to Web Services that handle the JSON) so you can easily just create an instance of the serializer and set the property accordingly :

//Creates an instance of your JavaScriptSerializer and Setting the MaxJsonLength
var serializer = new JavaScriptSerializer() { MaxJsonLength = 86753090 };

//Perform your serialization
serializer.Serialize("Your JSON Contents");

This will allow you to easily your larger data and adjust your maximum size easily.

Option III: Overiding the MVC4 JsonResult Action Result to Handle the Maximum Size

Much like the previously examples,  every time that you are going to return a JsonResult you can simply add the MaxJsonLength property to a specific value depending on the context of your specific action :

return new JsonResult() { Data = "Your Data", MaxJsonLength = 86753090 };

or using the Json() method :

JsonResult result = Json("Your Data");
result.MaxJsonLength = 8675309;

However, if you want a more widespread solution that you could use within a single area of your application, you may want to consider overriding the JsonResult class and set your value within this newer class :

//This ActionResult will override the existing JsonResult and will automatically set the 
protected override JsonResult Json(object data, string contentType, 
          System.Text.Encoding contentEncoding, JsonRequestBehavior behavior)
{
    return new JsonResult()
    {
        Data = data,
        ContentType = contentType,
        ContentEncoding = contentEncoding,
        JsonRequestBehavior = behavior,
        MaxJsonLength = Int32.MaxValue
        //Use this value to set your maximum size for all of your Requests
    };
}

From a JSON to a JMAN

Those are a just a few methods that you should be able to use if you ever encounter an issue when passing larger JSON strings across your Controllers or through the use of Web Services. I am sure that there are likely several other ways to handle these same problems, but hopefully one of these will help you out if you are in a tight spot.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

Rion Williams
Software Developer (Senior)
United States United States
An experienced Software Developer and Graphic Designer with an extensive knowledge of object-oriented programming, software architecture, design methodologies and database design principles. Specializing in Microsoft Technologies and focused on leveraging a strong technical background and a creative skill-set to create meaningful and successful applications.
 
Well versed in all aspects of the software development life-cycle and passionate about embracing emerging development technologies and standards, building intuitive interfaces and providing clean, maintainable solutions for even the most complex of problems.
Follow on   Twitter

Comments and Discussions

 
-- There are no messages in this forum --
| Advertise | Privacy | Mobile
Web01 | 2.8.140415.2 | Last Updated 13 May 2013
Article Copyright 2013 by Rion Williams
Everything else Copyright © CodeProject, 1999-2014
Terms of Use
Layout: fixed | fluid