我可以在 web.config 中为 maxJsonLength 设置无限长度吗？

Question

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

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

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

Answer 1

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

---

MaxJsonLength属性不能无限制，是一个整数属性，默认为 102400 (100k)。

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

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

Answer 2

如果您使用的是 MVC 4 ，请务必同时查看此答案。

---

如果您仍然收到错误：

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

您的问题很可能是：

MaxJsonLength 属性的值仅适用于异步通信层用来调用 Web 服务方法的内部 JavaScriptSerializer 实例。 （ MSDN：ScriptingJsonSerializationSection.MaxJsonLength 属性）

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

作为一种解决方法，您可以在控制器中（或任何地方）执行以下操作：

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 论坛答案的解释。

Answer 3

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

Answer 4

您可以在 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

Answer 5

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

我希望这会有所帮助。

Answer 6

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

        JavaScriptSerializer serializer = new JavaScriptSerializer();

        serializer.MaxJsonLength = Int32.MaxValue; 

        return serializer.Serialize(response);

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

Answer 7

我遵循了vestigal的回答并得到了这个解决方案：

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

我所做的是新建一个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);
}

Answer 8

我修好了它。

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

它工作得很好。

Answer 9

如果在您的 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>

Answer 10

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

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

Answer 11

您可以将此行写入 Controller

json.MaxJsonLength = 2147483644;

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

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

`

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

Answer 12

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

MiniProfiler.Settings.MaxJsonResponseSize = 104857600;

礼貌mvc-mini-profiler 。

Answer 13

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

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

Answer 14

一些属性魔法怎么样？

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

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

Answer 15

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

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.NET MVC源码的解释：可以查看ASP.NET MVC 源码中Controller.Json方法做了什么

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属性（默认为空）时会发生什么？ 它被传递给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。

Answer 16

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

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

Answer 17

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

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

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

Answer 18

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

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

Answer 19

替代 ASP.NET MVC 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.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;
    }
}

Answer 20

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

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

Answer 21

 JsonResult result = Json(r);
 result.MaxJsonLength = Int32.MaxValue;
 result.JsonRequestBehavior = JsonRequestBehavior.AllowGet;
 return result;

Answer 22

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

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

Answer 23

刚碰到这个。 我收到了超过 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
}

并将您的记录附加到您对它们所做的任何事情中。 或者只是等到所有调用完成并将结果拼凑在一起。

Answer 24

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

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

Answer 25

WebForms UpdatePanel 的解决方案：

将设置添加到 Web.config：

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

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

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

Answer 26

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

Answer 27

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

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

Answer 28

使用lib\Newtonsoft.Json.dll

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

Answer 29

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

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

Answer 30

您不需要使用 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 =barcode BE=book edition 等等