Czy mogę ustawić nieograniczoną długość dla maxJsonLength w web.config?

Korzystam z funkcji autouzupełniania jQuery. Kiedy próbuję pobrać listę ponad 17000 rekordów (każda nie będzie miała więcej niż 10 znaków), przekracza ona długość i zgłasza błąd:

Informacje o wyjątku:
Typ wyjątku: InvalidOperationException
Komunikat o wyjątku: Błąd podczas serializacji lub deserializacji przy użyciu JSON JavaScriptSerializer. Długość łańcucha przekracza wartość ustawioną we właściwości maxJsonLength.

Czy mogę ustawić nieograniczoną długość dla maxJsonLengthw web.config? Jeśli nie, jaka jest maksymalna długość, którą mogę ustawić?

UWAGA: ta odpowiedź dotyczy tylko usług sieciowych, jeśli zwracasz JSON z metody kontrolera, pamiętaj również o przeczytaniu poniższej SO: https://stackoverflow.com/a/7207539/1246870

Właściwość MaxJsonLength nie może być nieograniczona, jest to liczba całkowita, której domyślna wartość to 102400 (100k).

Możesz ustawić MaxJsonLengthwłaściwość na swoim web.config:

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

Jeśli używasz MVC 4 , koniecznie sprawdź również tę odpowiedź .

Jeśli nadal pojawia się błąd:

• po ustawieniu maxJsonLengthmaksymalnej wartości właściwości w pliku web.config
• i wiesz, że długość twoich danych jest mniejsza niż ta wartość
• i nie używasz metody usługi sieciowej do serializacji JavaScript

Twój problem prawdopodobnie:

Wartość właściwości MaxJsonLength dotyczy tylko wewnętrznej instancji JavaScriptSerializer używanej przez asynchroniczną warstwę komunikacyjną do wywoływania metod usług WWW. ( MSDN: Właściwość ScriptingJsonSerializationSection.MaxJsonLength )

Zasadniczo „wewnętrzny” JavaScriptSerializerszanuje wartość maxJsonLengthwywołania z metody internetowej; bezpośrednie użycie JavaScriptSerializer(lub użycie za pomocą metody akcji / kontrolera MVC) nie szanuje maxJsonLengthwłaściwości, przynajmniej nie z systemWebExtensions.scripting.webServices.jsonSerializationsekcji web.config.

Aby obejść ten problem, w kontrolerze (lub w dowolnym innym miejscu) możesz wykonać następujące czynności:

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;

Ta odpowiedź jest moją interpretacją odpowiedzi na forum asp.net .

W MVC 4 możesz:

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

w twoim kontrolerze.

Dodanie:

Dla każdego, kto jest zaskoczony parametrami, które musisz określić, połączenie może wyglądać następująco:

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

Możesz skonfigurować maksymalną długość żądań json w pliku web.config:

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

Domyślna wartość parametru maxJsonLength to 102400 . Aby uzyskać więcej informacji, zobacz tę stronę MSDN: http://msdn.microsoft.com/en-us/library/bb763183.aspx

jeśli po ustawieniu pliku web.config nadal pojawia się błąd, taki jak:

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

Rozwiązałem to, wykonując następujące czynności:

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

Mam nadzieję, że to powinno pomóc.

Miałem ten problem w formularzach sieci Web ASP.NET. Całkowicie ignorowałem ustawienia pliku web.config, więc zrobiłem to:

        JavaScriptSerializer serializer = new JavaScriptSerializer();

        serializer.MaxJsonLength = Int32.MaxValue; 

        return serializer.Serialize(response);

Oczywiście ogólnie jest to okropna praktyka. Jeśli wysyłasz tyle danych w ramach połączenia z serwisem internetowym, powinieneś spojrzeć na inne podejście.

Naprawiłem to.

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

Pracuje bardzo dobrze.

Postępowałem zgodnie z odpowiedzią szczątkowego i znalazłem rozwiązanie:

Gdy potrzebowałem wysłać dużego jsona do akcji w kontrolerze, otrzymałem słynny „Błąd podczas deserializacji za pomocą JSON JavaScriptSerializer. Długość łańcucha przekracza wartość ustawioną we właściwości maxJsonLength. \ R \ n Nazwa parametru: input dostawca wartości ”.

Utworzyłem nową ValueProviderFactory, LargeJsonValueProviderFactory i ustawiłem MaxJsonLength = Int32.MaxValue w metodzie 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;
     }
  }
}

Następnie w metodzie Application_Start z Global.asax.cs zamień ValueProviderFactory na nową:

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

jeśli po zaimplementowaniu powyższego dodatku w pliku web.config pojawi się „Nierozpoznana sekcja konfiguracji system.web.extensions”. błąd, a następnie spróbuj dodać to do pliku web.config w <ConfigSections>sekcji:

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

możesz napisać ten wiersz w kontrolerze

json.MaxJsonLength = 2147483644;

możesz również napisać ten wiersz w web.config

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

`

Aby być bezpiecznym, użyj obu.

Jeśli otrzymujesz ten błąd z MiniProfiler w MVC, możesz zwiększyć wartość, ustawiając właściwość MiniProfiler.Settings.MaxJsonResponseSizena pożądaną wartość. Domyślnie to narzędzie wydaje się ignorować wartość ustawioną w config.

MiniProfiler.Settings.MaxJsonResponseSize = 104857600;

Dzięki uprzejmości mini-profilera mvc .

Wystarczy ustawić właściwość MaxJsonLength w metodzie Action MVC

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

Sugeruję ustawienie go na Int32.MaxValue.

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

Co powiesz na magię atrybutów?

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

Następnie możesz zastosować go globalnie, używając globalnej konfiguracji filtra lub kontrolera / akcji.

Pytanie naprawdę brzmi, czy naprawdę musisz zwrócić 17k rekordów? Jak zamierzasz obsługiwać wszystkie dane w przeglądarce? Użytkownicy i tak nie będą przewijać 17000 wierszy.

Lepszym podejściem jest pobranie tylko „kilku pierwszych” rekordów i załadowanie większej liczby zgodnie z wymaganiami.

Możesz ustawić go w konfiguracji, jak powiedzieli inni, lub możesz ustawić indywidualne wystąpienie serializatora, takie jak:

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

Dla tych, którzy mają problemy z MVC3 z JSON, który jest automatycznie usuwany z postaci szeregowej dla segregatora modeli i jest zbyt duży, oto rozwiązanie.

1. Skopiuj kod klasy JsonValueProviderFactory z kodu źródłowego MVC3 do nowej klasy.
2. Dodaj wiersz, aby zmienić maksymalną długość JSON przed zdekrializowaniem obiektu.
3. Zastąp klasę JsonValueProviderFactory nową, zmodyfikowaną klasą.

Dzięki http://blog.naver.com/techshare/100145191355 i https://gist.github.com/DalSoft/1588818 za wskazanie mi właściwego kierunku, jak to zrobić. Ostatni link na pierwszej stronie zawiera pełny kod źródłowy rozwiązania.

Jeśli napotykasz tego rodzaju problem w widoku, możesz go rozwiązać, korzystając z poniższej metody. Tutaj użyłem pakietu 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;

Wygląda na to, że nie ma wartości „nieograniczonej”. Domyślnie jest to 2097152 znaków, co odpowiada 4 MB ciągów znaków Unicode.

Jak już zaobserwowano, 17 000 rekordów jest trudnych w użyciu w przeglądarce. Jeśli prezentujesz widok zagregowany, może być znacznie bardziej wydajne wykonanie agregacji na serwerze i przesłanie tylko podsumowania w przeglądarce. Na przykład, rozważmy przeglądarkę systemu plików, widzimy tylko górę drzewa, a następnie wysyłamy kolejne żądania podczas drążenia w dół. Liczba rekordów zwracanych w każdym żądaniu jest stosunkowo niewielka. Prezentacja widoku drzewa może dobrze działać w przypadku dużych zestawów wyników.

Właśnie na to wpadłem. Dostaję ponad 6000 rekordów. Właśnie zdecydowałem, że zrobię trochę stronicowania. W chwili obecnej akceptuję numer strony w moim punkcie końcowym MVC JsonResult, który jest domyślnie ustawiony na 0, więc nie jest to konieczne, na przykład:

public JsonResult MyObjects(int pageNumber = 0)

Następnie zamiast mówić:

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

Mówię:

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

To jest bardzo proste. Następnie w JavaScript zamiast tego:

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

Zamiast tego mówię:

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

I w pierwszej kolejności dołączaj swoje nagrania do wszystkiego, co z nimi robiłeś. Lub po prostu poczekaj, aż wszystkie połączenia zakończą się i połącz wyniki razem.

Rozwiązałem problem dodając ten kod:

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

Alternatywna poprawka ASP.NET MVC 5:

(Mój jest podobny do powyższej odpowiedzi MFC z kilkoma małymi zmianami)

Nie byłem jeszcze gotowy na przejście na Json.NET i w moim przypadku błąd występował podczas żądania. Najlepszym podejściem w moim scenariuszu było zmodyfikowanie tego, JsonValueProviderFactoryktóry stosuje poprawkę do projektu globalnego i można tego dokonać, edytując global.csplik jako taki.

JsonValueProviderConfig.Config(ValueProviderFactories.Factories);

dodaj wpis web.config:

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

a następnie utwórz dwie następujące klasy

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

Jest to w zasadzie dokładna kopia domyślnej implementacji znaleziona w, System.Web.Mvcale z dodaną konfigurowalną wartością ustawienia 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;
    }
}

Rozwiązanie dla WebForms UpdatePanel:

Dodaj ustawienie do Web.config:

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

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

ScriptRegistrationManager klasa zawiera następujący kod:

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

Nie potrzebujemy żadnych zmian po stronie serwera. możesz to naprawić tylko modyfikując za pomocą pliku web.config Pomogło mi to. wypróbuj to

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

posługiwać się lib\Newtonsoft.Json.dll

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

Naprawa dla ASP.NET MVC: jeśli chcesz to naprawić tylko dla określonej akcji powodującej problem, napisz następujący kod:

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

możesz to zmienić:

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

A funkcjonalność powinna być taka sama, możesz po prostu zwrócić większy JSON jako odpowiedź.

Objaśnienie oparte na kodzie źródłowym ASP.NET MVC: możesz sprawdzić, co Controller.Jsonrobi metoda w kodzie źródłowym ASP.NET MVC

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

Wywołuje inną Controller.Jsonmetodę:

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

gdzie są przekazywane contentTypei contentEncodingobiekt null. Więc w zasadzie wywołanie return Json(object)kontrolera jest równoważne z wywołaniem return new JsonResult { Data = object, JsonRequestBehavior = sonRequestBehavior.DenyGet }. Możesz użyć drugiego formularza i sparametryzować JsonResult.

Co się stanie, gdy ustawisz MaxJsonLengthwłaściwość (domyślnie jest ona pusta)? Jest przekazywany do JavaScriptSerializer.MaxJsonLengthwłaściwości, a następnie wywoływanaJavaScriptSerializer.Serialize jest metoda :

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

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

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

A jeśli nie ustawisz MaxJsonLenghtwłaściwości serializatora, wówczas przyjmuje ona wartość domyślną, która wynosi zaledwie 2 MB.

jeśli ta wartość maxJsonLength jest liczbą int, to jak duża jest jej int 32bit / 64bit / 16bit .... chcę tylko mieć pewność, jaką maksymalną wartość mogę ustawić jako moją maksymalną długość

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

Nie musisz robić z web.config Możesz użyć krótkiej właściwości podczas wartości catch listy przechodzącej Na przykład zadeklaruj model jak

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
}

tutaj używam krótkich proporcji, takich jak BC = kod kreskowy BE = wydanie książki i tak dalej