Kann ich in web.config eine unbegrenzte Länge für maxJsonLength festlegen?

Ich verwende die Autocomplete-Funktion von jQuery. Wenn ich versuche, die Liste mit mehr als 17000 Datensätzen abzurufen (jeder hat nicht mehr als 10 Zeichen), überschreitet dies die Länge und löst den Fehler aus:

Ausnahmeinformationen:
Ausnahmetyp: InvalidOperationException
Ausnahmemeldung: Fehler während der Serialisierung oder Deserialisierung mit dem JSON JavaScriptSerializer. Die Länge der Zeichenfolge überschreitet den in der Eigenschaft maxJsonLength festgelegten Wert.

Kann ich eine unbegrenzte Länge für maxJsonLengthin einstellen web.config? Wenn nicht, welche maximale Länge kann ich einstellen?

HINWEIS: Diese Antwort gilt nur für Webdienste. Wenn Sie JSON von einer Controller-Methode zurückgeben, lesen Sie auch diese SO-Antwort unten: https://stackoverflow.com/a/7207539/1246870

Die MaxJsonLength- Eigenschaft kann nicht unbegrenzt sein. Sie ist eine Ganzzahl-Eigenschaft, die standardmäßig 102400 (100 KB) lautet.

Sie können die MaxJsonLengthEigenschaft in Ihrer web.config festlegen:

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

Wenn Sie MVC 4 verwenden , lesen Sie auch diese Antwort .

Wenn Sie immer noch den Fehler erhalten:

• nachdem Sie die maxJsonLengthEigenschaft in web.config auf ihren Maximalwert gesetzt haben
• und Sie wissen, dass die Länge Ihrer Daten kleiner als dieser Wert ist
• und Sie verwenden keine Webdienstmethode für die JavaScript-Serialisierung

Ihr Problem ist wahrscheinlich, dass:

Der Wert der MaxJsonLength-Eigenschaft gilt nur für die interne JavaScriptSerializer-Instanz, die von der asynchronen Kommunikationsschicht zum Aufrufen von Webdienstmethoden verwendet wird. ( MSDN: ScriptingJsonSerializationSection.MaxJsonLength-Eigenschaft )

Grundsätzlich JavaScriptSerializerrespektiert das "interne" den Wert, maxJsonLengthwenn es von einer Webmethode aufgerufen wird; direkte Verwendung von a JavaScriptSerializer(oder der Verwendung über eine MVC action-Methode / Controller) wird nicht respektiert die maxJsonLengthEigenschaft, zumindest nicht aus dem systemWebExtensions.scripting.webServices.jsonSerializationAbschnitt web.config.

Um dieses Problem zu umgehen, können Sie in Ihrem Controller (oder wirklich überall) Folgendes tun:

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;

Diese Antwort ist meine Interpretation dieser Antwort im asp.net-Forum .

In MVC 4 können Sie Folgendes tun:

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

in Ihrem Controller.

Zusatz:

Für alle, die sich nicht sicher sind, welche Parameter Sie angeben müssen, könnte ein Aufruf folgendermaßen aussehen:

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

Sie können die maximale Länge für JSON-Anforderungen in Ihrer Datei web.config konfigurieren:

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

Der Standardwert für maxJsonLength ist 102400 . Weitere Informationen finden Sie auf dieser MSDN-Seite: http://msdn.microsoft.com/en-us/library/bb763183.aspx

Wenn nach der Einstellung von web.config immer noch eine Fehlermeldung angezeigt wird:

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

Ich habe es folgendermaßen gelöst:

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

Ich hoffe das sollte helfen.

Ich hatte dieses Problem in ASP.NET Web Forms. Die Einstellungen der Datei web.config wurden vollständig ignoriert, also habe ich Folgendes getan:

        JavaScriptSerializer serializer = new JavaScriptSerializer();

        serializer.MaxJsonLength = Int32.MaxValue; 

        return serializer.Serialize(response);

Insgesamt ist dies natürlich eine schreckliche Praxis. Wenn Sie so viele Daten in einem Webdienstaufruf senden, sollten Sie einen anderen Ansatz wählen.

Ich habe es repariert.

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

Es funktioniert sehr gut.

Ich folgte der Antwort von Vestigal und kam zu dieser Lösung:

Wenn ich einen großen JSON an eine Aktion in einem Controller senden musste, wurde der berühmte Fehler "Fehler beim Deserialisieren mit dem JSON JavaScriptSerializer" angezeigt. Die Länge der Zeichenfolge überschreitet den in der Eigenschaft maxJsonLength festgelegten Wert. \ R \ nParametername: Eingabe Wertanbieter ".

Ich habe eine neue ValueProviderFactory, LargeJsonValueProviderFactory, erstellt und MaxJsonLength = Int32.MaxValue in der GetDeserializedObject-Methode festgelegt

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

Ersetzen Sie dann in der Application_Start-Methode von Global.asax.cs die ValueProviderFactory durch die neue:

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

Wenn Sie nach der Implementierung des obigen Zusatzes in Ihre web.config einen "Nicht erkannten Konfigurationsabschnitt system.web.extensions" erhalten. Fehler, dann versuchen Sie, dies zu Ihrer web.config im <ConfigSections>Abschnitt hinzuzufügen :

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

Sie können diese Zeile in Controller schreiben

json.MaxJsonLength = 2147483644;

Sie können diese Zeile auch in schreiben web.config

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

`

Verwenden Sie zur Sicherheit beide.

Wenn Sie diesen Fehler vom MiniProfiler in MVC erhalten, können Sie den Wert erhöhen, indem Sie die Eigenschaft MiniProfiler.Settings.MaxJsonResponseSizeauf den gewünschten Wert setzen. Standardmäßig scheint dieses Tool den in config festgelegten Wert zu ignorieren.

MiniProfiler.Settings.MaxJsonResponseSize = 104857600;

Mit freundlicher Genehmigung von mvc-mini-profiler .

Legen Sie einfach die Eigenschaft MaxJsonLength in der Action-Methode von MVC fest

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

Ich schlage vor, es auf Int32.MaxValue zu setzen.

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

Wie wäre es mit einer Attributmagie?

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

Dann können Sie es entweder global mithilfe der globalen Filterkonfiguration oder in Bezug auf Controller / Aktion anwenden.

Die Frage ist wirklich, ob Sie wirklich 17.000 Datensätze zurückgeben müssen. Wie wollen Sie mit allen Daten im Browser umgehen? Die Benutzer werden sowieso nicht durch 17000 Zeilen scrollen.

Ein besserer Ansatz besteht darin, nur die "wenigen" Datensätze abzurufen und bei Bedarf mehr zu laden.

Sie können es in der Konfiguration festlegen, wie andere gesagt haben, oder Sie können eine einzelne Instanz des Serializers wie folgt einrichten:

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

Für diejenigen, die Probleme mit MVON in MVC3 haben, das automatisch für einen Modellordner deserialisiert wird und zu groß ist, ist hier eine Lösung.

1. Kopieren Sie den Code für die JsonValueProviderFactory-Klasse aus dem MVC3-Quellcode in eine neue Klasse.
2. Fügen Sie eine Zeile hinzu, um die maximale JSON-Länge zu ändern, bevor das Objekt deserialisiert wird.
3. Ersetzen Sie die JsonValueProviderFactory-Klasse durch Ihre neue, geänderte Klasse.

Vielen Dank an http://blog.naver.com/techshare/100145191355 und https://gist.github.com/DalSoft/1588818, die mich in die richtige Richtung geführt haben. Der letzte Link auf der ersten Site enthält den vollständigen Quellcode für die Lösung.

Wenn Sie in View auf diese Art von Problem stoßen, können Sie dieses Problem mithilfe der folgenden Methode beheben. Hier habe ich das Newtonsoft- Paket verwendet.

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

Es scheint, dass es keinen "unbegrenzten" Wert gibt. Der Standardwert beträgt 2097152 Zeichen, was 4 MB Unicode-Zeichenfolgendaten entspricht.

Wie bereits erwähnt, sind 17.000 Datensätze im Browser nur schwer gut zu verwenden. Wenn Sie eine Aggregatansicht präsentieren, ist es möglicherweise viel effizienter, die Aggregation auf dem Server durchzuführen und nur eine Zusammenfassung im Browser zu übertragen. Stellen Sie sich zum Beispiel einen Dateisystem-Browser vor. Wir sehen nur den oberen Rand des Baums und senden dann weitere Anfragen, während wir einen Drilldown durchführen. Die Anzahl der in jeder Anforderung zurückgegebenen Datensätze ist vergleichsweise gering. Eine Baumansicht kann für große Ergebnismengen gut funktionieren.

Bin gerade darauf gestoßen. Ich bekomme über 6.000 Platten. Ich habe gerade beschlossen, nur ein bisschen zu pagen. Wie in akzeptiere ich eine Seitenzahl in meinem MVC JsonResult-Endpunkt, die standardmäßig auf 0 gesetzt ist, sodass dies nicht erforderlich ist, wie folgt:

public JsonResult MyObjects(int pageNumber = 0)

Dann anstatt zu sagen:

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

Ich sage:

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

Es ist sehr einfach. Dann stattdessen in JavaScript:

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

Ich sage stattdessen:

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

Und hängen Sie Ihre Unterlagen an alles an, was Sie mit ihnen gemacht haben. Oder warten Sie einfach, bis alle Anrufe beendet sind, und basteln Sie die Ergebnisse zusammen.

Ich habe das Problem beim Hinzufügen dieses Codes gelöst:

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

Alternative ASP.NET MVC 5 Fix:

(Meins ähnelt der Antwort von MFCs oben mit ein paar kleinen Änderungen)

Ich war noch nicht bereit, zu Json.NET zu wechseln, und in meinem Fall trat der Fehler während der Anforderung auf. Der beste Ansatz in meinem Szenario war das Ändern des tatsächlichen Ansatzes, JsonValueProviderFactoryder den Fix auf das globale Projekt anwendet und durch Bearbeiten der global.csDatei als solche erfolgen kann.

JsonValueProviderConfig.Config(ValueProviderFactories.Factories);

Fügen Sie einen web.config-Eintrag hinzu:

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

und erstellen Sie dann die beiden folgenden Klassen

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

Dies ist im Grunde eine exakte Kopie der Standardimplementierung in, System.Web.Mvcjedoch mit dem Zusatz eines konfigurierbaren Web.config-Appsetting-Werts 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;
    }
}

verwenden lib\Newtonsoft.Json.dll

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

Lösung für WebForms UpdatePanel:

Fügen Sie Web.config eine Einstellung hinzu:

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

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

ScriptRegistrationManager Klasse enthält folgenden Code:

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

Wir brauchen keine serverseitigen Änderungen. Sie können dies nur durch die Datei web.config ändern. Dies hat mir geholfen. Probieren Sie es aus

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

Fix für ASP.NET MVC: Wenn Sie das Problem nur für eine bestimmte Aktion beheben möchten, die das Problem verursacht, codieren Sie wie folgt:

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

Sie können dies ändern:

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

Und die Funktionalität sollte gleich sein, Sie können einfach einen größeren JSON als Antwort zurückgeben.

Erläuterung basierend auf dem ASP.NET MVC-Quellcode: Sie können überprüfen, welche Controller.JsonMethode im ASP.NET MVC- Quellcode ausgeführt wird

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

Es ruft eine andere Controller.JsonMethode auf:

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

wo übergeben contentTypeund contentEncodingObjekt sind null. Das Aufrufen return Json(object)des Controllers entspricht also im Grunde dem Aufrufen return new JsonResult { Data = object, JsonRequestBehavior = sonRequestBehavior.DenyGet }. Sie können die zweite Form verwenden und parametrierenJsonResult .

Was passiert also, wenn Sie eine MaxJsonLengthEigenschaft festlegen (standardmäßig ist sie null)? Es ist überliefert, um JavaScriptSerializer.MaxJsonLengthEigentum und dann JavaScriptSerializer.Serializewird Verfahren genannt :

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

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

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

Wenn Sie die MaxJsonLenghtEigenschaft des Serializers nicht festlegen , wird ein Standardwert von nur 2 MB verwendet.

Wenn dieser maxJsonLength-Wert ein int ist, wie groß ist dann sein int 32bit / 64bit / 16bit .... Ich möchte nur sicher sein, was der maximale Wert ist, den ich als meine maxJsonLength festlegen kann

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

Sie müssen nicht mit web.config zu tun haben. Sie können die Eigenschaft short während des Catch-Werts der Übergabeliste verwenden. Deklarieren Sie beispielsweise ein Modell wie

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
}

hier verwende ich kurze Proportionen wie BC = Barcode BE = Buchausgabe und so weiter