我可以设置一个无限的长度maxJsonL在web.config?

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

异常信息：
异常类型：InvalidOperationException
异常消息：使用JSON JavaScriptSerializer进行序列化或反序列化时出错。字符串的长度超过了maxJsonL的属性设置的值。

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

729342 次浏览
小开
最佳答案

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

最大长度属性不能是无限的，是默认为102400（100k）的整数属性。

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

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

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

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

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

小开

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

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

小开

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

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

小开

如果在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>
小开

如果您使用的是MVC4，请务必查看这个答案。

如果您仍然收到错误：

  • 将maxJsonLength属性设置为web.config中的最大值后
  • 你知道你的数据长度小于这个值
  • 并且您没有使用Web服务方法进行JavaScript序列化

你的问题很可能是：

MaxJsonL长度属性的值仅适用于内部JavaScriptSerializer实例，该实例由异步通信层用于调用Web服务方法。（MSDN： ScriptingJsonSerializationSection. MaxJsonL的长度属性

基本上，“内部”JavaScriptSerializer在从web方法调用时尊重maxJsonLength的值；直接使用JavaScriptSerializer（或通过MVC动作方法/控制器使用）没有尊重maxJsonLength属性，至少不是从systemWebExtensions.scripting.webServices.jsonSerialization部分web.config.特别是Controller.Json()方法不要尊重配置设置！

作为一种解决方法，您可以在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论坛的答案。

小开

我修好了。

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

它工作得很好。

小开

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

在你的控制器。

补充：

对于任何对您需要指定的参数感到困惑的人，调用可能如下所示：

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

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

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

对于那些在MVC3中遇到JSON自动反序列化模型绑定器并且太大的问题的人，这里有一个解决方案。

  1. 将JsonValueProviderFactory类的代码从MVC3源代码复制到一个新类中。
  2. 添加一行以在反序列化对象之前更改最大JSON长度。
  3. 将JsonValueProviderFactory类替换为新的修改后的类。

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

小开

刚刚遇到这个。我有超过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
}

然后将你的记录附加到你一开始用它们做的任何事情上。或者只是等到所有的调用结束并将结果拼凑在一起。

小开

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

MiniProfiler.Settings.MaxJsonResponseSize = 104857600;

礼貌mvc-mini分析器。

小开

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

        JavaScriptSerializer serializer = new JavaScriptSerializer();


serializer.MaxJsonLength = Int32.MaxValue;


return serializer.Serialize(response);

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

小开

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

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

您可以将此行写入Controller

json.MaxJsonLength = 2147483644;

您也可以将此行写入web.config

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

'

为了安全起见，两者都要使用。

小开

使用lib\Newtonsoft.Json.dll

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

WebForms UpdatePanel的解决方案：

将设置添加到Web.config：

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

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);
小开

如果你仍然得到错误后web.config设置如下：

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

我通过以下方式解决了它：

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

我希望这会有帮助。

小开

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

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

如果这个maxJsonL值是一个int，那么它的int 32位/64位/16位有多大……我只是想确定我可以设置的最大值是多少

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

我听从了维克纳尔的回答，得到了这个解决方案：

当我需要将一个大json发布到控制器中的操作时，我会得到著名的“使用JSON JavaScriptSerializer进行反序列化时出错。字符串的长度超过了maxJsonL属性上设置的值。\r\n参数名称：输入值提供者”。

我所做的是创建一个新的ValueProviderFactory，LargeJsonValueProviderFactory，并在GetDeserializedObject方法中设置MaxJsonL长度=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);
}
小开

一些属性魔法怎么样？

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

然后，您可以使用全局过滤器配置或控制器/操作来全局应用它。

小开

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

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

在MVC的Action方法中简单地设置MaxJsonL长度proprty

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

我们不需要任何服务器端的更改。您只能通过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>

小开

你不需要做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=图书版等

小开

替代ASP.NETMVC 5修复：

（我的类似于上面的MFC答案，有一些小的变化）

我还没有准备好更改为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.configapp设置值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;
}
}
小开 
 JsonResult result = Json(r);
result.MaxJsonLength = Int32.MaxValue;
result.JsonRequestBehavior = JsonRequestBehavior.AllowGet;
return result;
小开

修复ASP.NETMVC如果您只想修复导致问题的特定操作，请更改此代码：

public JsonResult GetBigJson()
{
var someBigObject = GetBigObject();
return Json(someBigObject);
}

对此：

public JsonResult GetBigJson()
{
var someBigObject = GetBigObject();
return new JsonResult()
{
Data = someBigObject,
JsonRequestBehavior = JsonRequestBehavior.DenyGet,
MaxJsonLength = int.MaxValue
};
}

功能应该是一样的，你可以返回更大的JSON作为响应。

基于ASP.NETMVC源代码的解释：可以在MVC源代码中查看Controller.Json方法ASP.NET

protected internal JsonResult Json(object data)
{
return Json(data, null /* contentType */, null /* contentEncoding */, JsonRequestBehavior.DenyGet);
}

它正在调用其他Controller.Json方法：

protected internal virtual JsonResult Json(object data, string contentType, Encoding contentEncoding, JsonRequestBehavior behavior)
{
return new JsonResult
{
Data = data,
ContentType = contentType,
ContentEncoding = contentEncoding,
JsonRequestBehavior = behavior
};
}

其中传递的contentType和contentEncoding对象是null。所以基本上在控制器中调用return Json(object)相当于调用return new JsonResult { Data = object, JsonRequestBehavior = sonRequestBehavior.DenyGet }。您可以使用第二种形式并参数化JsonResult。

那么当你设置MaxJsonLength属性（默认为null）时会发生什么？ 它是传承下来到JavaScriptSerializer.MaxJsonLength属性，然后JavaScriptSerializer.Serialize方法是称为：

JavaScriptSerializer serializer = new JavaScriptSerializer();
if (MaxJsonLength.HasValue)
{
serializer.MaxJsonLength = MaxJsonLength.Value;
}


if (RecursionLimit.HasValue)
{
serializer.RecursionLimit = RecursionLimit.Value;
}


response.Write(serializer.Serialize(Data));

当你不设置序列化器的MaxJsonLenght属性时，它的需要默认值只有2MB。

小开

我使用这个，它适用于剑道网格读取请求。

{
//something
var result = XResult.ToList().ToDataSourceResult(request);
var rs = Json(result, JsonRequestBehavior.AllowGet);
rs.MaxJsonLength = int.MaxValue;
return rs;
}

提交答案