Während Ajax-Post in mvc4 mit großen Datenmengen das System wirft System.ArgumentException Ausnahme

Question

ich Ajax Post tue die Daten von Javascript in mvc4 zu schreiben, aber es scheitert mit Ausnahme folgenden

string exceeds the value set on the maxJsonLength property. 
Parameter name: input 
System.ArgumentException: Error during serialization or deserialization using the JSON JavaScriptSerializer. The length of the string exceeds the value set on the maxJsonLength property. 

Ich habe bereits versucht, die Einstellung Konfigurationen in Web-Config, aber es funktioniert nicht

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

ich auch unter Link versucht, aber nichts funktioniert: http://forums.asp.net/t/1751116.aspx?How+to+increase+maxJsonLength+for+JSON+POST+in+MVC3

var editorText = eval(htmlEditor).GetHtml();  
$.ajax({type: 'POST', 
    cache: false, 
    contentType: 'application/json; charset=utf-8', 
    url: "../Home/SaveExceptionLetter", 
    data: JSON.stringify({ message: editorText }), 
    datatype: 'json', 
    success: function() { 
    }); 
} }); 

[HttpPost] 
[ValidateInput(false)] 
public void SaveExceptionLetter(string message){ 
    //processing this message 
} 

string exceeds the value set on the maxJsonLength property. 
Parameter name: input 
System.ArgumentException: Error during serialization or deserialization using the JSON JavaScriptSerializer. The length of the string exceeds the value set on the maxJsonLength property. 
Parameter name: input 
    at System.Web.Script.Serialization.JavaScriptSerializer.Deserialize(JavaScriptSerializer serializer, String input, Type type, Int32 depthLimit) 
    at System.Web.Mvc.JsonValueProviderFactory.GetDeserializedObject(ControllerContext controllerContext) 
    at System.Web.Mvc.JsonValueProviderFactory.GetValueProvider(ControllerContext controllerContext) 
    at System.Web.Mvc.ValueProviderFactoryCollection.<>c__DisplayClassc.<GetValueProvider>b__7(ValueProviderFactory factory) 
    at System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext() 
    at System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext() 
    at System.Collections.Generic.List`1..ctor(IEnumerable`1 collection) 
    at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source) 
    at System.Web.Mvc.ValueProviderFactoryCollection.GetValueProvider(ControllerContext controllerContext) 
    at System.Web.Mvc.ControllerBase.get_ValueProvider() 
    at System.Web.Mvc.ControllerActionInvoker.GetParameterValue(ControllerContext controllerContext, ParameterDescriptor parameterDescriptor) 
    at System.Web.Mvc.ControllerActionInvoker.GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor) 
    at System.Web.Mvc.Async.AsyncControllerActionInvoker.<>c__DisplayClass25.<BeginInvokeAction>b__1e(AsyncCallback asyncCallback, Object asyncState) 

Answer 1

gibt es eine andere Einstellung in web.config, die Sie versuchen können, zu erhöhen:

<system.web> 
    // the default request size is 4096 KB (4 MB) this will increase it to 100 MB 
    <httpRuntime targetFramework="4.5" maxRequestLength="102400" /> 
<system.web> 

Answer 2

Hallo @usFarswan das ist genau das, was ich über nur eine halbe Stunde vor kam, und die Lösung ist http://forums.asp.net/t/1751116.aspx?How+to+increase+maxJsonLength+for+JSON+POST+in+MVC3

Und Sie können es so implementieren, in global.asax fügen Sie die folgenden Zeilen von /// *****.

namespace MyWebApp 
{ 
    // Note: For instructions on enabling IIS6 or IIS7 classic mode, 
    // visit http://go.microsoft.com/?LinkId=9394801 
    public class MvcApplication : System.Web.HttpApplication 
    { 
     protected void Application_Start() 
     { 
      AreaRegistration.RegisterAllAreas(); 


      WebApiConfig.Register(GlobalConfiguration.Configuration); 
      FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); 
      RouteConfig.RegisterRoutes(RouteTable.Routes); 
      XmlConfigurator.Configure(); 
      DbHelper.getSessionFactory(); 

      ///// ********** 
      JsonValueProviderFactory jsonValueProviderFactory = null; 

      foreach (var factory in ValueProviderFactories.Factories) 
      { 
       if (factory is JsonValueProviderFactory) 
       { 
        jsonValueProviderFactory = factory as JsonValueProviderFactory; 
       } 
      } 

      //remove the default JsonVAlueProviderFactory 
      if (jsonValueProviderFactory != null) ValueProviderFactories.Factories.Remove(jsonValueProviderFactory); 

      //add the custom one 
      ValueProviderFactories.Factories.Add(new CustomJsonValueProviderFactory());** 
     /////************* 
     } 
    } 




    ///******** 
    public sealed class CustomJsonValueProviderFactory : ValueProviderFactory 
    { 

     private static void AddToBackingStore(Dictionary<string, object> backingStore, string prefix, object value) 
     { 
      IDictionary<string, object> d = value as IDictionary<string, object>; 
      if (d != null) 
      { 
       foreach (KeyValuePair<string, object> entry in d) 
       { 
        AddToBackingStore(backingStore, MakePropertyKey(prefix, entry.Key), entry.Value); 
       } 
       return; 
      } 

      IList l = value as IList; 
      if (l != null) 
      { 
       for (int i = 0; i < l.Count; i++) 
       { 
        AddToBackingStore(backingStore, MakeArrayKey(prefix, i), l[i]); 
       } 
       return; 
      } 

      // primitive 
      backingStore[prefix] = value; 
     } 

     private static object GetDeserializedObject(ControllerContext controllerContext) 
     { 
      if (!controllerContext.HttpContext.Request.ContentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase)) 
      { 
       // not JSON request 
       return null; 
      } 

      StreamReader reader = new StreamReader(controllerContext.HttpContext.Request.InputStream); 
      string bodyText = reader.ReadToEnd(); 
      if (String.IsNullOrEmpty(bodyText)) 
      { 
       // no JSON data 
       return null; 
      } 

      JavaScriptSerializer serializer = new JavaScriptSerializer(); 
      serializer.MaxJsonLength = int.MaxValue; //increase MaxJsonLength. This could be read in from the web.config if you prefer 
      object jsonData = serializer.DeserializeObject(bodyText); 
      return jsonData; 
     } 

     public override IValueProvider GetValueProvider(ControllerContext controllerContext) 
     { 
      if (controllerContext == null) 
      { 
       throw new ArgumentNullException("controllerContext"); 
      } 

      object jsonData = GetDeserializedObject(controllerContext); 
      if (jsonData == null) 
      { 
       return null; 
      } 

      Dictionary<string, object> backingStore = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); 
      AddToBackingStore(backingStore, String.Empty, jsonData); 
      return new DictionaryValueProvider<object>(backingStore, CultureInfo.CurrentCulture); 
     } 

     private static string MakeArrayKey(string prefix, int index) 
     { 
      return prefix + "[" + index.ToString(CultureInfo.InvariantCulture) + "]"; 
     } 

     private static string MakePropertyKey(string prefix, string propertyName) 
     { 
      return (String.IsNullOrEmpty(prefix)) ? propertyName : prefix + "." + propertyName; 
     } 
    } 
    ///************* 
}