.NET RulesEngine（规则引擎）的使用详解

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

rulesengine 概述

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，我们将内容赋值之后，进行创建一个匿名类型，里面两个属性，user和items，最后通过我们的多条件组合进行逻辑判断。

            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

以上就是.net rulesengine（规则引擎）的使用详解的详细内容，更多关于.net rulesengine（规则引擎）的使用的资料请关注其它相关文章！