关于asp.net:Can我在web.config中为maxJsonLength设置了无限长度？


Can I set an unlimited length for maxJsonLength in web.config?

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

Exception information:
Exception type: InvalidOperationException
Exception message: Error during serialization or deserialization using the JSON JavaScriptSerializer. The length of the string exceeds the value set on the maxJsonLength property.

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

相关讨论

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

maxjsonlength属性不能是无限的，它是一个整数属性，默认值为102400(100k)。

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

1
2
3
4
5
6
7
8
9
<configuration>
   <system.web.extensions>
       <scripting>
           <webServices>
               <jsonSerialization maxJsonLength="50000000"/>
           </webServices>
       </scripting>
   </system.web.extensions>
</configuration>
相关讨论

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

如果仍然收到错误：

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

您的问题可能是：

The value of the MaxJsonLength property applies only to the internal JavaScriptSerializer instance that is used by the asynchronous communication layer to invoke Web services methods. (MSDN: ScriptingJsonSerializationSection.MaxJsonLength Property)

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

作为一个解决方法，您可以在控制器中(或任何真正的地方)执行以下操作：

1
2
3
4
5
6
7
8
9
10
11
12
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论坛答案的解释。

相关讨论

在MVC 4中，您可以执行以下操作：

1
2
3
4
5
6
7
8
9
10
11
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
    };
}

在你的控制器里。

添加：

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

1
2
3
4
5
6
7
8
9
Json(
    new {
        field1 = true,
        field2 ="value"
        },
   "application/json",
    Encoding.UTF8,
    JsonRequestBehavior.AllowGet
);
相关讨论

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

1
2
3
4
5
6
7
8
9
10
<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

相关讨论

我在ASP.NET Web窗体中遇到了这个问题。它完全忽略了web.config文件设置，因此我执行了以下操作：

1
2
3
4
5
        JavaScriptSerializer serializer = new JavaScriptSerializer();

        serializer.MaxJsonLength = Int32.MaxValue;

        return serializer.Serialize(response);

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

相关讨论

如果在web.config设置后仍然出现错误，如下所示：

1
2
3
4
5
6
7
8
9
<configuration>
   <system.web.extensions>
       <scripting>
           <webServices>
               <jsonSerialization maxJsonLength="50000000"/>
           </webServices>
       </scripting>
   </system.web.extensions>
</configuration>

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

1
2
3
4
5
6
   public ActionResult/JsonResult getData()
   {
      var jsonResult = Json(superlargedata, JsonRequestBehavior.AllowGet);
      jsonResult.MaxJsonLength = int.MaxValue;
      return jsonResult;
    }

我希望这能有所帮助。

相关讨论

我把它修好了。

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

它工作得很好。

相关讨论

如果在web.config中实现上述添加后，出现"无法识别的配置节system.web.extensions"错误，请尝试将其添加到节中的web.config中：

1
2
3
4
5
6
7
            <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>
相关讨论

我按照法斯蒂格尔的回答，得出了这个解决方案：

当我需要将一个大型JSON发布到控制器中的一个操作时，我会在使用JSON JavaScriptSerializer进行反序列化的过程中得到著名的"错误"。字符串长度超过了MaxJSOnLength属性设置的值。
参数名称：输入值提供程序"。

我所做的是创建一个新的ValueProviderFactory，即largejsonValueProviderFactory，并在getDeserializedObject方法中设置maxjsonLength=int32.maxValue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
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中的应用程序start方法中，将ValueProviderFactory替换为新的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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);
}
相关讨论

你可以把这行写进控制器

1
json.MaxJsonLength = 2147483644;

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

1
2
3
4
5
6
7
8
9
<configuration>
  <system.web.extensions>
    <scripting>
        <webServices>
            <jsonSerialization maxJsonLength="2147483647">
            </jsonSerialization>
        </webServices>
    </scripting>
  </system.web.extensions>

`

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

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

1
MiniProfiler.Settings.MaxJsonResponseSize = 104857600;

由MVC Mini Profiler提供。

只需在MVC的action方法中设置maxjsonlength属性

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

属性魔法怎么样？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
[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;
            }
        }
    }
}

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

相关讨论

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

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

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

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

相关讨论

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

  • 将jsonValueProviderFactory类的代码从MVC3源代码复制到新类中。
  • 添加一行以更改对象反序列化前的最大JSON长度。
  • 用新的、修改过的类替换jsonValueProviderFactory类。

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

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

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

    刚刚碰到这个。我有6000多张唱片。我刚决定做些寻呼。与中一样，我在MVC JSONResult端点中接受一个页码，它默认为0，因此不需要这样做：

    1
    public JsonResult MyObjects(int pageNumber = 0)

    然后，不要说：

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

    我说：

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

    很简单。然后，在javascript中，而不是这个：

    1
    2
    3
    function myAJAXCallback(items) {
        // Do stuff here
    }

    我反而说：

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

    把你的记录附加到你最初对它们做的任何事情上。或者等到所有的调用都完成，然后将结果拼凑在一起。

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

    1
    2
    3
    4
    5
    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();
    相关讨论

    如果您在视图中遇到这种问题，可以使用下面的方法来解决。这是我的牛顿包。

    1
    2
    3
    @using Newtonsoft.Json
    <script type="text/javascript">
        var partData = @Html.Raw(JsonConvert.SerializeObject(ViewBag.Part));
    相关讨论

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

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

    相关讨论

    替代ASP.NET MVC 5修复：

    (我的答案与上面的MFC答案类似，只做了一些小改动)

    我还没有准备好更改为json.net，在我的例子中，错误是在请求期间发生的。在我的场景中，最好的方法是修改实际的JsonValueProviderFactory，它将修复应用于全局项目，并且可以通过这样编辑global.cs文件来完成。

    1
    JsonValueProviderConfig.Config(ValueProviderFactories.Factories);

    添加web.config条目：

    1
     

    然后创建以下两个类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    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;
        }
    }
    相关讨论

    WebForms更新面板的解决方案：

    向web.config添加设置：

    1
    2
    3
    4
    5
    <configuration>
     
       
      </appSettings>
    </configuration>

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

    ScriptRegistrationManager类包含以下代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // 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文件修改来修复此问题这对我有帮助。试试这个

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    </appSettings>  

    and  

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

    使用lib
    ewtonsoft.Json.dll    。

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

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

    16

    您不需要使用web.config可以在传递列表的catch值期间使用short属性例如像这样声明模型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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=书籍版本等

    相关讨论