Winform开发框架之通用高级查询模块

在一般的检索界面中，基于界面易用和美观方便的考虑，我们往往只提供一些常用的条件查询进行列表数据的查询，但是有时候一些业务表字段很多，一些不常见的条件可能在某些场景下也需要用到。因此我们在通用的查询条件之外，一般可以考虑增加 一个高级查询的模块来管理这些不常见条件的查询处理。本篇随笔基于这个需求，综合abp框架的特点，整合了高级查询模块功能的处理。

1、高级查询模块的回顾

我们知道，在界面布局中，一般常见的查询条件不能太多，否则会显得臃肿而且占用太多空间，非常不美观，因此常见的查询都是提供寥寥几个的输出条件进行列表记录的查询的。

又或者一些更多内容的界面，我们也是仅仅提供多几个条件，其他的想办法通过高级查询界面进行查询管理。

在早期博客里面《winform开发框架之通用高级查询模块》，我曾经介绍过一款通用的高级查询界面处理，用在winform框架里面，可以对数据表更多的字段进行统一的查询处理。

对于内容较多的查询，我们可以在主界面增加一个高级查询按钮入口，如上图所示，单击后，显示一个所有字段的列表，如下界面。

一般来说，查询条件分为文本输入，如姓名，邮件，名称等这些。

日期类型条件输入界面：

数字类型条件输入界面：

 输入以上几种条件后，高级查询界面里面会显示友好的条件内容，确保用户能够看懂输入的条件，如下所示是输入几个不同类型的条件的显示内容。

以上是高级查询模块的思路，整体界面和处理逻辑虽然可以采用，但是在abp框架模式下，以前的处理方式有所不同了，下面详细介绍一下如何在abp框架模块下整合这个高级查询模块的内容。

 

2、abp框架模块下的高级查询处理

我们先来了解一下最终在abp框架下整合的高级查询模块界面如下所示。

可以设置一些模糊查询条件，以及一些区间的查询值，如下所示。

这个模块是以abp框架的web api获取数据，并通过winform界面进行调用，从而形成了一个abp+winform的框架体系。

前面abp框架系列介绍过，我们一般使用getall和分页条件dto进行数据的检索，如下是产品分页dto的定义

    /// <summary>
    /// 用于根据条件分页查询，dto对象
    /// </summary>
    public class productpageddto : pagedandsortedinputdto

而pagedandsortedinputdto也是自定义的类，它主要用来承载一些分页和排序的信息，如下所示

    /// <summary>
    /// 带有排序对象的分页基类
    /// </summary>
    public class pagedandsortedinputdto : pagedinputdto, isortedresultrequest
    {
        /// <summary>
        /// 排序信息
        /// </summary>
        public string sorting { get; set; }

其中的pagedinputdto也是自定义类，主要承载分页信息。

    /// <summary>
    /// 分页对象
    /// </summary>
    public class pagedinputdto : ipagedresultrequest
    {
        [range(1, int.maxvalue)]
        public int maxresultcount { get; set; }

        [range(0, int.maxvalue)]
        public int skipcount { get; set; }

        public pagedinputdto()
        {
            maxresultcount = int.maxvalue;
        }
    }

这样的构建，我们可以传递分页和排序信息，因此在getall函数里面，就可以根据这些条件进行数据查询了。

而我们通过重写过滤条件和排序处理，就可以实现数据的分页查询了。对于产品信息的过滤处理和排序处理，我们重写函数如下所示。

        /// <summary>
        /// 自定义条件处理
        /// </summary>
        /// <param name="input">查询条件dto</param>
        /// <returns></returns>
        protected override iqueryable<product> createfilteredquery(productpageddto input)
        {
            return base.createfilteredquery(input)
                .whereif(!input.excludeid.isnullorwhitespace(), t => t.id != input.excludeid) //不包含排除id

                .whereif(!input.productno.isnullorwhitespace(), t => t.productno.contains(input.productno)) //如需要精确匹配则用equals
                .whereif(!input.barcode.isnullorwhitespace(), t => t.barcode.contains(input.barcode)) //如需要精确匹配则用equals
                .whereif(!input.materialcode.isnullorwhitespace(), t => t.materialcode.contains(input.materialcode)) //如需要精确匹配则用equals
                .whereif(!input.producttype.isnullorwhitespace(), t => t.producttype.contains(input.producttype)) //如需要精确匹配则用equals
                .whereif(!input.productname.isnullorwhitespace(), t => t.productname.contains(input.productname)) //如需要精确匹配则用equals
                .whereif(!input.unit.isnullorwhitespace(), t => t.unit.contains(input.unit)) //如需要精确匹配则用equals
                .whereif(!input.note.isnullorwhitespace(), t => t.note.contains(input.note)) //如需要精确匹配则用equals
                .whereif(!input.description.isnullorwhitespace(), t => t.description.contains(input.description)) //如需要精确匹配则用equals
                 
                 //状态
                .whereif(input.status.hasvalue, t => t.status==input.status)
                                                                                              
                 //成本价区间查询
                .whereif(input.pricestart.hasvalue, s => s.price >= input.pricestart.value)
                .whereif(input.priceend.hasvalue, s => s.price <= input.priceend.value)

                //销售价区间查询
                .whereif(input.salepricestart.hasvalue, s => s.saleprice >= input.salepricestart.value)
                .whereif(input.salepriceend.hasvalue, s => s.saleprice <= input.salepriceend.value)

                //特价区间查询
                .whereif(input.specialpricestart.hasvalue, s => s.specialprice >= input.specialpricestart.value)
                .whereif(input.specialpriceend.hasvalue, s => s.specialprice <= input.specialpriceend.value)
                .whereif(input.isusespecial.hasvalue, t => t.isusespecial == input.isusespecial) //如需要精确匹配则用equals
                                                                                                  
                //最低折扣区间查询
                .whereif(input.lowestdiscountstart.hasvalue, s => s.lowestdiscount >= input.lowestdiscountstart.value)
                .whereif(input.lowestdiscountend.hasvalue, s => s.lowestdiscount <= input.lowestdiscountend.value)

                //创建日期区间查询
                .whereif(input.creationtimestart.hasvalue, s => s.creationtime >= input.creationtimestart.value)
                .whereif(input.creationtimeend.hasvalue, s => s.creationtime <= input.creationtimeend.value);
        }

        /// <summary>
        /// 自定义排序处理
        /// </summary>
        /// <param name="query">可查询linq</param>
        /// <param name="input">查询条件dto</param>
        /// <returns></returns>
        protected override iqueryable<product> applysorting(iqueryable<product> query, productpageddto input)
        {
            //按创建时间倒序排序
            return base.applysorting(query, input).orderbydescending(s => s.creationtime);//时间降序
        }

虽然我们一般在界面上不会放置所有的条件，但是高级查询模块倒是可以把分页条件dto里面的条件全部摆上去的。

高级查询模块的条件如下所示。

 我们高级查询里面的条件还是以getall里面的对象分页查询dto里面的属性，我们需要根据这些条件进行构建，也需要以这些属性的类型进行一个控件的选择。

因此我们需要一个属性的名称说明，以及在高级查询模块的列表界面中对显示那些字段进行控制，如下代码所示。

        private frmadvancesearch dlg;
        /// <summary>
        /// 高级查询的操作
        /// </summary>        
        private async void advancesearch()
        {
            if (dlg == null)
            {
                dlg = new frmadvancesearch();
                dlg.setfieldtypelist<productpageddto>();//通过分页对象获取查询属性和类型 
                dlg.columnnamealias = await productapicaller.instance.getcolumnnamealias();                
                dlg.displaycolumns = "productno,barcode,materialcode,producttype,productname,unit,price,saleprice,specialprice,isusespecial,lowestdiscount,note,description,status,creatoruserid,creationtime";

通过 setfieldtypelist<productpageddto> 的处理，我们把分页对象的查询属性和类型赋值给了高级查询模块，让它根据类型来创建不同的输入显示，如常规的字符串、数值区段、日期区段，下拉列表等等。

对于下拉列表，我们需要绑定它的数据源，如下代码所示。

 dlg.addcolumnlistitem("producttype", await dictitemutil.getdictlistitembydicttype("产品类型"));//字典列表
 dlg.addcolumnlistitem("status", await dictitemutil.getdictlistitembydicttype("产品状态"));//字典列表

而对于一些常规的固定列表，也可以以类似的方式加入下拉列表

    //固定转义的列表
    var speciallist = new list<clistitem>() { new clistitem("特价", "true"), new clistitem("一般", "false") };
    dlg.addcolumnlistitem("isusespecial", speciallist);

或者

    dlg.addcolumnlistitem("sex", "男,女");//固定列表

因此整个调用高级查询模块的代码如下所示

    private frmadvancesearch dlg;
    /// <summary>
    /// 高级查询的操作
    /// </summary>        
    private async void advancesearch()
    {
        if (dlg == null)
        {
            dlg = new frmadvancesearch();
            dlg.setfieldtypelist<productpageddto>();//通过分页对象获取查询属性和类型 
            dlg.columnnamealias = await productapicaller.instance.getcolumnnamealias();                
            dlg.displaycolumns = "productno,barcode,materialcode,producttype,productname,unit,price,saleprice,specialprice,isusespecial,lowestdiscount,note,description,status,creatoruserid,creationtime";

            #region 下拉列表数据

            dlg.addcolumnlistitem("producttype", await dictitemutil.getdictlistitembydicttype("产品类型"));//字典列表
            dlg.addcolumnlistitem("status", await dictitemutil.getdictlistitembydicttype("产品状态"));//字典列表

            //固定转义的列表
            var speciallist = new list<clistitem>() { new clistitem("特价", "true"), new clistitem("一般", "false") };
            dlg.addcolumnlistitem("isusespecial", speciallist);

            //dlg.addcolumnlistitem("sex", "男,女");//固定列表
            //dlg.addcolumnlistitem("credit", await productapicaller.instance.getfieldlist("credit"));//动态列表

            #endregion

            dlg.conditionchanged += new frmadvancesearch.conditionchangedeventhandler(dlg_conditionchanged);
        }
        dlg.showdialog();
    }

在处理获取数据getdata函数的时候，我们需要根据高级查询进行一定的切换，以便显示正确的过滤条件，如下代码所示是获取数据的处理。

        /// <summary>
        /// 获取数据
        /// </summary>
        /// <returns></returns>
        private async task<ipagedresult<productdto>> getdata()
        {
            productpageddto pagerdto = null;
            if (advancecondition != null)
            {
                pagerdto = new productpageddto(this.wingridviewpager1.pagerinfo);
                pagerdto = dlg.getpagedresult(pagerdto);               
            }
            else
            {
                //构建分页的条件和查询条件
                pagerdto = new productpageddto(this.wingridviewpager1.pagerinfo)
                {
                    //添加所需条件
                    productno = this.txtproductno.text.trim(),
                    barcode = this.txtbarcode.text.trim(),
                    materialcode = this.txtmaterialcode.text.trim(),
                    producttype = this.txtproducttype.text.trim(),
                    productname = this.txtproductname.text.trim(),
                    description = this.txtdescription.text.trim(),
                };

                //日期和数值范围定义
                //创建时间，需在productpageddto中添加datetime?类型字段creationtimestart和creationtimeend
                var creationtime = new timerange(this.txtcreationtime1.text, this.txtcreationtime2.text); //日期类型
                pagerdto.creationtimestart = creationtime.start;
                pagerdto.creationtimeend = creationtime.end;

            }

            var result = await productapicaller.instance.getall(pagerdto);
            return result;
        }

在高级查询的处理方式下，我们是传入一个列表的分页对象属性，然后传入一个分页dto对象，就可以构建出我们需要的分页查询条件，传递给web api端获取对应条件的数据了。

    pagerdto = new productpageddto(this.wingridviewpager1.pagerinfo);
    pagerdto = dlg.getpagedresult(pagerdto);        

而高级查询模块，所需要处理的逻辑就是需要根据不同的属性类型，赋值常规的属性值或者区段属性值，从而构建出分页对应的属性条件即可。

如果是区段（包括日期或者数值）的，我们分页查询条件里面，会有一个abcstart,abcend的对象属性，依照这个规则，获取到对应的用户输入，采用反射方式赋值dto对象即可。