基于Expression Lambda表达式树的通用复杂动态查询构建器——《原型篇一》[已开源]

这篇具有很好参考价值的文章主要介绍了基于Expression Lambda表达式树的通用复杂动态查询构建器——《原型篇一》[已开源]。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

续接上编,本篇来讲讲俄罗斯套娃的设计与实现。

首先简单地完善一下前面提到的例子,代码如下:

  • 测试实体类
//测试实体类
public class Table
{
    public int A;
    public int B;
}
  • 独立条件类
//独立条件:
public class Field
{
    public Logical Logical { get; set; }        //与其它条件之间的逻辑关系  
    public Comparer Comparer { get; set; }      //条件比较符 
    public Type DataType { get; set; }          //数据类型
    public string FieldName { get; set; }       //字段名称
    public object QueryValue { get; set; }      //条件值
}
  • 条件组类
//条件组:
public class Block
{
    public Logical Logical { get; set; }      //与其它条件组或独立条件之间的逻辑关系  
    public List<Field> Fields { get; set;}=new List<Field>();
    public List<Block> Blocks { get;set; }=new List<Block>();
}
  • 枚举
//逻辑
public enum Logical
{
    And,
    Or,
}
​
//比较
public enum Comparer
{
    Equal,
    GreatThan,
    LessThan,
}

 文章来源地址https://www.toymoban.com/news/detail-461297.html

接下来,先构建查询条件描述器对象,由于例子代码比较简略,仅用于方便说明设计思路和方法,如果哪位看官直接拿来实用,请先备好洗澡水,以备从坑里爬出来净身之用。

代码简单就不作多说明了,就是添加一个独立条件,两个子组,子组里分别包含两个独立条件,以描述等效于

SQL=(Table1.A<3 OR Table1.A=3) Or (Table1.A>5 And Table1.B=3)) OR Table1.B>5的查询子句。

Block CreaterDescriptor()
{
    //SQL: (Table1.A<3 OR Table1.A=3) Or  (Table1.A>5 And Table1.B=3)) OR Table1.B>5
    var block = new Block() {Logical= Logical.Or};
    block.Fields.AddRange(new[]{new Field(){ Comparer= Comparer.GreatThan, DataType= typeof(int), FieldName="B", Logical= Logical.Or, QueryValue=5}});
    block.Blocks.AddRange(new [] {
        new Block(){
            Logical= Logical.Or,
            Fields=new List<Field>(new Field[]{
                new Field(){ Comparer= Comparer.LessThan, DataType=typeof(int), FieldName="A", QueryValue= 3},
                new Field(){ Comparer= Comparer.Equal, DataType=typeof(int), FieldName="A", Logical= Logical.Or, QueryValue= 3}
            }),
        },
        new Block(){
            Logical= Logical.Or,
            Fields=new List<Field>(new Field[]{
                new Field(){ Comparer= Comparer.GreatThan, DataType=typeof(int), FieldName="A", QueryValue= 5},
                new Field(){ Comparer= Comparer.Equal, DataType=typeof(int), FieldName="B", Logical= Logical.And,QueryValue= 3}
            }), 
        },
    });
    return block;
}

至此,已经拿到查询条件描述对象,知道了需要以什么条件进行查询了,一下步就是如何其转换为查询委托。

先来个手动组装看看上篇的设想能不能行得通。

Expression<Func<Table,bool>>  Manual()
{
    //SQL: (Table1.A<3 OR Table1.A=3) Or  (Table1.A>5 And Table1.B=3)) OR Table1.B>5
    //老套路,先包装
    var Table1 = new Table();
    var p = Expression.Parameter(typeof(Table), "Table1");
    
    //将5、3这两个常量包装成ConstantExpression:
    var num5 = Expression.Constant(5, typeof(int));
    var num3 = Expression.Constant(3, typeof(int));
    
    //将两个属性包装成MemberExpression。
    var a = Expression.PropertyOrField(p, "A");
    var b = Expression.PropertyOrField(p, "B");
    
    //构造Table1.A<3:
    var ltA3 = Expression.LessThan(a, num3);
    //构造Table1.A=3:
    var eqA3 = Expression.Equal(a, num3);
    //构造Table1.A>5:
    var gtA5 = Expression.GreaterThan(a, num5);
    //构造Table1.A=5:
    var eqB3 = Expression.Equal(b, num3);
    //构造Table1.B>5:
    var gtB5 = Expression.GreaterThan(b, num5);
    
    //构造Table1.A<3 OR Table1.A=3
    var expLtA3orEqA3 = Expression.OrElse(ltA3, eqA3);
    //构造Table1.A>5 && Table1.B=3
    var expGtA5andEqB3 = Expression.AndAlso(gtA5, eqB3);
    //构造(Table1.A<3 OR Table1.A=3) Or  (Table1.A>5 And Table1.B=3))
    var expGtA5andEqA3_Or_expLtA3orEqA3=Expression.OrElse(expLtA3orEqA3,expGtA5andEqB3);
    //(Table1.A<3 OR Table1.A=3) Or  (Table1.A>5 And Table1.B=3)) OR Table1.B>5
    var result=Expression.OrElse(expGtA5andEqA3_Or_expLtA3orEqA3,gtB5);
    
    //结果要出来了
    Expression<Func<Table,bool>> lambda=Expression.Lambda<Func<Table,bool>>(result,p);
    return lambda;
}

手动组装好了,来测试验证一下:

//测试方法
void TestLambda(Expression<Func<Table,bool>> lambda)
{
    var list = new List<Table>
        {
            new Table{A=6,B=2},
            new Table{A=5,B=6},
            new Table{A=2,B=3}
        }
    ;
    var my = list.Where(t => lambda.Compile()(t)).ToArray();
    var linq = list.Where(t => ((t.A < 3 || t.A == 3) || (t.A > 5 && t.B == 3)) || t.B > 5).ToArray();
    Debug.Assert(my.Length == linq.Length);
    for (var i = 0; i < my.Length; i++)
    {
        Debug.Assert(my[i] == linq[i]);
    }
    Console.WriteLine("Test_Ok");
}
​
​
//运行测试
void Main()
{
    var lambda=Manual();
    TestLambda(lambda );    
}

经过上机运行,结果正确,OK!

但是,问题来了,这手动组装并不简单,稍不留神就容易写错,如果真这么用,就是浪费表情了。那么有没有自动的,不需要人工干预的方法?必须有,否则本系列文章还有什么可写的呢?

具体看下面代码,就不太过啰嗦的解释了,简单说明一下思路,拿到一个多层嵌套的条件组之后,先对直接的独立条件进行LambdaExpression逐个组装,串联起来,再逐个组装子条件组也串联起来,最后把独立条件和子组串联起来,如果子组里还有子组,进行逐层递归:

Expression<Func<T,bool>>  CreaterQueryExpression<T>(Block block)
{
    var param=Expression.Parameter(typeof(T),typeof(T).Name);
    return Expression.Lambda<Func<T,bool>>(CreateBlockExpr(block),param);
    //构建独立条件的串联
    Expression CreateFieldExpr(List<Field> fields)
    {
        var lastExp=default(Expression);
        foreach (var f in fields)
        {
            var member=Expression.PropertyOrField(param, f.FieldName);
            var value=Expression.Constant(f.QueryValue);
            var exp=f.Comparer switch
            {
                Comparer.GreatThan=>Expression.GreaterThan(member,value),
                Comparer.LessThan=>Expression.LessThan(member,value),
                _=> Expression.Equal(member,value),
            };
            if (lastExp != default(Expression))
            {
                 exp= f.Logical switch
                {
                    Logical.Or => Expression.OrElse(lastExp,exp),
                    _=>Expression.AndAlso(lastExp,exp),
                };
            }
            lastExp=exp;
        }
        return lastExp;
    }
    //构建子组并串联
    Expression CreateBlockExpr(Block block)
    {
        var lastExp=default(Expression);
        var exp=CreateFieldExpr(block.Fields);
        foreach (var sub in block.Blocks)
        {
            var subExp = CreateBlockExpr(sub);
            if (lastExp != default && subExp!=default)
            {
                subExp = sub.Logical switch
                {
                    Logical.Or => Expression.OrElse(lastExp, subExp),
                    _ => Expression.AndAlso(lastExp, subExp),
                };
            }
            lastExp=subExp;
        }
        if (lastExp != default && exp!=default)
        {
            exp= block.Logical switch
            {
                Logical.Or => Expression.OrElse(exp, lastExp),
                _ => Expression.AndAlso(exp, lastExp),
            };
        }
        return exp;
    }
        
}
​

好,委托已经拿到。是否能正确实现查询意图呢?来测试一下:

// 运行测试
void Main()
{
    var lambda=CreaterQueryExpression<Table>(CreaterDescriptor());
    TestLambda(lambda);
}

经上机运行,结果OK!

  • 至此,初步的原型实现已经完成.
  • 接下来要做什么呢,是正式编码开战呢,还是思考一下,有什么应用场景,有什么优缺点,如果有缺点能不能克服?如果正式开战可能会遇到些什么问题或困难,要如何解决?
  • 敬请等下回分解,随手点个赞呗。

 

 

到了这里,关于基于Expression Lambda表达式树的通用复杂动态查询构建器——《原型篇一》[已开源]的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【c#表达式树】最完善的表达式树Expression.Dynamic的玩法

    在我第一次写博客的时候,写的第一篇文章,就是关于表达式树的,链接:https://www.cnblogs.com/1996-Chinese-Chen/p/14987967.html,其中,当时一直没有研究Expression.Dynamic的使用方法(因为网上找不到资料),就了解到是程序运行时动态去构建表达式树,举个例子,例如我们需要在我们的

    2023年04月11日
    浏览(37)
  • oracle的正则表达式(regular expression)

    当前,正则表达式已经在很多软件中得到广泛的应用,包括Linux, Unix,HP等操作系统,PHP,C#,Java等开发环境,ORACLE则在10G中推出了自己的正则表达式。 Oracle 10g正则表达式提高了SQL灵活性,有效的解决了数据有效性, 重复词的辨认, 无关的空白检测,或者分解多个正则组成的

    2024年02月07日
    浏览(44)
  • 表达式树(Expression)的执行、解释与创建

    前言:在这里不进行概念性描述,能看到这篇文章说明你已经知道如何使用表达式树 这里需要说明下表达式树是表示代码的数据结构,并不是经过编译且可执行的代码,如果想要执行由表达式树表示的 .NET 代码,必须将其转换为可执行的 IL 指令。这时候我们需要调用编译函

    2024年02月22日
    浏览(35)
  • Python正则表达式Regular Expression初探

    目录 Regular 匹配规则 单字符匹配  数量匹配 边界匹配  分组匹配 贪婪与懒惰 原版说明 特殊字符 转义序列 模块方法 函数说明 匹配模式 常用匹配规则 1. 匹配出所有整数 2. 匹配11位且13开头的整数 Python的re模块提供了完整的正则表达式功能。正则表达式(Regular Expression)是一

    2024年01月22日
    浏览(46)
  • C#Regex正则表达式(Regular Expression)

    在C#中,Regex是正则表达式(Regular Expression)的缩写,它是一种强大的文本匹配和处理工具。正则表达式是一种用于描述模式的字符串,它可以用来在文本中查找、替换和提取满足特定模式的内容。 在C#中,你可以使用System.Text.RegularExpressions命名空间下的Regex类来操作正则表达

    2024年02月05日
    浏览(37)
  • 数据结构——基于二叉树的表达式求值算法

    1.输入一个表达式(表达式中的数均小于10的正整数),利用二叉树来表示该表达式,创建表达式数,然后利用二叉树的遍历操作求表达式的值。 2.输入要求:多组数据,每组数据1行,为一个表达式,表达式以“=”结尾。当输入只有一个“=”时,输入结束。 3.输出要求:每组

    2024年02月04日
    浏览(47)
  • 【javaSE】 Lambda表达式与Lambda表达式的使用

    Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式(Lambda expression) ,基于数学中的λ演算得名,也

    2024年02月08日
    浏览(62)
  • 进阶JAVA篇- Lambda 表达式与 Lambda 表达式的省略规则

    目录         1.0 什么是 Lambda 表达式?         1.1 既然跟匿名内部类相关,先来回顾匿名内部类。          1.2 Lambda 表达式与匿名内部类之间的关系。         1.3 函数式接口         1.4 在具体代码中来操作一下         2.0 Lambda 表达式省略规则          Lambda 表达

    2024年02月08日
    浏览(55)
  • 【P15】JMeter 正则表达式提取器(Regular Expression Extractor)

    接口需要关联时,可以通过正则表达式提取所需要的值 右键 添加 后置处理器 正则表达式提取器(Regular Expression Extractor) Apply to Main sample and sub-samples:匹配范围包括当前父取样器并覆盖子取样器 Main sample only:默认;匹配范围是当前父取样器 Sub-samples only :仅匹配子取样器

    2024年02月07日
    浏览(44)
  • 探索Python中的函数式编程:Lambda表达式与函数式工具【第135篇—Lambda表达式】

    前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。【点击进入巨牛的人工智能学习网站】。 在Python编程世界中,函数式编程逐渐成为了一种流行的范式,特别是在处理数据和编写简洁、高效代码时。函数式编程的核心思想是将计算视

    2024年04月08日
    浏览(87)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包