提问



我正在使用jQuery的自动完成功能。当我尝试检索超过17000条记录的列表(每条记录不会超过10个字符长度)时,它超出了长度并抛出错误:



  例外信息:

      异常类型:InvalidOperationException

      异常消息:使用JSON JavaScriptSerializer进行序列化或反序列化时出错。字符串的长度超过maxJsonLength属性上设置的值。



我可以在web.config中为maxJsonLength设置无限长度吗?如果没有,我可以设置的最大长度是多少?

最佳参考


注意:此答案仅适用于Web服务,如果您从Controller方法返回JSON,请确保您也阅读以下SO答案:https://stackoverflow.com/a/7207539/1246870





MaxJsonLength属性不能无限制,是一个默认为102400(100k)的整数属性。[53]


您可以在web.config上设置MaxJsonLength属性:


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

其它参考1


如果您使用MVC 4 ,请务必查看此答案。





如果您仍然收到错误:



  • maxJsonLength属性设置为web.config
  • 中的最大值
  • 并且您知道您的数据长度小于此值

  • 并且您没有使用JavaScript序列化的Web服务方法



你的问题很可能是:



  MaxJsonLength属性的值仅适用于异步通信层用于调用Web服务方法的内部JavaScriptSerializer实例。 (MSDN:ScriptingJsonSerializationSection.MaxJsonLength Property) [55]



基本上,内部JavaScriptSerializer在从网络方法调用时尊重maxJsonLength的价值;直接使用JavaScriptSerializer(或通过MVC动作方法/控制器使用)尊重maxJsonLength属性,至少不是systemWebExtensions.scripting.webServices.jsonSerialization部分web.config。


作为解决方法,您可以在Controller(或任何地方)中执行以下操作:


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;





这个答案是我对这个asp.net论坛答案的解释。 [56]

其它参考2


在MVC 4中,您可以:


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


在你的控制器中。

其它参考3


您可以在web.config文件中配置json请求的最大长度:


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


maxJsonLength的默认值为 102400 。有关更多详细信息,请参阅此MSDN页面:http://msdn.microsoft.com/en-us/library/bb763183.aspx [57]

其它参考4


我在ASP.NET Web窗体中遇到了这个问题。它完全忽略了web.config文件设置所以我这样做了:


        JavaScriptSerializer serializer = new JavaScriptSerializer();

        serializer.MaxJsonLength = Int32.MaxValue; 

        return serializer.Serialize(response);


当然总的来说这是一种可怕的做法。如果要在Web服务调用中发送这么多数据,您应该看一下不同的方法。

其它参考5


我修好了它。


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


它工作得很好。

其它参考6


如果在web.config设置之后仍然出现错误,如下所示:
   


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



如果在您的web.config中实现上述添加后,您会收到无法识别的配置部分system.web.extensions。错误,请尝试将此添加到<ConfigSections>部分中的web.config:


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

其它参考7


我跟着vestigal的回答并得到了这个解决方案:


当我需要将一个大的json发布到控制器中的一个动作时,我会在使用JSON JavaScriptSerializer进行反序列化时得到着名的错误。字符串的长度超过了maxJsonLength属性上设置的值。\\ r \\ nParameter name:input价值提供者。


我所做的是创建一个新的ValueProviderFactory,LargeJsonValueProviderFactory,并在GetDeserializedObject方法中设置MaxJsonLength=Int32.MaxValue


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


}


然后,在Global.asax.cs的Application_Start方法中,将ValueProviderFactory替换为新的:


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

其它参考8


你可以把这一行写入Controller


json.MaxJsonLength = 2147483644;


你也可以把这一行写进web.config


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


`


为了安全起见,请同时使用两者。

其它参考9


如果从MVC中的MiniProfiler收到此错误,则可以通过将属性MiniProfiler.Settings.MaxJsonResponseSize设置为所需的值来增加该值。默认情况下,此工具似乎忽略配置中设置的值。[58]


MiniProfiler.Settings.MaxJsonResponseSize = 104857600;


礼貌mvc-mini-profiler。[59]

其它参考10


只需在MVC的Action方法中设置MaxJsonLength proprty


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

其它参考11


我建议将其设置为Int32.MaxValue。


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

其它参考12


一些属性魔法怎么样?


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


然后,您可以使用全局筛选器配置或控制器/操作方式全局应用它。

其它参考13


问题是你是否真的需要返回17k记录?您打算如何处理浏览器中的所有数据?无论如何,用户不会滚动17000行。


更好的方法是仅检索前几个记录并根据需要加载更多。

其它参考14


对于那些在MVC3中遇到问题的人来说,JSON会自动被反序列化为模型绑定器并且太大,这是一个解决方案。



  1. 将MVC3源代码中的JsonValueProviderFactory类的代码复制到新类中。

  2. 添加一行以更改对象反序列化之前的最大JSON长度。

  3. 将JsonValueProviderFactory类替换为新的已修改类。



感谢http://blog.naver.com/techshare/100145191355和https://gist.github.com/DalSoft/1588818,为我指明了如何做到这一点的正确方向。第一个站点上的最后一个链接包含解决方案的完整源代码。[60] [61]

其它参考15


刚碰到这个。我有超过6,000条记录。刚决定我只是做一些分页。在中,我接受我的MVC JsonResult端点中的页码,默认为0,所以没有必要,如下所示:


public JsonResult MyObjects(int pageNumber = 0)


然后而不是说:


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


我说:


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


这很简单。然后,在JavaScript中,而不是这样:


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


我改为说:


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


并将您的记录附加到您最初使用它们的任何内容中。或者等到所有通话完成并将结果拼凑在一起。

其它参考16


似乎没有无限的价值。默认值为2097152个字符,相当于4 MB的Unicode字符串数据。


正如已经观察到的那样,17,000条记录在浏览器中很难使用。如果要呈现聚合视图,则在服务器上执行聚合并在浏览器中仅传输摘要可能更有效。例如,考虑一个文件系统浏览器,我们只看到树的顶部,然后在我们向下钻取时发出更多请求。每个请求中返回的记录数相对较少。树视图演示文稿可以很好地适用于大型结果集。

其它参考17


您可以像其他人所说的那样在配置中设置它,或者您可以设置序列化器的单个实例,如:


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

其它参考18


我解决了添加此代码的问题:


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

其它参考19


如果您在View中遇到此类问题,可以使用以下方法来解决此问题。这里使用了 Newtonsoft 包。


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

其它参考20


使用lib\Newtonsoft.Json.dll


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

其它参考21


WebForms UpdatePanel的解决方案:


将设置添加到Web.config:


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


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


ScriptRegistrationManager类包含以下代码:


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

其它参考22


我们不需要任何服务器端更改。您可以通过web.config文件修复此问题
这对我有帮助。试试这个


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




其它参考23


替代ASP.NET MVC 5修复:


(我的类似于MFCs上面的回答,只有一些小改动)


我还没准备好改变Json.NET,在我的情况下,错误发生在请求中。我的方案中的最佳方法是修改实际JsonValueProviderFactory,将修复程序应用于全局项目,并且可以通过编辑global.cs文件来完成。


JsonValueProviderConfig.Config(ValueProviderFactories.Factories);


添加web.config条目:


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


然后创建以下两个类


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


这基本上是System.Web.Mvc中的默认实现的精确副本,但添加了可配置的web.config appsetting值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;
    }
}

其它参考24


如果这个maxJsonLength值是一个int那么它的int 32bit/64bit/16bit有多大....我只想确定我可以设置的最大值是什么maxJsonLength


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

其它参考25


您不需要使用web.config
您可以在通过列表的捕获值期间使用短属性
例如
宣布一个类似的模型


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
}


在这里,我使用短的比例
BC =条形码
BE =书籍版等