it-swarm.com.de

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

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

Ausnahmeinformationen:
Ausnahmetyp: InvalidOperationException
Ausnahmemeldung: Fehler bei 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 maxJsonLength in web.config festlegen? Wenn nicht, welche maximale Länge kann ich einstellen?

634
Prasad

ANMERKUNG: Diese Antwort gilt nur für Webdienste. Wenn Sie JSON von einer Controller-Methode zurückgeben, stellen Sie sicher, dass Sie dieses SO lesen. Beantworten Sie auch unten: https://stackoverflow.com/a/7207539/124687


Die MaxJsonLength -Eigenschaft kann nicht unbegrenzt sein. Dies ist eine Ganzzahleigenschaft, die standardmäßig 102400 (100 KB) enthält.

Sie können die MaxJsonLength-Eigenschaft in Ihrer web.config festlegen:

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

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


Wenn Sie immer noch den Fehler erhalten:

  • nach dem Setzen der Eigenschaft maxJsonLength auf den Maximalwert in web.config
  • und Sie wissen, dass die Länge Ihrer Daten diesen Wert unterschreitet
  • und Sie verwenden keine Webservice-Methode 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 berücksichtigt das "interne" JavaScriptSerializer den Wert von maxJsonLength, wenn es von einer Webmethode aufgerufen wird. Die direkte Verwendung von JavaScriptSerializer (oder die Verwendung über eine MVC-Aktionsmethode/einen MVC-Controller) respektiert nicht die Eigenschaft maxJsonLength. Zumindest nicht aus dem Abschnitt systemWebExtensions.scripting.webServices.jsonSerialization von 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 von diese asp.net Forum Antwort .

441
David Murdoch

In MVC 4 können Sie:

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.

Ergänzung:

Für alle, die mit den Parametern, die Sie angeben müssen, verwirrt sind, könnte ein Aufruf folgendermaßen aussehen:

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

Sie können die maximale Länge für JSON-Anforderungen in Ihrer web.config-Datei 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

58
M4N

Ich hatte dieses Problem in ASP.NET Web Forms. Die Einstellungen der Datei web.config wurden vollständig ignoriert.

        JavaScriptSerializer serializer = new JavaScriptSerializer();

        serializer.MaxJsonLength = Int32.MaxValue; 

        return serializer.Serialize(response);

Natürlich ist dies insgesamt eine schreckliche Praxis. Wenn Sie so viele Daten in einem Webservice-Aufruf senden, sollten Sie einen anderen Ansatz wählen.

33
Flea

wenn nach der Einstellung von web.config immer noch eine Fehlermeldung angezeigt wird, wie folgt:

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

29
Ravi Anand

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.

21
Mario Arrieta

Ich folgte Vestigals Antwort und kam zu dieser Lösung:

Wenn ich einen großen JSON-Wert an eine Aktion in einem Controller senden musste, wurde der bekannte 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 Value Provider ".

Ich habe eine neue ValueProviderFactory, LargeJsonValueProviderFactory, erstellt und die 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);
}
17
MFA

wenn Sie nach der Implementierung des obigen Zusatzes in Ihrer web.config den Fehler "Unbekannter Konfigurationsabschnitt system.web.extensions" erhalten, versuchen Sie, diesen zu Ihrer web.config im Abschnitt <ConfigSections> 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>
16
bkdraper

sie können diese Zeile in Controller schreiben

json.MaxJsonLength = 2147483644;

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

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

`

Verwenden Sie aus Sicherheitsgründen beide.

10
Pankaj Sapkal

Wenn Sie diese Fehlermeldung vom MiniProfiler in MVC erhalten, können Sie den Wert erhöhen, indem Sie die Eigenschaft MiniProfiler.Settings.MaxJsonResponseSize auf 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 .

9
WolfyUK

Legen Sie einfach die MaxJsonLength-Eigenschaft in der MVC-Aktionsmethode fest

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

Wie wäre es mit etwas Attribut Magie?

[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 Steuerung/Aktion anwenden.

7
Balázs

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

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

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 "besten" Datensätze abzurufen und nach Bedarf mehr zu laden.

4
Chetan Sastry

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

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

Für diejenigen, die Probleme mit MVC3 mit JSON haben, das automatisch für einen Model Binder 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 für den Hinweis in die richtige Richtung wie das geht. Der letzte Link auf der ersten Site enthält den vollständigen Quellcode für die Lösung.

3
vestigal

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

Wie bereits festgestellt, sind 17.000 Datensätze im Browser nur schwer zu verwenden. Wenn Sie eine aggregierte Ansicht anzeigen, ist es möglicherweise effizienter, die Aggregation auf dem Server durchzuführen und nur eine Zusammenfassung im Browser zu übertragen. Betrachten wir beispielsweise einen Dateisystem-Browser, sehen wir nur den oberen Rand des Baums und senden weitere Anfragen, während wir einen Drilldown durchführen. Die Anzahl der in jeder Anforderung zurückgegebenen Datensätze ist vergleichsweise gering. Eine Baumansicht-Präsentation eignet sich gut für große Ergebnismengen.

2
djna

Ich habe das Problem gelöst, indem ich diesen Code hinzugefügt habe:

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

Wenn Sie auf ein solches Problem in View stoßen, können Sie es mit der folgenden Methode beheben. Hier habe ich Newtonsoft Paket verwendet.

@using Newtonsoft.Json
<script type="text/javascript">
    var partData = @Html.Raw(JsonConvert.SerializeObject(ViewBag.Part));
</script>
2
dush88c

Ich bin nur darauf gestoßen. Ich bekomme über 6.000 Platten. Habe gerade beschlossen, dass ich nur ein bisschen paging mache. Wie in akzeptiere ich eine Seitenzahl in meinem MVC JsonResult-Endpunkt, die standardmäßig auf 0 gesetzt ist, sodass dies nicht erforderlich ist.

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 in JavaScript stattdessen:

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 Aufzeichnungen an das an, was Sie mit ihnen gemacht haben. Oder warten Sie einfach, bis alle Anrufe beendet sind, und fassen Sie die Ergebnisse zusammen.

2
vbullinger

Alternativer ASP.NET MVC 5 Fix:

(Meins ähnelt der obigen Antwort von MFCs 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 aktuellen JsonValueProviderFactory, wodurch die Korrektur auf das globale Projekt angewendet wird. Dies kann durch Bearbeiten der global.cs -Datei als solche erfolgen.

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.Mvc, jedoch mit dem Zusatz eines konfigurierbaren web.config-Appset-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;
    }
}
1

Wir brauchen keine serverseitigen Änderungen. Sie können diese Änderung nur durch die Datei web.config beheben Dies hat mir geholfen. probier das 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>
0

benutze lib\Newtonsoft.Json.dll

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

Lösung für WebForms UpdatePanel:

Fügen Sie eine Einstellung zu Web.config hinzu:

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

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

Die Klasse ScriptRegistrationManager 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);
0
Der_Meister