asp.net - receive - ¿Puedo establecer una longitud ilimitada para maxJsonLength en web.config?

return json data to view mvc

Question

Estoy usando la función autocompletar de jQuery. Cuando intento recuperar la lista de más de 17000 registros (cada uno no tendrá una longitud de 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 utilizando el 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 configurar?

Answer 1

¿La pregunta realmente es si realmente necesitas devolver los registros de 17k? ¿Cómo planea manejar todos los datos en el navegador? Los usuarios no van a desplazarse a través de 17000 filas de todos modos.

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

Answer 2

¿Qué tal un 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 controlador / acción.

Answer 3

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 su controlador

Adición:

Para cualquier persona desconcertada por los parámetros que necesita especificar, una llamada podría tener este aspecto:

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

Answer 4

Estaba teniendo este problema en los formularios web de ASP.NET. Fue ignorar completamente 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 tantos datos en una llamada de servicio web, debería considerar un enfoque diferente.

Answer 5

Lo arreglé.

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

Funciona muy bien.

Answer 6

No necesita hacerlo con web.config. Puede usar propiedades cortas durante el valor de captura de la lista de aprobación. Por ejemplo, declare 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 propiedades cortas como BC = código de barras BE = edición de libro, etc.

Answer 7

No necesitamos cambios del lado del servidor. puede arreglar esto solo modifíquelo mediante el archivo web.config Esto me ayudó. probar esto

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

Answer 8

Para aquellos que tienen problemas con MVC3 con JSON que se está deserializando automáticamente para una carpeta de modelos y es demasiado grande, aquí hay una solución.

1. Copie el código para la clase JsonValueProviderFactory del código fuente de MVC3 en una nueva clase.
2. Agregue una línea para cambiar la longitud máxima de JSON antes de deserializar el objeto.
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 indicarme la dirección correcta para saber cómo hacer esto. El último enlace en el primer sitio contiene el código fuente completo de la solución.

Answer 9

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 bien 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 y 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 de árbol puede funcionar bien para grandes conjuntos de resultados.

Answer 10

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

<configuration>
    <system.web.extensions>
        <scripting>
            <webServices>
                <jsonSerialization maxJsonLength="....">
                </jsonSerialization>
            </webServices>
        </scripting>
    </system.web.extensions>
</configuration>

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

Answer 11

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

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

Answer 12

Puedes escribir esta línea en el controlador

json.MaxJsonLength = 2147483644;

También puede escribir esta línea en web.config

<configuration>
  <system.web.extensions>
    <scripting>
        <webServices>
            <jsonSerialization maxJsonLength="2147483647">
            </jsonSerialization>
        </webServices>
    </scripting>
  </system.web.extensions>

`

Para estar en el lado seguro, use ambos.

Answer 13

Resolví el problema agregando 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();

Answer 14

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

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

Lo que hice es 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<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;
    }
}

}

Luego, en el método Application_Start de Global.asax.cs, reemplace ValueProviderFactory por 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);
}

Answer 15

Si MiniProfiler este error del MiniProfiler en MVC, puede aumentar el valor configurando la propiedad MiniProfiler.Settings.MaxJsonResponseSize al valor deseado. De forma predeterminada, esta herramienta parece ignorar el valor establecido en la configuración.

MiniProfiler.Settings.MaxJsonResponseSize = 104857600;

Cortesía de mvc-mini-profiler .

Answer 16

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

Si todavía está recibiendo el error:

• después de configurar 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 que utiliza la capa de comunicación asíncrona para invocar métodos de servicios web. ( MSDN: ScriptingJsonSerializationSection.MaxJsonLength Property )

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 un método de acción / controlador MVC) no respeta la propiedad maxJsonLength , al menos no de la sección systemWebExtensions.scripting.webServices.jsonSerialization de web.config.

Como solución alternativa, 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 .

Answer 17

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

@using Newtonsoft.Json
<script type="text/javascript">
    var partData = @Html.Raw(JsonConvert.SerializeObject(ViewBag.Part));
</script>

Answer 18

Si, después de implementar la adición anterior en su web.config, obtiene un error de "Sección de configuración no reconocida system.web.extensions". Luego intente agregar esto a su web.config en la sección <ConfigSections> :

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

Answer 19

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

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

Answer 20

Solo me encontré con esto. Estoy recibiendo más de 6.000 discos. Solo decidí que solo haría un poco de paginación. Al igual que en, acepto un número de página en mi punto final de MVC JsonResult, cuyo valor predeterminado es 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 agregue sus registros a lo que estaba haciendo con ellos en primer lugar. O simplemente espere hasta que todas las llamadas terminen y improvisen los resultados.

Answer 21

Solución para WebForms UpdatePanel:

Agrega una configuración a Web.config:

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

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

Answer 22

Sugiero establecerlo en Int32.MaxValue.

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

Answer 23

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

<configuration> 
   <system.web.extensions>
       <scripting>
           <webServices>
               <jsonSerialization maxJsonLength="50000000"/>
           </webServices>
       </scripting>
   </system.web.extensions>
</configuration> 

Lo resolví siguiendo:

   public ActionResult/JsonResult getData()
   {
      var jsonResult = Json(superlargedata, JsonRequestBehavior.AllowGet);
      jsonResult.MaxJsonLength = int.MaxValue;
      return jsonResult;
    }

Espero que esto ayude.

Answer 24

si este valor de maxJsonLength es un int, entonces ¿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 mi maxJsonLength

<scripting>
        <webServices>
            <jsonSerialization maxJsonLength="2147483647">
            </jsonSerialization>
        </webServices>
    </scripting>

Answer 25

utilizar lib/Newtonsoft.Json.dll

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

Answer 26

NOTA: esta respuesta se aplica solo a los servicios web, si está devolviendo JSON desde un método de controlador, asegúrese de leer esta respuesta SO a continuación: https://.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:

<configuration> 
   <system.web.extensions>
       <scripting>
           <webServices>
               <jsonSerialization maxJsonLength="50000000"/>
           </webServices>
       </scripting>
   </system.web.extensions>
</configuration> 

Answer 27

Solución ASP.NET MVC 5 alternativa:

(La mía es similar a la respuesta de MFC arriba con algunos pequeños cambios)

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

JsonValueProviderConfig.Config(ValueProviderFactories.Factories);

añadir una entrada web.config:

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

y luego crear las dos clases siguientes

public class JsonValueProviderConfig
{
    public static void Config(ValueProviderFactoryCollection factories)
    {
        var jsonProviderFactory = factories.OfType<JsonValueProviderFactory>().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 configurable de configuración de web.config 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;
    }
}