¿Puedo establecer una longitud ilimitada para maxJsonLength en web.config?

Estoy usando la función de autocompletar de jQuery. Cuando trato de recuperar la lista de más de 17000 registros (cada uno no tendrá más de 10 caracteres), está excediendo la longitud y arroja el error:

Información de excepción:
Tipo de excepción: InvalidOperationException
Mensaje de excepción: error durante la serialización o deserialización usando JSON JavaScriptSerializer. La longitud de la cadena excede el valor establecido en la propiedad maxJsonLength.

¿Puedo establecer una longitud ilimitada para maxJsonLength en web.config ? Si no, ¿cuál es la longitud máxima que puedo establecer?

NOTA: esta respuesta se aplica solo a los servicios web. Si devuelve JSON desde un método de controlador, asegúrese de leer también esta respuesta SO: https://stackoverflow.com/a/7207539/1246870


La propiedad MaxJsonLength no puede ser ilimitada, es una propiedad entera que por defecto es 102400 (100k).

Puede establecer la propiedad MaxJsonLength en su web.config:

          

Si está utilizando MVC 4 , asegúrese de revisar esta respuesta también.


Si aún recibes el error:

  • después de establecer la propiedad maxJsonLength a su valor máximo en web.config
  • y sabes que la longitud de tus datos es menor que este valor
  • y no está utilizando un método de servicio web para la serialización de JavaScript

su problema es probable que:

El valor de la propiedad MaxJsonLength se aplica solo a la instancia interna de JavaScriptSerializer utilizada por la capa de comunicación asincrónica para invocar métodos de servicios web. ( MSDN: Propiedad ScriptingJsonSerializationSection.MaxJsonLength )

Básicamente, el JavaScriptSerializer “interno” respeta el valor de maxJsonLength cuando se llama desde un método web; el uso directo de un JavaScriptSerializer (o su uso a través de MVC action-method / Controller) no respeta la propiedad maxJsonLength , al menos no de la sección systemWebExtensions.scripting.webServices.jsonSerialization de web.config.

Como solución, puede hacer lo siguiente dentro de su Controlador (o en cualquier lugar realmente):

 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; 

Esta respuesta es mi interpretación de esta respuesta del foro asp.net .

En MVC 4 puedes hacer:

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

en tu controlador.

Adición:

Para cualquiera desconcertado por los parámetros que necesita especificar, una llamada podría verse así:

 Json( new { field1 = true, field2 = "value" }, "application/json", Encoding.UTF8, JsonRequestBehavior.AllowGet ); 

Puede configurar la longitud máxima para las solicitudes json en su archivo web.config:

           

El valor predeterminado para maxJsonLength es 102400 . Para obtener más detalles, consulte esta página de MSDN: http://msdn.microsoft.com/en-us/library/bb763183.aspx

Estaba teniendo este problema en ASP.NET Web Forms. Estaba ignorando por completo la configuración del archivo web.config, así que hice esto:

  JavaScriptSerializer serializer = new JavaScriptSerializer(); serializer.MaxJsonLength = Int32.MaxValue; return serializer.Serialize(response); 

Por supuesto, en general esta es una práctica terrible. Si está enviando esta cantidad de datos en una llamada de servicio web, debe considerar un enfoque diferente.

Lo arreglé.

 //your Json data here string json_object="........"; JavaScriptSerializer jsJson = new JavaScriptSerializer(); jsJson.MaxJsonLength = 2147483644; MyClass obj = jsJson.Deserialize(json_object); 

Funciona muy bien.

si aún recibe el error después de la configuración de web.config como sigue:

          

si, después de implementar la adición anterior en su web.config, obtiene un error “sección de configuración no reconocida system.web.extensions.” y luego intente agregar esto a su web.config en la sección :

     

Seguí la respuesta de vestigal y llegué a esta solución:

Cuando necesitaba publicar un JSON grande en una acción en un controlador, obtenía el famoso “Error durante la deserialización usando JSON JavaScriptSerializer. La longitud de la cadena excede el valor establecido en la propiedad maxJsonLength. \ R \ nNombre del parámetro: entrada proveedor de valor “.

Lo que hice fue crear una nueva ValueProviderFactory, LargeJsonValueProviderFactory, y establecer MaxJsonLength = Int32.MaxValue en el método GetDeserializedObject

 public sealed class LargeJsonValueProviderFactory : ValueProviderFactory { private static void AddToBackingStore(LargeJsonValueProviderFactory.EntryLimitedDictionary backingStore, string prefix, object value) { IDictionary dictionary = value as IDictionary; if (dictionary != null) { foreach (KeyValuePair keyValuePair in (IEnumerable>) 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); } /// Returns a JSON value-provider object for the specified controller context. /// A JSON value-provider object for the specified controller context. /// The controller context. 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 dictionary = new Dictionary((IEqualityComparer) StringComparer.OrdinalIgnoreCase); LargeJsonValueProviderFactory.AddToBackingStore(new LargeJsonValueProviderFactory.EntryLimitedDictionary((IDictionary) dictionary), string.Empty, deserializedObject); return (IValueProvider) new DictionaryValueProvider((IDictionary) 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 _innerDictionary; private int _itemCount; public EntryLimitedDictionary(IDictionary 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; } } 

}

Luego, en el método Application_Start de Global.asax.cs, reemplace ValueProviderFactory con el nuevo:

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

puedes escribir esta línea en el controlador

 json.MaxJsonLength = 2147483644; 

también puedes escribir esta línea en web.config

          

`

Para estar seguro, usa ambos.

Si obtiene este error del MiniProfiler en MVC, puede boost el valor configurando la propiedad MiniProfiler.Settings.MaxJsonResponseSize en el valor deseado. Por defecto, esta herramienta parece ignorar el valor establecido en config.

 MiniProfiler.Settings.MaxJsonResponseSize = 104857600; 

Cortesía de mvc-mini-profiler .

Simplemente configure MaxJsonLength proprty en el método de acción MVC

 JsonResult json= Json(classObject, JsonRequestBehavior.AllowGet); json.MaxJsonLength = int.MaxValue; return json; 

Sugiero configurarlo en Int32.MaxValue.

 JavaScriptSerializer serializer = new JavaScriptSerializer(); serializer.MaxJsonLength = Int32.MaxValue; 

¿Qué tal algún atributo de magia?

 [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; } } } } 

Luego, puede aplicarlo globalmente utilizando la configuración de filtro global o el controlador / acción.

La pregunta realmente es si realmente necesita devolver 17k registros. ¿Cómo piensa manejar todos los datos en el navegador? Los usuarios no se desplazarán entre 17000 filas de todos modos.

Un mejor enfoque es recuperar solo los “primeros pocos” registros y cargar más según sea necesario.

Para aquellos que están teniendo problemas en MVC3 con JSON que se están deserializando automáticamente para un archivador de modelo y es demasiado grande, aquí hay una solución.

  1. Copie el código de la clase JsonValueProviderFactory del código fuente MVC3 en una nueva clase.
  2. Agregue una línea para cambiar la longitud máxima de JSON antes de que el objeto se deserialice.
  3. Reemplace la clase JsonValueProviderFactory con su nueva clase modificada.

Gracias a http://blog.naver.com/techshare/100145191355 y https://gist.github.com/DalSoft/1588818 por señalarme en la dirección correcta para saber cómo hacer esto. El último enlace en el primer sitio contiene el código fuente completo para la solución.

Solo encontré esto. Recibo más de 6,000 registros. Solo decidí que haría un poco de paginación. Al igual que en, acepto un número de página en mi punto final MVC JsonResult, que está predeterminado en 0, por lo que no es necesario, así:

 public JsonResult MyObjects(int pageNumber = 0) 

Entonces, en lugar de decir:

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

Yo digo:

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

Es muy sencillo. Luego, en JavaScript, en lugar de esto:

 function myAJAXCallback(items) { // Do stuff here } 

Yo en cambio digo:

 var pageNumber = 0; function myAJAXCallback(items) { if(items.length == 1000) // Call same endpoint but add this to the end: '?pageNumber=' + ++pageNumber } // Do stuff here } 

Y añada sus registros a todo lo que estaba haciendo con ellos en primer lugar. O simplemente espere hasta que todas las llamadas terminen y improvise los resultados.

Parece que no hay un valor “ilimitado”. El valor predeterminado es 2097152 caracteres, que es equivalente a 4 MB de datos de cadena Unicode.

Como ya se ha observado, 17,000 registros son difíciles de usar en el navegador. Si está presentando una vista agregada, puede ser mucho más eficiente hacer la agregación en el servidor y transferir solo un resumen en el navegador. Por ejemplo, considere un navegador de sistema de archivos, solo vemos la parte superior del árbol, luego emitimos más solicitudes a medida que profundizamos. El número de registros devueltos en cada solicitud es comparativamente pequeño. Una presentación de vista en árbol puede funcionar bien para grandes conjuntos de resultados.

Puede configurarlo en la configuración como otros han dicho, o puede establecer una instancia individual del serializador como:

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

Resolví el problema añadiendo este código:

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

Si encuentra este tipo de problema en View, puede usar el siguiente método para resolverlo. Aquí usé el paquete Newtonsoft .

 @using Newtonsoft.Json  

use lib\Newtonsoft.Json.dll

 public string serializeObj(dynamic json) { return JsonConvert.SerializeObject(json); } 

Solución para WebForms UpdatePanel:

Agregue una configuración a Web.config:

      

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

ScriptRegistrationManager clase ScriptRegistrationManager contiene el siguiente código:

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

No necesitamos ningún cambio en el servidor. puedes arreglar esto solo modificar mediante el archivo web.config Esto me ayudó. probar esto

     and       

Alternativa de reparación de ASP.NET MVC 5:

(El mío es similar a la respuesta anterior de MFC con algunos pequeños cambios)

Todavía no estaba listo para cambiar a Json.NET y en mi caso el error se produjo durante la solicitud. El mejor enfoque en mi escenario fue modificar el JsonValueProviderFactory real que aplica el arreglo al proyecto global y se puede hacer editando el archivo global.cs como tal.

 JsonValueProviderConfig.Config(ValueProviderFactories.Factories); 

agregue una entrada web.config:

  

y luego crea las dos clases siguientes

 public class JsonValueProviderConfig { public static void Config(ValueProviderFactoryCollection factories) { var jsonProviderFactory = factories.OfType().Single(); factories.Remove(jsonProviderFactory); factories.Add(new CustomJsonValueProviderFactory()); } } 

Esta es básicamente una copia exacta de la implementación predeterminada que se encuentra en System.Web.Mvc pero con la adición de un valor de aspnet:MaxJsonLength web.config configurable aspnet:MaxJsonLength .

 public class CustomJsonValueProviderFactory : ValueProviderFactory { /// Returns a JSON value-provider object for the specified controller context. /// A JSON value-provider object for the specified controller context. /// The controller context. public override IValueProvider GetValueProvider(ControllerContext controllerContext) { if (controllerContext == null) throw new ArgumentNullException("controllerContext"); object deserializedObject = CustomJsonValueProviderFactory.GetDeserializedObject(controllerContext); if (deserializedObject == null) return null; Dictionary strs = new Dictionary(StringComparer.OrdinalIgnoreCase); CustomJsonValueProviderFactory.AddToBackingStore(new CustomJsonValueProviderFactory.EntryLimitedDictionary(strs), string.Empty, deserializedObject); return new DictionaryValueProvider(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 strs = value as IDictionary; if (strs != null) { foreach (KeyValuePair 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 _innerDictionary; private int _itemCount; static EntryLimitedDictionary() { _maximumDepth = CustomJsonValueProviderFactory.GetMaximumDepth(); } public EntryLimitedDictionary(IDictionary 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; } } 

si este valor de maxJsonLength es un int, ¿qué tan grande es su int 32bit / 64bit / 16bit … solo quiero estar seguro de cuál es el valor máximo que puedo establecer como maxJsonLength

       

No necesita hacer con web.config Puede usar propiedad corta durante el valor de captura de la lista de aprobación. Por ejemplo, declarar un modelo como

 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 } 

aquí utilizo proporciones cortas como BC = código de barras BE = edición de libros, etc.