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

662

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?

Prasad
quelle
1
Etwas zu erwähnen, das ziemlich offensichtlich sein kann. Entschuldigen Sie mich bitte, wenn Sie bereits darüber nachgedacht haben. Die Json-Zeichenfolge enthält auch die geschweiften Klammern um jeden Datensatz, die Anführungszeichen um jeden Feldnamen [und Wert] sowie den Feldnamen und den Wert. Daher kann es nützlich sein, den Feldnamen als einzelnes Zeichen festzulegen und sicherzustellen, dass Sie den Feldtyp korrekt festlegen, wenn der Wert keine Zeichenfolge ist, damit er keine Anführungszeichen enthält.
MichaelJTaylor

Antworten:

719

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> 
CMS
quelle
153
Es ist eine ganze Zahl, so dass der maximale Wert, den Sie einstellen können, ist: 2147483644
David Espart
57
@despart: Du meinst 2 147 483 647.
Dercsár
6
@ kmcc049, IMO, die Werte sind nicht falsch, denn wenn Sie sich die Frage ansehen, fragt das OP nicht "Was ist der Standardwert von maxJsonLength?" (Übrigens, die zweithäufigste Antwort ist die Beantwortung dieser falschen Frage.) Er versucht, diese Eigenschaft auf "unbegrenzt" zu setzen. Da es sich jedoch um eine Ganzzahl handelt, ist der maximal mögliche Wert 2147483647wie bei @depsart und @ Descár angegeben.
CMS
11
Großartig, aber beachten Sie die Antwort von @David Murdoch unten, wenn Sie dieses Problem haben, wenn Sie return Json()
MVCs
3
@ Dercsár: Worum geht es? 2147483644 ist die größte Ganzzahl, die durch 1024 perfekt teilbar ist.
Naveen
460

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 .

David Murdoch
quelle
5
Ihre Antwort war wirklich hilfreich, da ich die Json()Aktionsergebnismethode in asp.net mvc verwende.
Jessegavin
3
Ja, ich war ein Json () leiden auch. Vielen Dank!
BritishDeveloper
3
Obwohl es völlig korrekt ist und seinen Platz verdient, ist dies eine dieser Fragen, bei denen es sich lohnt, über die Top-Antwort hinaus zu lesen :). Vielen Dank!
Nigel
3
Wenn Sie MVC4 verwenden, lesen Sie bitte auch die Antwort von @fanisch.
Beyers
4
Wie wäre es mit Deserialisierung? Ich habe diesen Fehler bei der Modellbindung der Aktion festgestellt.
Guogangj
345

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
);
fanisch
quelle
6
Ich kann bestätigen, dass das oben genannte wie ein Zauber in MVC 4 funktioniert, danke fanisch.
Beyers
9
Ich kann es auch bestätigen. Das Einfügen dieses Codes in einen Basis-Controller ist definitiv der sauberste vorgeschlagene Ansatz.
Parlament
15
Dies funktioniert auch, indem nur "MaxJsonLength = Int32.MaxValue" zum Ergebnis der einzelnen Aktion hinzugefügt wird. Falls die Änderung nicht erwünscht ist, steuern oder projektweit.
Hypnovirus
3
Dies ist die beste Antwort. Die MaxJsonLength kann pro Controller konfiguriert werden.
Liang
3
WARNUNG: Diese Lösung deaktiviert die Komprimierung (falls angefordert) der Antwort. Fügen Sie diesen Filter zu Ihrer Aktion hinzu: stackoverflow.com/questions/3802107/…
Gorgi Rankovski
60

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

M4N
quelle
1
Was repräsentiert der in dieser Ganzzahl gespeicherte Wert? Ist das eine Art Charakterzählung? Ich denke, was ich frage ist, warum eine ganze Zahl verwendet wird? Vielen Dank!
eaglei22
@ eaglei22 Die Zahl gibt an, wie viele Bytes für die maxJsonLength verwendet werden können. Wie M4N erwähnt, ist 102400 die Standardeinstellung (100 KB).
Jacob Plonke
Dies funktioniert nicht für mich und ich habe keine Webservices verwendet.
Kalai
42

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.

Ravi Anand
quelle
2
Das Festlegen der maxJsonLength in der web.config ist unpassend. Das Festlegen der jsonResult.MaxJsonLength sollte ausreichen (zumindest für mich (MVC5))
Hormberg
Das ist gut, weil es keine globale Veränderung ist.
rob_james
40

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.

Floh
quelle
1
Hat das für dich funktioniert? Wo hast du diesen Code platziert?
user1012598
Unser Problem war, dass wir einen Textbereich hatten, der HTML zuließ, und die Leute Bilder als HTML einbetteten, was dazu führte, dass der Eintrag sehr groß wurde und der JSON-Serializer fehlschlug. Ich denke, wenn es möglich ist, werden Benutzer es tun ...
Marko
Bitte beschreiben Sie, wo wir diesen Code setzen sollen ... @Flea
Koray Durudogan
@KorayDurudogan - Ich habe dies in die Ajax-Methode eingefügt, die die Antwort zurückgab, also in meinen Controller. Ich hoffe, das hilft!
Floh
Ich fordere Ihre Antwort nicht heraus, sondern versuche, eine bessere Vorstellung davon zu bekommen, welche besseren Ansätze es gibt. Ich habe eine Abfrage, die abhängig von den Kriterien des Benutzers die Ergebnisgröße bestimmt. Ich gebe ein JsonResult zurück. Wäre es wichtig, wenn ich eine Excel-Datei zurückgeben würde?
eaglei22
22

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.

Mario Arrieta
quelle
Genial! Dies ist die einzige Lösung, die für mich funktioniert hat und die sowieso besser ist, da es sich nicht um eine globale Veränderung handelt. Vielen Dank!
Sealer_05
20

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);
}
MFA
quelle
1
Ich habe alles getan, was ich kann, nur deine Antwort hat meinen Tag gerettet, diese Antwort hätte akzeptiert werden sollen
Muhammad Waqas Aziz
Mit diesem Code können wir das maximale Deserialisierungslimit des MVC-Controllers von 4 MB überschreiben, aber es gibt eine Möglichkeit, das maximale Deserialisierungslimit des Web-API-Controllers zu überschreiben
Muhammad Waqas Aziz
17

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>
bkdraper
quelle
4
Ich hatte dieses Problem. Diese Antwort hat bei mir jedoch nicht funktioniert. Anstatt das hier beschriebene <sectionGroup> -Element hinzuzufügen, habe ich den gesamten neu hinzugefügten <system.web.extensions> -Block ganz vor </ configuration> an das Ende meiner web.config ... verschoben. Dann hat es funktioniert.
ClearCloud8
Dies hat geholfen, aber in meiner Situation musste ich Ihre vierte Zeile ändern <section name="jsonSerialization" type="System.Web.Configuration.ScriptingJsonSerializationSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" allowDefinition="Everywhere"/>, wie auf dieser Seite zu sehen: forums.asp.net/t/1446510.aspx/1
Nathan
@ ClearCloud8 Verbreite diesen Kommentar sofort auf dieser Seite.
Jack Nutkins
11

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.

Pankaj Sapkal
quelle
10

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 .

Wolfyuk
quelle
10

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;
Aftab Ahmed Kalhoro
quelle
9

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

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

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.

Balázs
quelle
Gute Antwort. Gute Verwendung von benutzerdefinierten Attributen. Sie fragen sich, ob es einen bestimmten (technischen) Grund gibt, warum Sie die Standardeinstellung auf 10 MB für 1-Byte-Zeichen anstelle von Max (int.MaxValue) festgelegt haben?
Josh
@ Josh Nein, dafür gab es keinen besonderen Grund.
Balázs
5

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.

Chetan Sastry
quelle
1
Die Standardliste von json enthält 17.000 Datensätze. Die Funktion zur automatischen Vervollständigung listet jedoch nur die Datensätze auf, die den vom Benutzer eingegebenen Zeichen entsprechen, sodass die Liste nicht weiter gescrollt werden muss. Was ich also brauche, ist eine unbegrenzte Länge für maxJsonLength festzulegen, die die 17k-Daten serialisieren kann.
Prasad
6
Sie können eine Kombination aus server- und clientseitiger Filterung verwenden. Es kann schwierig sein, alle Daten auf der Clientseite zu filtern, ganz zu schweigen von der Netzwerklatenz.
Chetan Sastry
1
Nachdem ich vor einiger Zeit zu demselben Problem gekommen war, entschied ich mich, einen "Onsearch" -Handler für die automatische Vervollständigung zu implementieren und den Webdienstaufruf den "Suchtext" weiterleiten zu lassen und eine Top10-Abfrage unter Verwendung der Suchkriterien als Filter durchzuführen. Dies bedeutete mehr individuelle Ajax-Anfragen, als nur die vollständige Liste beim Laden der Seite zu erhalten, aber es bedeutete auch, dass alle Anfragen / Antworten viel kleiner waren.
Mike U
3

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 };
Caleb Postlethwait
quelle
3

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.

Überbleibsel
quelle
3

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>
dush88c
quelle
Bedeutet dies, dass ich mir keine Sorgen um die maximale Länge machen muss, wenn ich Json.NET verwende? Ich glaube nicht, dass es eine Möglichkeit gibt, die maximale Länge in Json.NET festzulegen, also hoffe ich, dass es sofort funktioniert.
Kimbaudi
1
Ausgezeichnete Antwort danke! Dies funktionierte auch, als ich versuchte, ein Objekt zu laden.
user1299379
3
 JsonResult result = Json(r);
 result.MaxJsonLength = Int32.MaxValue;
 result.JsonRequestBehavior = JsonRequestBehavior.AllowGet;
 return result;
Aikansh Mann
quelle
2

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.

djna
quelle
3
Eher bizarrerweise die Standardeinstellung im Code (neuer JavaScriptSerializer ()). MaxJsonLength ist 2097152 Byte, aber der Webdienst ResponseFormatJson ist die 102400 Byte, sofern nicht explizit festgelegt.
Rob
2

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.

vbullinger
quelle
2

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();
jfabrizio
quelle
Dies scheint eine hackige Lösung zu sein, aber trotzdem ein interessanter Ansatz. Ich fand es nützlich, danke! Für mich in apsnet mvc 5 controller musste ich 'Current' aus dem Namespace entfernen. Ich habe ein paar Anpassungen vorgenommen:string confString = HttpContext.Request.ApplicationPath.ToString(); var conf = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration(confString); var section = (System.Web.Configuration.ScriptingJsonSerializationSection)conf.GetSection("system.web.extensions/scripting/webServices/jsonSerialization"); section.MaxJsonLength = int.MaxValue; conf.Save();
ooXei1sh
2

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;
    }
}
Maxim Gershkovich
quelle
1
Danke, es funktioniert ... Vielen Dank @Maxim Gershkovich
Jasper Manickaraj
0

verwenden lib\Newtonsoft.Json.dll

public string serializeObj(dynamic json) {        
    return JsonConvert.SerializeObject(json);
}
Buddhika De Silva
quelle
0

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);
Der_Meister
quelle
0

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>

Isanka Thalagala
quelle
0

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.

Mariusz Pawelski
quelle
-2

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>
mpho isaac Molelle
quelle
-4

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

Md Nazrul Islam
quelle
Dies wird nicht helfen, wenn der Großteil der Daten in den Eigenschaftswerten ist
Fenster