.NET RulesEngine（規則引擎）的使用詳解

.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 = "失敗事件.";
          });