zoukankan      html  css  js  c++  java
  • .NET RulesEngine(规则引擎)

    一次偶然的机会,让我拿出RulesEngine去完成一个业务,对于业务来说主要是完成一个可伸缩性(不确定的类型,以及不确定的条件,条件的变动可能是持续增加修改的)的业务判断。比如说完成一个成就系统,管理员可创建,对于成就来说有一次性解锁、日常、周常式,还有随时重置,每次达成都触发的,面对着成就任务的增加,那对于程序员来说,如果每次都去增加修改这些成就任务简直是太头疼了。好了,对此大家应该有一个简单的了解了,那跟着笔者往下走,我们看看如何在.NET中使用非常少的代码去完成一个简单的动态逻辑处理。

    RulesEngine 概述

    Microsoft推出的一个规则引擎项目,用于系统中抽象出的业务逻辑/规则/策略。在我们开发的过程中,避免不了的是跟这种反反复复的业务逻辑进行处理,而对于这种动态的规则来说的话,它是比较优雅的一种方式,使用我们减少了对我们代码或者说项目的修改。

    如何使用

    目前我们可以通过nuget的形式进行引入该库,如下所示:

    dotnet add package RulesEngine 
    

    对于规则的配置来说,大家可以直接通过类型化参数,笔者主要是为了大家可以清晰的明白,所以用JSON化配置来做演示。

    //反序列化Json格式规则字符串
    var workflowRules = JsonConvert.DeserializeObject<List<WorkflowRules>>(rulesStr);
     var rulesEngine = new RulesEngine.RulesEngine(workflowRules.ToArray());
    
     //定义规则
                var rulesStr = @"[{
                        ""WorkflowName"": ""UserInputWorkflow"",
                        ""Rules"": [
                          {
                            ""RuleName"": ""CheckAge"",
                            ""ErrorMessage"": ""年龄必须大于18岁."",
                            ""ErrorType"": ""Error"",
                            ""RuleExpressionType"": ""LambdaExpression"",
                            ""Expression"": ""Age > 18""
                          },
                           {
                            ""RuleName"": ""CheckIDNoIsEmpty"",
                            ""ErrorMessage"": ""身份证号不可以为空."",
                             ""ErrorType"": ""Error"",
                            ""RuleExpressionType"": ""LambdaExpression"",
                            ""Expression"": ""IdNo != null""
                          }
                        ]
                      }] ";
    

    如上所示我们定义了规则信息,对于该信息,对于规则信息笔者默认存储的还是JSON数据,当然大家可以进行存储如下内容,将如下数据结构拆分存储到数据库中。

    属性描述
    RuleName 规则名称
    Properties 规则属性,获取或设置规则的自定义属性或者标记
    Operator 操作符
    ErrorMessage 错误消息
    Enabled 获取和设置规则是否已启用
    RuleExpressionType 规则表达式类型,默认为LambdaExpression,当然目前只有这么一个
    WorkflowRulesToInJect 注入工作流程规则
    Rules 规则
    LocalParams 本地参数
    Expression 表达树
    Actions  
    SuccessEvent 完成事件,默认为规则名称

    我们来看一下该代码产生的结果,对于该内容笔者创建了一个类,如下所示:

       public class UserInput
            {
                public string IdNo { get; set; }
                public int Age { get; set; }
            }
    
    static async Task Main(string[] args)
            {
                var userInput = new UserInput
                {
                    IdNo = null,
                    Age = 18
                };
    
                //反序列化Json格式规则字符串
                var workflowRules = JsonConvert.DeserializeObject<List<WorkflowRules>>(rulesStr);
                
                var rulesEngine = new RulesEngine.RulesEngine(workflowRules.ToArray());
    
                List<RuleResultTree> resultList = await rulesEngine.ExecuteAllRulesAsync("UserInputWorkflow", userInput);
                foreach (var item in resultList)
                {               
                     Console.WriteLine("验证成功:{0},消息:{1}",item.IsSuccess,item.ExceptionMessage);
                }
    
                Console.ReadLine();
    
            }
    

    输出结果如下所示:

    验证成功:False,消息:年龄必须大于18岁.
    验证成功:False,消息:身份证号不可以为空.
    

    返回结构resultList如下所示:

     { "Rule":{ "RuleName":"CheckNestedSimpleProp","Properties":null,"Operator":null,"ErrorMessage":"年龄必须大于18岁.",
                    "ErrorType":"Error","RuleExpressionType":"LambdaExpression","WorkflowRulesToInject":null,"Rules":null,"LocalParams":null,"Expression":"Age > 18","Actions":null,"SuccessEvent":null},"IsSuccess":false,"ChildResults":null,"Inputs":{ "input1":{ "IdNo":null,"Age":18} },
                    "ActionResult":{ "Output":null,"Exception":null},"ExceptionMessage":"年龄必须大于18岁.","RuleEvaluatedParams":[]}
    

    表达树内使用扩展方法

    上面相信大家对于规则引擎的使用,有了一个简单的了解,下面我们再来一个进阶版内容。

    比如我觉得通过输入的年龄不准确,我想通过身份证号去计算年龄,那么我该如何操作,正常的情况下,我们会通过扩展方法,然后将身份证号参数进行传递给处理程序,处理程序计算完成后,会返回给我们年龄,而在这个里面我们该如何操作呢?我们往下看。

    通过ReSettings进行增加自定义类型,将扩展方法,因为它们所能使用的方法仅限于[System namespace],所以我们需要将自定义类进行添加到设置中。

       private static readonly ReSettings reSettings = new ReSettings
            {
                CustomTypes = new[] { typeof(IdCardUtil) }
            };
            
    

    修改如下内容:

     var rulesEngine = new RulesEngine.RulesEngine(workflowRules.ToArray(), null, reSettings: reSettings);
    
    var rulesStr = @"[{
                        ""WorkflowName"": ""UserInputWorkflow"",
                        ""Rules"": [
                          {
                            ""RuleName"": ""CheckNestedSimpleProp"",
                            ""ErrorMessage"": ""年龄必须小于18岁."",
                            ""ErrorType"": ""Error"",
                            ""RuleExpressionType"": ""LambdaExpression"",
                            ""Expression"": ""IdNo.GetAgeByIdCard() < 18""
                          },
                           {
                            ""RuleName"": ""CheckNestedSimpleProp1"",
                            ""ErrorMessage"": ""身份证号不可以为空."",
                             ""ErrorType"": ""Error"",
                            ""RuleExpressionType"": ""LambdaExpression"",
                            ""Expression"": ""IdNo != null""
                          }
                        ]
                      }] ";
    

    输出结果如下所示:

    验证成功:False,消息:年龄必须小于18岁.
    验证成功:True,消息:
    

    多对象组合条件

    下面我们修改了一下之前的规则内容,同时又增加了一个类ListItem,我们将内容赋值之后,进行创建一个匿名类型,里面两个属性,useritems,最后通过我们的多条件组合进行逻辑判断。

                var rulesStr = @"[{
                        ""WorkflowName"": ""UserInputWorkflow"",
                        ""Rules"": [
                          {
                            ""RuleName"": ""CheckNestedSimpleProp"",
                            ""ErrorMessage"": ""Value值不是second."",
                            ""ErrorType"": ""Error"",
                            ""RuleExpressionType"": ""LambdaExpression"",
                            ""Expression"": ""user.UserId==1 && items[0].Value==second""
                          }
                        ]
                      }] ";
    
    
                var userInput = new UserInput
                {
                    UserId = 1,
                    IdNo = "11010519491230002X",
                    Age = 18
                };
                var input = new
                {
                    user = userInput,
                    items = new List<ListItem>()
                    {
                        new ListItem{ Id=1,Value="first"},
                        new ListItem{ Id=2,Value="second"}
                    }
                };
    
    

    输出结果如下所示:

    验证成功:False,消息:Value值不是second.
    

    如何实现的?

    对于这个,我们该根据现象去看原理,对于内部的动态树其实是使用了System.Linq.Dynamic.Core,RulesEngine是建立在该库之上,进行抽象出来的,为我们提供了一个规则引擎,那我们来试一下System.Linq.Dynamic.Core

    我们先查询集合数据,编辑一个条件字符串,如下所示:

    var items = input.items.AsQueryable().Where("Id == 1").ToList();
    
    
    foreach (var item in items)
    {
        Console.WriteLine($"Id:{item.Id},Value: {item.Value}");
    }
    

    输出结果:

    Id:1,Value: first
    

    那我们再看看如果是通过表达树,我们是如何进行实现的,如下所示:

                Expression<Func<ListItem, bool>> predicate = x => x.Id == 1;
                //输入条件如下
                var inputItem = new ListItem
                {
                    Id = 1,
                    Value = "second"
                };
    
                if (inputItem.Id !=null)
                {
                    predicate = predicate.And(x=>x.Id==inputItem.Id);
                }
    
                if (inputItem.Id != null)
                {
                    predicate = predicate.And(x => x.Value == inputItem.Value);
                }
                
        public static class PredicateBuilder
        {
            public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1,
                                                                Expression<Func<T, bool>> expr2)
            {
                var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
                return Expression.Lambda<Func<T, bool>>
                      (Expression.And(expr1.Body, invokedExpr), expr1.Parameters);
            }
        }
    

    正常来说是如上这种的,我们进行条件的拼接,相信大家可以通过这种的一个条件进行一个思考,确定什么样的适合自己。

    如果使用动态查询形式如下所示:

    var items = input.items.AsQueryable().Where("Id ==@0  && Value==@1",inputItem.Id,inputItem.Value).ToList();
    

    成功失败事件

    因为对于逻辑验证来说,我们既然要这样做,肯定需要知道到底成功了还是失败了。而这个我们不仅可以通过对象的IsSuccess还可以通过两个事件进行得到逻辑验证的失败与成功,如下所示:

                var discountOffered = "";
    
                resultList.OnSuccess((eventName) =>
                {
                    discountOffered = $"成功事件:{eventName}.";
                });
    
    
                resultList.OnFail(() =>
                {
                    discountOffered = "失败事件.";
                });
    
    

    总结

    有兴趣的话可以看一下System.Linq.Dynamic.Core,因为关于动态表达树解析还是使用的这个项目去做的。另外项目地址在RulesEngine

    https://github.com/hueifeng/BlogSample/tree/master/src/RulesEngineDemo

    https://microsoft.github.io/RulesEngine/

    本文来自博客园,作者:古道轻风,转载请注明原文链接:https://www.cnblogs.com/88223100/p/DotNet_RulesEngine.html

  • 相关阅读:
    Leetcode NO.110 Balanced Binary Tree 平衡二叉树
    Leetcode NO.226 Invert Binary Tree 翻转二叉树
    Leetcode NO.215 Kth Largest Element In An Array 数组中的第K个最大元素
    根据特征的浏览器判断
    Cygwin在打开在当前目录
    【转帖】科学对待 健康养猫 打造快乐孕妇
    解决chrome浏览器安装扩展、应用程序一直处在“检查中”的问题
    对【SQL SERVER 分布式事务解决方案】的心得补充
    关于“点击这里继续访问您选择的百度XXX”
    VBA一例:如何保持文本框焦点
  • 原文地址:https://www.cnblogs.com/88223100/p/DotNet_RulesEngine.html
Copyright © 2011-2022 走看看