Cfrgtkky

If you are using MVC 4, be sure to check out this answer as well.

If you are still receiving the error:

• after setting the maxJsonLength property to its maximum value in web.config


• and you know that your data's length is less than this value


• and you are not utilizing a web service method for the JavaScript serialization

your problem is is likely that:

The value of the MaxJsonLength property applies only to the internal JavaScriptSerializer instance that is used by the asynchronous communication layer to invoke Web services methods. (MSDN: ScriptingJsonSerializationSection.MaxJsonLength Property)

Basically, the "internal" JavaScriptSerializer respects the value of maxJsonLength when called from a web method; direct use of a JavaScriptSerializer (or use via an MVC action-method/Controller) does not respect the maxJsonLength property, at least not from the systemWebExtensions.scripting.webServices.jsonSerialization section of web.config.

As a workaround, you can do the following within your Controller (or anywhere really):

var serializer = new JavaScriptSerializer();



// For simplicity just use Int32's max value.

// You could always read the value from the config section mentioned above.

serializer.MaxJsonLength = Int32.MaxValue;



var resultData = new { Value = "foo", Text = "var" };

var result = new ContentResult{

    Content = serializer.Serialize(resultData),

    ContentType = "application/json"

};

return result;

This answer is my interpretation of this asp.net forum answer.

In MVC 4 you can do:

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

    };

}

in your controller.

Addition:

For anyone puzzled by the parameters you need to specify, a call could look like this:

Json(

    new {

        field1 = true,

        field2 = "value"

        },

    "application/json",

    Encoding.UTF8,

    JsonRequestBehavior.AllowGet

);

You can configure the max length for json requests in your web.config file:

<configuration>

    <system.web.extensions>

        <scripting>

            <webServices>

                <jsonSerialization maxJsonLength="....">

                </jsonSerialization>

            </webServices>

        </scripting>

    </system.web.extensions>

</configuration>

The default value for maxJsonLength is 102400. For more details, see this MSDN page: http://msdn.microsoft.com/en-us/library/bb763183.aspx

I was having this problem in ASP.NET Web Forms. It was completely ignoring the web.config file settings so I did this:

        JavaScriptSerializer serializer = new JavaScriptSerializer();



        serializer.MaxJsonLength = Int32.MaxValue; 



        return serializer.Serialize(response);

Of course overall this is terrible practice. If you are sending this much data in a web service call you should look at a different approach.

if you are still getting error after web.config setting like following:

<configuration> 

   <system.web.extensions>

       <scripting>

           <webServices>

               <jsonSerialization maxJsonLength="50000000"/>

           </webServices>

       </scripting>

   </system.web.extensions>

</configuration> 

I solved it by following:

   public ActionResult/JsonResult getData()

   {

      var jsonResult = Json(superlargedata, JsonRequestBehavior.AllowGet);

      jsonResult.MaxJsonLength = int.MaxValue;

      return jsonResult;

    }

I hope this should help.

I fixed it.

//your Json data here

string json_object="........";

JavaScriptSerializer jsJson = new JavaScriptSerializer();

jsJson.MaxJsonLength = 2147483644;

MyClass obj = jsJson.Deserialize<MyClass>(json_object);

It works very well.

if, after implementing the above addition into your web.config, you get an “Unrecognized configuration section system.web.extensions.” error then try adding this to your web.config in the <ConfigSections> section:

            <sectionGroup name="system.web.extensions" type="System.Web.Extensions">

              <sectionGroup name="scripting" type="System.Web.Extensions">

                    <sectionGroup name="webServices" type="System.Web.Extensions">

                          <section name="jsonSerialization" type="System.Web.Extensions"/>

                    </sectionGroup>

              </sectionGroup>

        </sectionGroup>

I followed vestigal's answer and got to this solution:

When I needed to post a large json to an action in a controller, I would get the famous "Error during deserialization using the JSON JavaScriptSerializer. The length of the string exceeds the value set on the maxJsonLength property.rnParameter name: input value provider".

What I did is create a new ValueProviderFactory, LargeJsonValueProviderFactory, and set the MaxJsonLength = Int32.MaxValue in the GetDeserializedObject method

public sealed class LargeJsonValueProviderFactory : ValueProviderFactory

{

private static void AddToBackingStore(LargeJsonValueProviderFactory.EntryLimitedDictionary backingStore, string prefix, object value)

{

    IDictionary<string, object> dictionary = value as IDictionary<string, object>;

    if (dictionary != null)

    {

        foreach (KeyValuePair<string, object> keyValuePair in (IEnumerable<KeyValuePair<string, object>>) dictionary)

            LargeJsonValueProviderFactory.AddToBackingStore(backingStore, LargeJsonValueProviderFactory.MakePropertyKey(prefix, keyValuePair.Key), keyValuePair.Value);

    }

    else

    {

        IList list = value as IList;

        if (list != null)

        {

            for (int index = 0; index < list.Count; ++index)

                LargeJsonValueProviderFactory.AddToBackingStore(backingStore, LargeJsonValueProviderFactory.MakeArrayKey(prefix, index), list[index]);

        }

        else

            backingStore.Add(prefix, value);

    }

}



private static object GetDeserializedObject(ControllerContext controllerContext)

{

    if (!controllerContext.HttpContext.Request.ContentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase))

        return (object) null;

    string end = new StreamReader(controllerContext.HttpContext.Request.InputStream).ReadToEnd();

    if (string.IsNullOrEmpty(end))

        return (object) null;



    var serializer = new JavaScriptSerializer {MaxJsonLength = Int32.MaxValue};



    return serializer.DeserializeObject(end);

}



/// <summary>Returns a JSON value-provider object for the specified controller context.</summary>

/// <returns>A JSON value-provider object for the specified controller context.</returns>

/// <param name="controllerContext">The controller context.</param>

public override IValueProvider GetValueProvider(ControllerContext controllerContext)

{

    if (controllerContext == null)

        throw new ArgumentNullException("controllerContext");

    object deserializedObject = LargeJsonValueProviderFactory.GetDeserializedObject(controllerContext);

    if (deserializedObject == null)

        return (IValueProvider) null;

    Dictionary<string, object> dictionary = new Dictionary<string, object>((IEqualityComparer<string>) StringComparer.OrdinalIgnoreCase);

    LargeJsonValueProviderFactory.AddToBackingStore(new LargeJsonValueProviderFactory.EntryLimitedDictionary((IDictionary<string, object>) dictionary), string.Empty, deserializedObject);

    return (IValueProvider) new DictionaryValueProvider<object>((IDictionary<string, object>) dictionary, CultureInfo.CurrentCulture);

}



private static string MakeArrayKey(string prefix, int index)

{

    return prefix + "[" + index.ToString((IFormatProvider) CultureInfo.InvariantCulture) + "]";

}



private static string MakePropertyKey(string prefix, string propertyName)

{

    if (!string.IsNullOrEmpty(prefix))

        return prefix + "." + propertyName;

    return propertyName;

}



private class EntryLimitedDictionary

{

    private static int _maximumDepth = LargeJsonValueProviderFactory.EntryLimitedDictionary.GetMaximumDepth();

    private readonly IDictionary<string, object> _innerDictionary;

    private int _itemCount;



    public EntryLimitedDictionary(IDictionary<string, object> innerDictionary)

    {

        this._innerDictionary = innerDictionary;

    }



    public void Add(string key, object value)

    {

        if (++this._itemCount > LargeJsonValueProviderFactory.EntryLimitedDictionary._maximumDepth)

            throw new InvalidOperationException("JsonValueProviderFactory_RequestTooLarge");

        this._innerDictionary.Add(key, value);

    }



    private static int GetMaximumDepth()

    {

        NameValueCollection appSettings = ConfigurationManager.AppSettings;

        if (appSettings != null)

        {

            string values = appSettings.GetValues("aspnet:MaxJsonDeserializerMembers");

            int result;

            if (values != null && values.Length > 0 && int.TryParse(values[0], out result))

                return result;

        }

        return 1000;

    }

}

}

Then, in the Application_Start method from Global.asax.cs, replace the ValueProviderFactory with the new one:

protected void Application_Start()

{

    ...



    //Add LargeJsonValueProviderFactory

    ValueProviderFactory jsonFactory = null;

    foreach (var factory in ValueProviderFactories.Factories)

    {

        if (factory.GetType().FullName == "System.Web.Mvc.JsonValueProviderFactory")

        {

            jsonFactory = factory;

            break;

        }

    }



    if (jsonFactory != null)

    {

        ValueProviderFactories.Factories.Remove(jsonFactory);

    }



    var largeJsonValueProviderFactory = new LargeJsonValueProviderFactory();

    ValueProviderFactories.Factories.Add(largeJsonValueProviderFactory);

}

you can write this line into Controller

json.MaxJsonLength = 2147483644;

you can also write this line into web.config

<configuration>

  <system.web.extensions>

    <scripting>

        <webServices>

            <jsonSerialization maxJsonLength="2147483647">

            </jsonSerialization>

        </webServices>

    </scripting>

  </system.web.extensions>

`

To be on the safe side, use both.

If you are getting this error from the MiniProfiler in MVC then you can increase the value by setting the property MiniProfiler.Settings.MaxJsonResponseSize to the desired value. By default, this tool seems to ignore the value set in config.

MiniProfiler.Settings.MaxJsonResponseSize = 104857600;

Courtesy mvc-mini-profiler.

Simply set MaxJsonLength proprty in MVC's Action method

JsonResult json= Json(classObject, JsonRequestBehavior.AllowGet);

json.MaxJsonLength = int.MaxValue;

return json;

I suggest setting it to Int32.MaxValue.

JavaScriptSerializer serializer = new JavaScriptSerializer();

serializer.MaxJsonLength = Int32.MaxValue;

How about some attribute magic?

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]

public class MaxJsonSizeAttribute : ActionFilterAttribute

{

    // Default: 10 MB worth of one byte chars

    private int maxLength = 10 * 1024 * 1024;



    public int MaxLength

    {

        set

        {

            if (value < 0) throw new ArgumentOutOfRangeException("value", "Value must be at least 0.");



            maxLength = value;

        }

        get { return maxLength; }

    }



    public override void OnActionExecuted(ActionExecutedContext filterContext)

    {

        JsonResult json = filterContext.Result as JsonResult;

        if (json != null)

        {

            if (maxLength == 0)

            {

                json.MaxJsonLength = int.MaxValue;

            }

            else

            {

                json.MaxJsonLength = maxLength;

            }

        }

    }

}

Then you could either apply it globally using the global filter configuration or controller/action-wise.

The question really is whether you really need to return 17k records? How are you planning to handle all the data in the browser? The users are not going to scroll through 17000 rows anyway.

A better approach is to retrieve only a "top few" records and load more as needed.

You can set it in the config as others have said, or you can set in on an individual instance of the serializer like:

var js = new JavaScriptSerializer() { MaxJsonLength = int.MaxValue };

For those who are having issues with in MVC3 with JSON that's automatically being deserialized for a model binder and is too large, here is a solution.

1. Copy the code for the JsonValueProviderFactory class from the MVC3 source code into a new class.


2. Add a line to change the maximum JSON length before the object is deserialized.


3. Replace the JsonValueProviderFactory class with your new, modified class.

Thanks to http://blog.naver.com/techshare/100145191355 and https://gist.github.com/DalSoft/1588818 for pointing me in the right direction for how to do this. The last link on the first site contains full source code for the solution.

It appears that there is no "unlimited" value. The default is 2097152 characters, which is equivalent to 4 MB of Unicode string data.

As as already been observed, 17,000 records are hard to use well in the browser. If you are presenting an aggregate view it may be much more efficient to do the aggregation on the server and transfer only a summary in the browser. For example, consider a file system brower, we only see the top of the tree, then emit further requestes as we drill down. The number of records returned in each request is comparatively small. A tree view presentation can work well for large result sets.

Just ran into this. I'm getting over 6,000 records. Just decided I'd just do some paging. As in, I accept a page number in my MVC JsonResult endpoint, which is defaulted to 0 so it's not necessary, like so:

public JsonResult MyObjects(int pageNumber = 0)

Then instead of saying:

return Json(_repository.MyObjects.ToList(), JsonRequestBehavior.AllowGet);

I say:

return Json(_repository.MyObjects.OrderBy(obj => obj.ID).Skip(1000 * pageNumber).Take(1000).ToList(), JsonRequestBehavior.AllowGet);

It's very simple. Then, in JavaScript, instead of this:

function myAJAXCallback(items) {

    // Do stuff here

}

I instead say:

var pageNumber = 0;

function myAJAXCallback(items) {

    if(items.length == 1000)

        // Call same endpoint but add this to the end: '?pageNumber=' + ++pageNumber

    }

    // Do stuff here

}

And append your records to whatever you were doing with them in the first place. Or just wait until all the calls finish and cobble the results together.

I solved the problem adding this code:

String confString = HttpContext.Current.Request.ApplicationPath.ToString();

Configuration conf = WebConfigurationManager.OpenWebConfiguration(confString);

ScriptingJsonSerializationSection section = (ScriptingJsonSerializationSection)conf.GetSection("system.web.extensions/scripting/webServices/jsonSerialization");

section.MaxJsonLength = 6553600;

conf.Save();

If you are encountering this sort of issue in View, you can use below method to resolve that. Here Iused Newtonsoft package .

@using Newtonsoft.Json

<script type="text/javascript">

    var partData = @Html.Raw(JsonConvert.SerializeObject(ViewBag.Part));

</script>

Alternative ASP.NET MVC 5 Fix:

(Mine is similar to MFCs answer above with a few small changes)

I wasn't ready to change to Json.NET just yet and in my case the error was occurring during the request. Best approach in my scenario was modifying the actual JsonValueProviderFactory which applies the fix to the global project and can be done by editing the global.cs file as such.

JsonValueProviderConfig.Config(ValueProviderFactories.Factories);

add a web.config entry:

<add key="aspnet:MaxJsonLength" value="20971520" />

and then create the two following classes

public class JsonValueProviderConfig

{

    public static void Config(ValueProviderFactoryCollection factories)

    {

        var jsonProviderFactory = factories.OfType<JsonValueProviderFactory>().Single();

        factories.Remove(jsonProviderFactory);

        factories.Add(new CustomJsonValueProviderFactory());

    }

}

This is basically an exact copy of the default implementation found in System.Web.Mvc but with the addition of a configurable web.config appsetting value aspnet:MaxJsonLength.

public class CustomJsonValueProviderFactory : ValueProviderFactory

{



    /// <summary>Returns a JSON value-provider object for the specified controller context.</summary>

    /// <returns>A JSON value-provider object for the specified controller context.</returns>

    /// <param name="controllerContext">The controller context.</param>

    public override IValueProvider GetValueProvider(ControllerContext controllerContext)

    {

        if (controllerContext == null)

            throw new ArgumentNullException("controllerContext");



        object deserializedObject = CustomJsonValueProviderFactory.GetDeserializedObject(controllerContext);

        if (deserializedObject == null)

            return null;



        Dictionary<string, object> strs = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

        CustomJsonValueProviderFactory.AddToBackingStore(new CustomJsonValueProviderFactory.EntryLimitedDictionary(strs), string.Empty, deserializedObject);



        return new DictionaryValueProvider<object>(strs, CultureInfo.CurrentCulture);

    }



    private static object GetDeserializedObject(ControllerContext controllerContext)

    {

        if (!controllerContext.HttpContext.Request.ContentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase))

            return null;



        string fullStreamString = (new StreamReader(controllerContext.HttpContext.Request.InputStream)).ReadToEnd();

        if (string.IsNullOrEmpty(fullStreamString))

            return null;



        var serializer = new JavaScriptSerializer()

        {

            MaxJsonLength = CustomJsonValueProviderFactory.GetMaxJsonLength()

        };

        return serializer.DeserializeObject(fullStreamString);

    }



    private static void AddToBackingStore(EntryLimitedDictionary backingStore, string prefix, object value)

    {

        IDictionary<string, object> strs = value as IDictionary<string, object>;

        if (strs != null)

        {

            foreach (KeyValuePair<string, object> keyValuePair in strs)

                CustomJsonValueProviderFactory.AddToBackingStore(backingStore, CustomJsonValueProviderFactory.MakePropertyKey(prefix, keyValuePair.Key), keyValuePair.Value);



            return;

        }



        IList lists = value as IList;

        if (lists == null)

        {

            backingStore.Add(prefix, value);

            return;

        }



        for (int i = 0; i < lists.Count; i++)

        {

            CustomJsonValueProviderFactory.AddToBackingStore(backingStore, CustomJsonValueProviderFactory.MakeArrayKey(prefix, i), lists[i]);

        }

    }



    private class EntryLimitedDictionary

    {

        private static int _maximumDepth;



        private readonly IDictionary<string, object> _innerDictionary;



        private int _itemCount;



        static EntryLimitedDictionary()

        {

            _maximumDepth = CustomJsonValueProviderFactory.GetMaximumDepth();

        }



        public EntryLimitedDictionary(IDictionary<string, object> innerDictionary)

        {

            this._innerDictionary = innerDictionary;

        }



        public void Add(string key, object value)

        {

            int num = this._itemCount + 1;

            this._itemCount = num;

            if (num > _maximumDepth)

            {

                throw new InvalidOperationException("The length of the string exceeds the value set on the maxJsonLength property.");

            }

            this._innerDictionary.Add(key, value);

        }

    }



    private static string MakeArrayKey(string prefix, int index)

    {

        return string.Concat(prefix, "[", index.ToString(CultureInfo.InvariantCulture), "]");

    }



    private static string MakePropertyKey(string prefix, string propertyName)

    {

        if (string.IsNullOrEmpty(prefix))

        {

            return propertyName;

        }

        return string.Concat(prefix, ".", propertyName);

    }



    private static int GetMaximumDepth()

    {

        int num;

        NameValueCollection appSettings = ConfigurationManager.AppSettings;

        if (appSettings != null)

        {

            string values = appSettings.GetValues("aspnet:MaxJsonDeserializerMembers");

            if (values != null && values.Length != 0 && int.TryParse(values[0], out num))

            {

                return num;

            }

        }

        return 1000;

    }



    private static int GetMaxJsonLength()

    {

        int num;

        NameValueCollection appSettings = ConfigurationManager.AppSettings;

        if (appSettings != null)

        {

            string values = appSettings.GetValues("aspnet:MaxJsonLength");

            if (values != null && values.Length != 0 && int.TryParse(values[0], out num))

            {

                return num;

            }

        }

        return 1000;

    }

}

use libNewtonsoft.Json.dll

public string serializeObj(dynamic json) {        

    return JsonConvert.SerializeObject(json);

}

Solution for WebForms UpdatePanel:

Add a setting to Web.config:

<configuration>

  <appSettings>

    <add key="aspnet:UpdatePanelMaxScriptLength" value="2147483647" />

  </appSettings>

</configuration>

https://support.microsoft.com/en-us/kb/981884

ScriptRegistrationManager class contains following code:

// Serialize the attributes to JSON and write them out

JavaScriptSerializer serializer = new JavaScriptSerializer();



// Dev10# 877767 - Allow configurable UpdatePanel script block length

// The default is JavaScriptSerializer.DefaultMaxJsonLength

if (AppSettings.UpdatePanelMaxScriptLength > 0) {

    serializer.MaxJsonLength = AppSettings.UpdatePanelMaxScriptLength;

}  



string attrText = serializer.Serialize(attrs);

We don't need any server side changes. you can fix this only modify by web.config file
This helped for me. try this out

<appSettings>

 <add key="aspnet:MaxJsonDeserializerMembers" value="2147483647" />

<add key="aspnet:UpdatePanelMaxScriptLength" value="2147483647" />

</appSettings>  



and   



<system.web.extensions>

<scripting>

  <webServices>

    <jsonSerialization maxJsonLength="2147483647"/>

  </webServices>

</scripting>

if this maxJsonLength value is a int then how big is its int 32bit/64bit/16bit.... i just want to be sure whats the maximum value i can set as my maxJsonLength

<scripting>

        <webServices>

            <jsonSerialization maxJsonLength="2147483647">

            </jsonSerialization>

        </webServices>

    </scripting>

You do not need to do with web.config
You can use short property during catch value of the passing list
For example
declare a model like

public class BookModel

    {

        public decimal id { get; set; }  // 1 



        public string BN { get; set; } // 2 Book Name



        public string BC { get; set; } // 3 Bar Code Number



        public string BE { get; set; } // 4 Edition Name



        public string BAL { get; set; } // 5 Academic Level



        public string BCAT { get; set; } // 6 Category

}

here i use short proporties like
BC =barcode
BE=book edition and so on