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

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> 

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 .

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

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

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.

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

Funciona muy bien.

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

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>

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.

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 .

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;

Sugiero configurarlo en Int32.MaxValue.

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

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

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.

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

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.

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>

 JsonResult result = Json(r);
 result.MaxJsonLength = Int32.MaxValue;
 result.JsonRequestBehavior = JsonRequestBehavior.AllowGet;
 return result;

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.

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.

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

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

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

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>

utilizar lib\Newtonsoft.Json.dll

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

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.

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>

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.