Question Puis-je définir une longueur illimitée pour maxJsonLength dans web.config?


J'utilise la fonctionnalité de saisie semi-automatique de jQuery. Lorsque j'essaie de récupérer la liste de plus de 17000 enregistrements (chacun n'aura pas plus de 10 caractères), cela dépasse la longueur et lance l'erreur:

Informations d'exception:
      Type d'exception: InvalidOperationException
      Message d'exception: Erreur lors de la sérialisation ou de la désérialisation à l'aide du JavaScriptSerializer JSON. La longueur de la chaîne dépasse la valeur définie sur la propriété maxJsonLength.

Puis-je définir une longueur illimitée pour maxJsonLength dans web.config? Si non, quelle est la longueur maximale que je peux définir?


560
2017-07-20 06:38


origine


Réponses:


REMARQUE: cette réponse s'applique uniquement aux services Web, si vous renvoyez JSON à partir d'une méthode de contrôleur, assurez-vous de lire également cette réponse SO ci-dessous: https://stackoverflow.com/a/7207539/1246870


le MaxJsonLength la propriété ne peut pas être illimitée, est une propriété entière dont la valeur par défaut est 102400 (100k).

Vous pouvez définir la propriété MaxJsonLength sur votre web.config:

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

631
2017-07-20 06:43



Si vous utilisez MVC 4, assurez-vous de vérifier cette réponse ainsi que.


Si vous recevez toujours l'erreur:

  • après avoir réglé maxJsonLength propriété à sa valeur maximale dans web.config
  • et vous savez que la longueur de vos données est inférieure à cette valeur
  • et vous n'utilisez pas une méthode de service Web pour la sérialisation JavaScript

votre problème est probable que:

La valeur de la propriété MaxJsonLength s'applique uniquement à l'instance interne JavaScriptSerializer utilisée par la couche de communication asynchrone pour appeler les méthodes de services Web. (MSDN: ScriptingJsonSerializationSection.MaxJsonLength, propriété)

Fondamentalement, le "interne" JavaScriptSerializer respecte la valeur de maxJsonLength lorsqu'il est appelé à partir d'une méthode web; l'utilisation directe d'un JavaScriptSerializer (ou utiliser via une action-méthode / contrôleur MVC) ne pas respecter le maxJsonLength propriété, du moins pas du systemWebExtensions.scripting.webServices.jsonSerialization section de web.config.

Pour contourner le problème, vous pouvez effectuer les opérations suivantes dans votre contrôleur (ou ailleurs):

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;

Cette réponse est mon interprétation de ce forum asp.net répond.


404
2017-08-26 16:04



Dans MVC 4, vous pouvez faire:

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

dans votre contrôleur.


283
2017-09-05 10:03



Vous pouvez configurer la longueur maximale des demandes json dans votre fichier web.config:

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

La valeur par défaut pour maxJsonLength est 102400. Pour plus de détails, consultez cette page MSDN: http://msdn.microsoft.com/en-us/library/bb763183.aspx


57
2017-07-20 06:43



J'avais ce problème dans ASP.NET Web Forms. Il ignorait complètement les paramètres du fichier web.config, donc j'ai fait ceci:

        JavaScriptSerializer serializer = new JavaScriptSerializer();

        serializer.MaxJsonLength = Int32.MaxValue; 

        return serializer.Serialize(response);

Bien sûr, dans l'ensemble, c'est une pratique terrible. Si vous envoyez autant de données dans un appel de service Web, vous devriez envisager une approche différente.


30
2017-08-20 19:34



Je l'ai corrigé.

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

Il fonctionne très bien.


20
2017-10-18 13:27



si vous obtenez toujours une erreur après le réglage de web.config comme suit:    

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

Je l'ai résolu en suivant:

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

J'espère que cela devrait aider.


18
2017-09-19 09:44



si, après avoir implémenté l'ajout ci-dessus dans votre web.config, vous obtenez une erreur "section de configuration non reconnue system.web.extensions.", essayez d'ajouter ceci à votre web.config dans le <ConfigSections> section:

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

15
2018-01-12 00:17



J'ai suivi la réponse de vestigal et suis arrivé à cette solution:

Quand je devais publier un grand json à une action dans un contrôleur, j'obtenais la fameuse "Erreur lors de la désérialisation utilisant le JavaScriptSerializer JSON.La longueur de la chaîne dépasse la valeur définie sur la propriété maxJsonLength. \ R \ nParameter name: input fournisseur de valeur ".

Ce que j'ai fait est de créer une nouvelle ValueProviderFactory, LargeJsonValueProviderFactory, et de définir MaxJsonLength = Int32.MaxValue dans la méthode 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;
    }
}

}

Ensuite, dans la méthode Application_Start de Global.asax.cs, remplacez ValueProviderFactory par le nouveau:

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

12
2018-01-10 17:51