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

663

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 de longitud), 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 JSON JavaScriptSerializer. La longitud de la cadena excede el valor establecido en la propiedad maxJsonLength.

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

Prasad
fuente
1
Algo que mencionar que puede ser bastante obvio, así que discúlpeme si ya lo ha pensado; la cadena Json también incluye los corchetes alrededor de cada registro, las comillas alrededor de cada nombre de campo [y valor], así como el nombre y el valor del campo. Por lo tanto, puede ser útil establecer el nombre del campo como un solo carácter y también asegurarse de que si el valor no es una cadena, establezca el tipo de campo correctamente para que no contenga comillas.
MichaelJTaylor

Respuestas:

720

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 a continuación: 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 MaxJsonLengthpropiedad en su web.config:

<configuration> 
   <system.web.extensions>
       <scripting>
           <webServices>
               <jsonSerialization maxJsonLength="50000000"/>
           </webServices>
       </scripting>
   </system.web.extensions>
</configuration> 
CMS
fuente
153
Es un número entero, por lo que el valor máximo que puede establecer es: 2147483644
David Espart el
58
@despart: Te refieres a 2 147 483 647.
Dercsár
66
@ kmcc049, OMI, los valores no están mal porque si observa la pregunta, el OP no pregunta "¿cuál es el valor predeterminado de maxJsonLength?" (Por cierto, la segunda respuesta más votada es responder a esta pregunta incorrecta), está tratando de establecer esta propiedad en "ilimitada", pero como es un número entero, el valor máximo posible es 2147483647como señalan @depsart y @ Descár.
CMS
11
Genial, pero tenga en cuenta la respuesta de @David Murdoch a continuación si tiene este problema al usar MVC return Json()o algo así
BritishDeveloper
3
@ Dercsár: ¿cuál es el punto? 2147483644 es el entero más grande perfectamente divisible por 1024.
naveen
461

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


Si aún recibe el error:

  • después de establecer la maxJsonLengthpropiedad en 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 asincrónica para invocar métodos de servicios web. ( MSDN: Propiedad ScriptingJsonSerializationSection.MaxJsonLength )

Básicamente, lo "interno" JavaScriptSerializerrespeta el valor de maxJsonLengthcuando se llama desde un método web; el uso directo de un JavaScriptSerializer(o el uso a través de un método de acción MVC / controlador) no respeta la maxJsonLengthpropiedad, al menos no desde la systemWebExtensions.scripting.webServices.jsonSerializationsección 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 .

David Murdoch
fuente
55
Su respuesta fue realmente útil ya que estoy usando el Json()método de resultado de acción en asp.net mvc.
jessegavin
3
Sí, yo era un Json () sufro también. ¡Gracias!
BritishDeveloper
3
Aunque es completamente correcto y merece su lugar, esta es una de esas preguntas en las que vale la pena leer más allá de la respuesta principal :). ¡Gracias!
Nigel
3
Si está utilizando MVC4, consulte también @fanisch answer.
Beyers
44
¿Qué tal la deserialización? Encontré este error en el enlace del modelo de acción.
guogangj
345

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 cualquier persona desconcertada 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
);
fanisch
fuente
66
Puedo confirmar que lo anterior funciona como un encanto en MVC 4, gracias fanisch.
Beyers
99
Puedo confirmar también. Poner este código dentro de un controlador base es definitivamente el enfoque más limpio propuesto.
Parlamento
15
Esto también funciona simplemente agregando "MaxJsonLength = Int32.MaxValue" al resultado de la acción individual. En caso de que no se desee el cambio de controlador o proyecto en general
Hypnovirus
3
Esta es la mejor respuesta. MaxJsonLength se puede configurar por controlador.
liang
3
ADVERTENCIA: esta solución desactiva la compresión (si se solicita) de la respuesta. Agregue este filtro en su acción: stackoverflow.com/questions/3802107/…
Gorgi Rankovski
60

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

M4N
fuente
1
¿Cuál es el valor almacenado en este entero que representa? ¿Es esta una especie de recuento de personajes? Supongo que lo que pregunto es, ¿por qué se usa un número entero? ¡Gracias!
eaglei22
@ eaglei22 el número representa cuántos bytes se pueden usar para maxJsonLength. Como mencionó M4N, 102400 es el valor predeterminado (100 KB).
Jacob Plonke
esto no me funcionó y no utilicé servicios web.
kalai
42

si todavía recibe un error después de la configuración de 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.

Ravi Anand
fuente
2
Configurar maxJsonLength en web.config no es conveniente, configurar jsonResult.MaxJsonLength debería ser suficiente (al menos para mí (MVC5))
hormberg
Esto es bueno porque no es un cambio global.
rob_james
40

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.

Pulga
fuente
1
¿Esto funcionó para ti? ¿Dónde pusiste este código?
user1012598
Nuestro problema era porque teníamos un área de texto que permitía HTML y las personas incrustaban imágenes como HTML, lo que hacía que la entrada se volviera muy grande y que el serializador JSON fallara. Supongo que si se puede hacer, los usuarios lo harán ...
Marko
Describa dónde debemos poner este código ... @Flea
Koray Durudogan
@KorayDurudogan: puse esto en el método Ajax que estaba devolviendo la respuesta, así que en mi controlador. ¡Espero que ayude!
Pulga
No estoy cuestionando su respuesta, sino tratando de tener una mejor idea de qué mejores enfoques existen. Tengo una consulta que, según los criterios del usuario, determinará el tamaño del resultado. Devuelvo un JsonResult, ¿importaría si devolviera un archivo de Excel?
eaglei22
22

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.

Mario Arrieta
fuente
¡Increíble! Esta es la única solución que funcionó para mí y es mejor de todos modos ya que no es un cambio global. ¡Gracias!
Sealer_05
20

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

Cuando necesitaba publicar un json grande en una acción en un controlador, recibí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 del parámetro: entrada proveedor de valor ".

Lo que hice fue crear un nuevo 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 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);
}
AMF
fuente
1
Hice todo lo que pude, solo su respuesta me salvó el día, esta debería haber sido aceptada
Muhammad Waqas Aziz
Con este código, podemos anular el límite de deserialización de max json del controlador MVC de 4 mb, pero ¿hay alguna manera de anular el límite de deserialización de max json del controlador web-api
Muhammad Waqas Aziz
17

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

            <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>
bkdraper
fuente
44
Estaba teniendo este problema Sin embargo, esta respuesta no funcionó para mí. En lugar de agregar el elemento <sectionGroup> descrito aquí, simplemente moví todo el bloque <system.web.extensions> recién agregado al final de mi web.config ... justo antes de </configuration>. Entonces funcionó.
ClearCloud8
Esto ayudó, pero en mi situación necesitaba cambiar su cuarta línea a <section name="jsonSerialization" type="System.Web.Configuration.ScriptingJsonSerializationSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="Everywhere"/>, como se ve en esta página: forums.asp.net/t/1446510.aspx/1
Nathan
@ ClearCloud8 Obtenga ese comentario difundido en esta página de inmediato.
Jack Nutkins el
11

puedes escribir esta línea en el controlador

json.MaxJsonLength = 2147483644;

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

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

``

Para estar seguro, use ambos.

Pankaj Sapkal
fuente
10

Si recibe este error del MiniProfiler en MVC, puede aumentar el valor estableciendo la propiedad MiniProfiler.Settings.MaxJsonResponseSizeen el valor deseado. Por defecto, esta herramienta parece ignorar el valor establecido en la configuración.

MiniProfiler.Settings.MaxJsonResponseSize = 104857600;

Cortesía de mvc-mini-profiler .

wolfyuk
fuente
10

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;
Aftab Ahmed Kalhoro
fuente
9

Sugiero configurarlo en Int32.MaxValue.

JavaScriptSerializer serializer = new JavaScriptSerializer();
serializer.MaxJsonLength = Int32.MaxValue;
Santhosh
fuente
9

¿Qué tal algún atributo mágico?

[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 inteligente.

Balázs
fuente
Gran respuesta. Buen uso de atributos personalizados. ¿Se pregunta si hay una razón específica (técnica) por la que establece el valor predeterminado en 10 MB de caracteres de un byte en lugar de Max (int.MaxValue)?
Josh
@ Josh No, no había ninguna razón especial para eso.
Balázs el
5

La pregunta realmente es si realmente necesita devolver 17k registros. ¿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 "primeros pocos" registros y cargar más según sea necesario.

Chetan Sastry
fuente
1
La lista predeterminada de json dará 17k registros. Pero la función de autocompletar solo mostrará una lista de los registros que coinciden con los caracteres que escribe el usuario, por lo que no necesitará desplazarse más por la lista. Entonces, lo que necesito es establecer una longitud ilimitada para maxJsonLength que puede serializar los datos de 17k.
Prasad el
66
Puede usar una combinación de filtrado del lado del servidor y del cliente. Podría ser difícil filtrar todos los datos en el lado del cliente, sin mencionar la latencia de la red.
Chetan Sastry el
1
Habiendo llegado a este mismo problema hace un tiempo, decidí implementar un controlador "onsearch" para el autocompletado, y hacer que la llamada al servicio web pasara el texto de "búsqueda" y realizara una consulta Top10 usando los criterios de búsqueda como filtro. Esto significaba más solicitudes individuales de ajax, que solo obtener la lista completa en la carga de la página, pero también significaba que todas las solicitudes / respuestas eran mucho más pequeñas.
Mike U
3

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

var js = new JavaScriptSerializer() { MaxJsonLength = int.MaxValue };
Caleb Postlethwait
fuente
3

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

  1. Copie el código para 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 sobre cómo hacer esto. El último enlace en el primer sitio contiene el código fuente completo de la solución.

vestigio
fuente
3

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

@using Newtonsoft.Json
<script type="text/javascript">
    var partData = @Html.Raw(JsonConvert.SerializeObject(ViewBag.Part));
</script>
dush88c
fuente
¿Esto significa que no tengo que preocuparme por la longitud máxima si uso Json.NET? No creo que haya una manera de establecer la longitud máxima en Json.NET, así que espero que funcione de inmediato.
Kimbaudi
1
Excelente respuesta gracias! Esto también funcionó cuando intentaba cargar un objeto.
user1299379
3
 JsonResult result = Json(r);
 result.MaxJsonLength = Int32.MaxValue;
 result.JsonRequestBehavior = JsonRequestBehavior.AllowGet;
 return result;
Aikansh Mann
fuente
2

Parece que no hay un valor "ilimitado". El valor predeterminado es 2097152 caracteres, lo que equivale a 4 MB de datos de cadena Unicode.

Como ya se observó, 17,000 registros son difíciles de usar bien en el navegador. Si presenta 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 buscador 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 relativamente pequeño. Una presentación en vista de árbol puede funcionar bien para grandes conjuntos de resultados.

djna
fuente
3
el código predeterminado es bastante extraño (nuevo JavaScriptSerializer ()). MaxJsonLength es 2097152 bytes pero el servicio web ResponseFormatJson es 102400 bytes a menos que se establezca explícitamente.
robar
2

Acabo de encontrarme con esto. Estoy obteniendo más de 6,000 registros. Solo decidí que solo haría un poco de paginación. Como 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 simple. Luego, en JavaScript, en lugar de esto:

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

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 lo que sea que estaba haciendo con ellos en primer lugar. O simplemente espere hasta que todas las llamadas terminen y emita los resultados juntos.

vbullinger
fuente
2

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();
jfabrizio
fuente
Esto parece una solución pirata pero un enfoque interesante independientemente. Lo encontré útil gracias! Para mí, en el controlador apsnet mvc 5, tuve que eliminar 'Current' del espacio de nombres. Hice un par de ajustes:string confString = HttpContext.Request.ApplicationPath.ToString(); var conf = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration(confString); var section = (System.Web.Configuration.ScriptingJsonSerializationSection)conf.GetSection("system.web.extensions/scripting/webServices/jsonSerialization"); section.MaxJsonLength = int.MaxValue; conf.Save();
ooXei1sh
2

Solución alternativa 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 estaba ocurriendo durante la solicitud. El mejor enfoque en mi escenario fue modificar el real JsonValueProviderFactoryque aplica la solución al proyecto global y puede hacerse editando el global.csarchivo como tal.

JsonValueProviderConfig.Config(ValueProviderFactories.Factories);

agregue una entrada web.config:

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

y luego crea 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());
    }
}

Básicamente, se trata de una copia exacta de la implementación predeterminada que se encuentra en, System.Web.Mvcpero con la adición de un valor de configuración web.config configurable 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;
    }
}
Maxim Gershkovich
fuente
1
Gracias, está funcionando ... Muchas gracias @Maxim Gershkovich
Jasper Manickaraj
1

Solución para UpdatePanel de WebForms:

Agregue 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 La clase 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);
Der_Meister
fuente
1

No necesitamos ningún cambio en el lado del servidor. puedes arreglar esto solo modificar por 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>

isanka thalagala
fuente
0

utilizar lib\Newtonsoft.Json.dll

public string serializeObj(dynamic json) {        
    return JsonConvert.SerializeObject(json);
}
Buddhika De Silva
fuente
0

Solución para ASP.NET MVC: si desea solucionarlo solo para una acción particular que está causando el problema, codifique de esta manera:

public JsonResult GetBigJson()
{
    var someBigObject = GetBigObject();
    return Json(someBigObject);
}

puedes cambiar a esto:

public JsonResult GetBigJson()
{
    var someBigObject = GetBigObject();
    return new JsonResult()
    {
        Data = someBigObject,
        JsonRequestBehavior = JsonRequestBehavior.DenyGet,
        MaxJsonLength = int.MaxValue
    };
}

Y la funcionalidad debe ser la misma, solo puede devolver JSON más grande como respuesta.


Explicación basada en el código fuente ASP.NET MVC: puede verificar qué Controller.Jsonmétodo hace en el código fuente ASP.NET MVC

protected internal JsonResult Json(object data)
{
    return Json(data, null /* contentType */, null /* contentEncoding */, JsonRequestBehavior.DenyGet);
}

Está llamando a otro Controller.Jsonmétodo:

protected internal virtual JsonResult Json(object data, string contentType, Encoding contentEncoding, JsonRequestBehavior behavior)
{
    return new JsonResult
    {
        Data = data,
        ContentType = contentType,
        ContentEncoding = contentEncoding,
        JsonRequestBehavior = behavior
    };
}

donde pasaron contentTypey contentEncodingobjeto son null. Entonces, básicamente, llamar return Json(object)al controlador es equivalente a llamar return new JsonResult { Data = object, JsonRequestBehavior = sonRequestBehavior.DenyGet }. Puedes usar la segunda forma y parametrizarJsonResult .

Entonces, ¿qué sucede cuando establece la MaxJsonLengthpropiedad (por defecto es nula)? Se pasa a la JavaScriptSerializer.MaxJsonLengthpropiedad y luego JavaScriptSerializer.Serializese llama método :

JavaScriptSerializer serializer = new JavaScriptSerializer();
if (MaxJsonLength.HasValue)
{
    serializer.MaxJsonLength = MaxJsonLength.Value;
}

if (RecursionLimit.HasValue)
{
    serializer.RecursionLimit = RecursionLimit.Value;
}

response.Write(serializer.Serialize(Data));

Y cuando no establece la MaxJsonLenghtpropiedad del serializador, entonces toma el valor predeterminado que es solo 2 MB.

Mariusz Pawelski
fuente
-2

si este valor de maxJsonLength es 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 maxJsonLength

<scripting>
        <webServices>
            <jsonSerialization maxJsonLength="2147483647">
            </jsonSerialization>
        </webServices>
    </scripting>
mpho isaac Molelle
fuente
-4

No es necesario que haga con web.config. Puede usar una propiedad corta 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í uso proporciones cortas como BC = código de barras BE = edición de libro, etc.

Md Nazrul Islam
fuente
Esto no ayudará si la mayor parte de los datos se encuentra en los valores de las propiedades
ventana