3

当我在“au”我的网络网格上进行服务器过滤并更改页面时，对控制器的多次调用完成：

  1. 第一个用 0 过滤，
  2. 第二个用“a”过滤，
  3. 第三个带有“au”过滤。

我的表加载了大量数据，因此第一次调用比其他调用更长。我看到网格首先显示第三个调用结果，然后是第二个，最后是第一个调用（由于 filter 参数，此顺序对应于我的控制器的响应时间）

为什么要进行所有控制器调用？不能只用我的总过滤器“au”调用一次我的控制器吗？我应该怎么办 ？

这是我的网格：

$("#" + gridId).kendoGrid({
            selectable: "row",
            pageable: true,
            filterable:true,
            scrollable : true,
            //scrollable: {
            //    virtual: true //false // Bug : Génère un affichage multiple...
            //},
            navigatable: true,
            groupable: true,
            sortable: {
                mode: "multiple", // enables multi-column sorting
                allowUnsort: true
            },
            dataSource: {
                type: "json",
                serverPaging: true,
                serverSorting: true,
                serverFiltering: true,
                serverGrouping:false, // Ne fonctionne pas...
                pageSize: '@ViewBag.Pagination',
                transport: {
                    read: {
                        url: Procvalue + "/LOV",
                        type: "POST",
                        dataType: "json",
                        contentType: "application/json; charset=utf-8"
                    },
                    parameterMap: function (options, type) {
                        // Mise à jour du format d'envoi des paramètres 
                        // pour qu'ils puissent être correctement interprétés côté serveur.
                        // Construction du paramètre sort : 
                        if (options.sort != null) {
                            var sort = options.sort;
                            var sort2 = "";
                            for (i = 0; i < sort.length; i++) {
                                sort2 = sort2 + sort[i].field + '-' + sort[i].dir + '~';
                            }
                            options.sort = sort2;
                        }
                        if (options.group != null) {
                            var group = options.group;
                            var group2 = "";
                            for (i = 0; i < group.length; i++) {
                                group2 = group2 + group[i].field + '-' + group[i].dir + '~';
                            }
                            options.group = group2;
                        }
                        if (options.filter != null) {
                            var filter = options.filter.filters;
                            var filter2 = "";
                            for (i = 0; i < filter.length; i++) {
                                // Vérification si type colonne == string.
                                // Parcours des colonnes pour trouver celle qui a le même nom de champ.
                                var type = "";
                                for (j = 0 ; j < colonnes.length ; j++) {
                                    if (colonnes[j].champ == filter[i].field) {
                                        type = colonnes[j].type;
                                        break;
                                    }
                                }

                                if (filter2.length == 0) {
                                    if (type == "string") { // Avec '' autour de la valeur.
                                        filter2 = filter2 + filter[i].field + '~' + filter[i].operator + "~'" + filter[i].value + "'";
                                    } else { // Sans '' autour de la valeur.
                                        filter2 = filter2 + filter[i].field + '~' + filter[i].operator + "~" + filter[i].value;
                                    }
                                } else {
                                    if (type == "string") { // Avec '' autour de la valeur.
                                        filter2 = filter2 + '~' + options.filter.logic + '~' + filter[i].field + '~' + filter[i].operator + "~'" + filter[i].value + "'";
                                    }else{
                                        filter2 = filter2 + '~' + options.filter.logic + '~' + filter[i].field + '~' + filter[i].operator + "~" + filter[i].value;
                                    }
                                }
                            }
                            options.filter = filter2;
                        }
                        var json = JSON.stringify(options);
                        return json;
                    }
                },
                schema: {
                    data: function (data) {
                        return eval(data.data.Data);
                    },
                    total: function (data) {
                        return eval(data.data.Total);
                    }
                },
                filter: {
                    logic: "or",
                    filters:filtre(valeur)
                }
            },
            columns: getColonnes(colonnes)
        });

这是我的控制器：

[HttpPost]
    public ActionResult LOV([DataSourceRequest] DataSourceRequest request)
    {
        return Json(CProduitsManager.GetProduits().ToDataSourceResult(request));
    }
4

2 回答 2

1

3 对应于初始负载（无过滤）和以下在您输入过滤条件时的负载，类似kendoAutocomplete但kendoAutocomplete有几个选项（时间和最小长度）控制何时发送请求（我不能'在网格中找不到类似的东西）。

如果您的问题是加载大量数据，我建议限制pageSize在DataSource定义中使用的传输数据的大小。但是，显然，如果执行查询需要很长时间，这不是一个解决方案。

于 2012-11-21T22:57:34.873 回答
0

在这种情况下，建议创建一个打字延迟，从而在用户停止打字时执行请求（除非他的打字速度比常规打字慢）。

为了造成延迟，我可以建议您执行以下操作：

    <script type="text/javascript">        
    var globalTimeout = null;
    $('#searchInput').keyup(function () {
        if (globalTimeout != null) clearTimeout(globalTimeout);
        globalTimeout = setTimeout(SearchFunc, 500);
    });   

    function SearchFunc(){  
        globalTimeout = null;
        $('#yourGridName').data('kendoGrid').dataSource.filter({ field:"theField",operator:"startswith",value:$('#searchInput').val() })
    }
    </script>
于 2012-11-22T19:38:02.103 回答