Posso definir um comprimento ilimitado para maxJsonLength no web.config?

Estou usando o recurso de preenchimento automático do jQuery. Quando tento recuperar a lista de mais de 17000 registros (cada um não terá mais de 10 caracteres), está excedendo o comprimento e gera o erro:

Informações sobre a exceção:
Tipo de exceção: InvalidOperationException
Mensagem de exceção: Erro durante a serialização ou desserialização usando o JSON JavaScriptSerializer. O comprimento da cadeia excede o valor definido na propriedade maxJsonLength.

Posso definir um comprimento ilimitado para maxJsonLengthin web.config? Caso contrário, qual é o comprimento máximo que posso definir?

NOTA: esta resposta se aplica apenas a serviços da Web, se você estiver retornando JSON de um método Controller, leia também esta resposta SO abaixo: https://stackoverflow.com/a/7207539/1246870

A propriedade MaxJsonLength não pode ser ilimitada, é uma propriedade inteira cujo padrão é 102400 (100k).

Você pode definir a MaxJsonLengthpropriedade no seu web.config:

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

Se você estiver usando o MVC 4 , verifique também esta resposta .

Se você ainda estiver recebendo o erro:

• depois de definir a maxJsonLengthpropriedade com seu valor máximo em web.config
• e você sabe que o comprimento dos seus dados é menor que esse valor
• e você não está utilizando um método de serviço da web para a serialização JavaScript

seu problema é provável que:

O valor da propriedade MaxJsonLength se aplica apenas à instância JavaScriptSerializer interna usada pela camada de comunicação assíncrona para chamar métodos de serviços da Web. ( Propriedade MSDN: ScriptingJsonSerializationSection.MaxJsonLength )

Basicamente, o "interno" JavaScriptSerializerrespeita o valor de maxJsonLengthquando chamado de um método da web; O uso direto de a JavaScriptSerializer(ou o uso de um método de ação / Controller MVC) não respeita a maxJsonLengthpropriedade, pelo menos não na systemWebExtensions.scripting.webServices.jsonSerializationseção web.config.

Como solução alternativa, você pode fazer o seguinte no seu Controller (ou em qualquer outro lugar):

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 resposta é a minha interpretação desta resposta do fórum asp.net .

No MVC 4, você pode fazer:

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

no seu controlador.

Adição:

Para qualquer pessoa intrigada com os parâmetros que você precisa especificar, uma chamada pode ser assim:

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

Você pode configurar o comprimento máximo para solicitações json no seu arquivo web.config:

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

O valor padrão para maxJsonLength é 102400 . Para obter mais detalhes, consulte esta página do MSDN: http://msdn.microsoft.com/en-us/library/bb763183.aspx

se você ainda estiver recebendo erro após a configuração do web.config da seguinte maneira:

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

Eu o resolvi seguindo:

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

Espero que isso ajude.

Eu estava tendo esse problema no ASP.NET Web Forms. Ele estava ignorando completamente as configurações do arquivo web.config, então eu fiz isso:

        JavaScriptSerializer serializer = new JavaScriptSerializer();

        serializer.MaxJsonLength = Int32.MaxValue; 

        return serializer.Serialize(response);

Obviamente, no geral, essa é uma prática terrível. Se você está enviando tantos dados em uma chamada de serviço da web, deve considerar uma abordagem diferente.

Eu consertei isso.

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

Funciona muito bem.

Segui a resposta da Vestigal e cheguei a esta solução:

Quando eu precisava postar um json grande em uma ação em um controlador, recebia o famoso "Erro durante a desserialização usando o JSON JavaScriptSerializer. O comprimento da string excede o valor definido na propriedade maxJsonLength. \ R \ nNome do parâmetro: input provedor de valor ".

O que fiz foi criar um novo ValueProviderFactory, LargeJsonValueProviderFactory e definir o MaxJsonLength = Int32.MaxValue no 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;
     }
  }
}

Em seguida, no método Application_Start de Global.asax.cs, substitua o ValueProviderFactory pelo novo:

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

se, depois de implementar a adição acima em seu web.config, você obtiver uma "seção de configuração não reconhecida system.web.extensions". erro, tente adicionar isso ao seu web.config na <ConfigSections>seção:

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

você pode escrever esta linha no Controller

json.MaxJsonLength = 2147483644;

você também pode escrever esta linha em web.config

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

`

Para estar do lado seguro, use os dois.

Se você estiver recebendo esse erro do MiniProfiler no MVC, poderá aumentar o valor configurando a propriedade MiniProfiler.Settings.MaxJsonResponseSizepara o valor desejado. Por padrão, essa ferramenta parece ignorar o valor definido na configuração.

MiniProfiler.Settings.MaxJsonResponseSize = 104857600;

Cortesia do mvc-mini-profiler .

Basta definir a propriedade MaxJsonLength no método Action do MVC

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

Sugiro configurá-lo para Int32.MaxValue.

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

Que tal algum 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;
            }
        }
    }
}

Em seguida, você pode aplicá-lo globalmente usando a configuração de filtro global ou o controlador / ação.

A questão realmente é se você realmente precisa retornar 17k registros? Como você planeja lidar com todos os dados no navegador? Os usuários não vão rolar pelas 17000 linhas de qualquer maneira.

Uma abordagem melhor é recuperar apenas os "poucos poucos" registros e carregar mais conforme necessário.

Você pode configurá-lo na configuração, como já foi dito, ou em uma instância individual do serializador, como:

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

Para aqueles que estão tendo problemas no MVC3 com JSON que estão sendo desserializados automaticamente para um fichário de modelo e são muito grandes, aqui está uma solução.

1. Copie o código da classe JsonValueProviderFactory do código-fonte MVC3 para uma nova classe.
2. Adicione uma linha para alterar o comprimento máximo do JSON antes que o objeto seja desserializado.
3. Substitua a classe JsonValueProviderFactory pela sua nova classe modificada.

Agradeço a http://blog.naver.com/techshare/100145191355 e https://gist.github.com/DalSoft/1588818 por me indicar a direção certa de como fazer isso. O último link no primeiro site contém o código fonte completo da solução.

Se você encontrar esse tipo de problema no modo de exibição, use o método abaixo para resolver isso. Aqui usei o pacote 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 não há valor "ilimitado". O padrão é 2097152 caracteres, o que equivale a 4 MB de dados da cadeia Unicode.

Como já foi observado, 17.000 registros são difíceis de usar bem no navegador. Se você estiver apresentando uma exibição agregada, pode ser muito mais eficiente fazer a agregação no servidor e transferir apenas um resumo no navegador. Por exemplo, considere um navegador de sistema de arquivos, vemos apenas o topo da árvore e emitimos solicitações adicionais à medida que expandimos. O número de registros retornados em cada solicitação é comparativamente pequeno. Uma apresentação em exibição em árvore pode funcionar bem para grandes conjuntos de resultados.

Apenas me deparei com isso. Estou recebendo mais de 6.000 registros. Acabei de decidir que faria apenas uma paginação. Por exemplo, aceito um número de página no meu ponto de extremidade MVC JsonResult, que é padronizado como 0, portanto não é necessário, como:

public JsonResult MyObjects(int pageNumber = 0)

Então, em vez de dizer:

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

Eu digo:

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

É muito simples. Então, em JavaScript, em vez disso:

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

Em vez disso, 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
}

E anexe seus registros ao que você estava fazendo com eles em primeiro lugar. Ou apenas espere até que todas as chamadas terminem e junte os resultados.

Resolvi o problema adicionando 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();

Correção alternativa do ASP.NET MVC 5:

(A minha é semelhante à resposta dos MFCs acima com algumas pequenas alterações)

Ainda não estava pronto para mudar para o Json.NET e, no meu caso, o erro estava ocorrendo durante a solicitação. A melhor abordagem no meu cenário foi modificar o real JsonValueProviderFactoryque aplica a correção ao projeto global e pode ser feito editando o global.csarquivo como tal.

JsonValueProviderConfig.Config(ValueProviderFactories.Factories);

adicione uma entrada web.config:

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

e crie as duas classes a seguir

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

Esta é basicamente uma cópia exata da implementação padrão encontrada em, System.Web.Mvcmas com a adição de um valor configurável para o conjunto de aplicativos 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;
    }
}

Solução para o WebForms UpdatePanel:

Adicione uma configuração ao Web.config:

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

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

ScriptRegistrationManager A classe contém o seguinte 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);

Não precisamos de nenhuma alteração no lado do servidor. você pode corrigir isso apenas modificar pelo arquivo web.config Isso me ajudou. tente isso

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

usar lib\Newtonsoft.Json.dll

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

Correção para o ASP.NET MVC: se você deseja corrigi-lo apenas para uma ação específica que está causando o problema, codifique assim:

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

você pode mudar para isso:

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

E a funcionalidade deve ser a mesma, você pode retornar JSON maior como resposta.

Explicação baseada no código-fonte do ASP.NET MVC: você pode verificar o que o Controller.Jsonmétodo faz no código-fonte do ASP.NET MVC

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

Está chamando outro 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
    };
}

onde passado contentTypee contentEncodingobjeto estão null. Então, basicamente, chamar o return Json(object)controlador é equivalente a chamar return new JsonResult { Data = object, JsonRequestBehavior = sonRequestBehavior.DenyGet }. Você pode usar o segundo formulário e parametrizar JsonResult.

Então, o que acontece quando você define a MaxJsonLengthpropriedade (por padrão, é nula)? É passado para a JavaScriptSerializer.MaxJsonLengthpropriedade e o JavaScriptSerializer.Serializemétodo é chamado :

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

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

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

E quando você não definir MaxJsonLenghtpropriedade de serializer então ele toma valor padrão que é apenas 2MB.

se esse valor maxJsonLength é um int, então qual é o tamanho dele?

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

Você não precisa fazer web.config Você pode usar a propriedade short durante o valor catch da lista de aprovação. Por exemplo, declare um 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
}

aqui eu uso pequenas propriedades como BC = código de barras BE = edição de livros e assim por diante