C#使用第三方元件實現動態解析和求值字串表示式

2022-06-22 18:04:56

介紹

在進行專案開發的時候，剛好需要用到對字串表示式進行求值的處理場景，因此尋找了幾個符合要求的第三方元件LambdaParser、DynamicExpresso、Z.Expressions，它們各自功能有所不同，不過基本上都能滿足要求。它們都可以根據相關的引數進行字串表示式的求值，本篇隨筆介紹它們三者的使用程式碼，以及總結其中的一些經驗。

數學表示式求值應該是最常見的，一般我們在應用程式中如果需要計算，是需要對引數進行型別轉換，然後在後臺進行相應計算的。但是如果是計算一些符合的式子或者公式，特別是引數不一定的情況下，這個就比較麻煩。利用第三方元件，對錶示式進行快速求值，可以滿足我們很多實際專案上的需求，而且處理起來也很方便。

這幾個第三方元件，它們的GitHub或官網地址：

https://github.com/nreco/lambdaparser

https://github.com/dynamicexpresso/DynamicExpresso

https://eval-expression.net/eval-execute

不過Z.Expressions是收費的，前兩者都是免費的。

我使用字串表示式進行求值的場景，主要就是想對一個SQL條件的表示式，轉換為普通的字串表示式，然後根據物件的引數值，進行求值處理，這幾個表示式求值元件都支援這樣的操作，為了更好演示它們的使用效果及程式碼，我們專門建立了一個案例程式碼進行測試驗證，確認滿足我的實際需求。

1、Z.Expressions.Eval 表示式解析

Z.Expression.Eval是一個免費開源的（後續收費了），可延伸的，超輕量級的公式化語言解析執行工具包，可以在執行時解析C#表示式的開源免費元件。Z.Expressions從2.0開始支援了NetCore，但是收費的。參考地址：https://riptutorial.com/eval-expression/learn/100000/getting-started 或者 https://eval-expression.net/eval-execute。

在執行時解析C#表示式，例如一些工資或者成本核算系統，就需要在後臺動態設定計算表示式，從而進行計算求值。

下面對幾個不同的案例程式碼進行介紹及輸出結果驗證

匿名型別處理

//匿名型別
string expression = "a*2 + b*3 - 3";
int result = Eval.Execute<int>(expression, new { a = 10, b = 5 });
Console.WriteLine("{0} = {1}", expression, result); //a*2 + b*3 - 3 = 32

指定引數

//指定引數
expression = "{0}*2 + {1}*3 - 3";
result = Eval.Execute<int>(expression, 10, 5);
Console.WriteLine("{0} = {1}", expression, result);//{0}*2 + {1}*3 - 3 = 32

類物件

//類物件
expression = "a*2 + b*3 - 3";
dynamic expandoObject = new ExpandoObject();
expandoObject.a = 10;
expandoObject.b = 5;

result = Eval.Execute<int>(expression, expandoObject);
Console.WriteLine("{0} = {1}", expression, result); //a*2 + b*3 - 3 = 32

字典物件

//字典物件
expression = "a*2 + b*3 - 3";
var values = new Dictionary<string, object>()
{
    { "a", 10 },
    { "b", 5 }
};

result = Eval.Execute<int>(expression, values);
Console.WriteLine("{0} = {1}", expression, result);//a*2 + b*3 - 3 = 32

委託型別

//委託型別1
expression = "{0}*2 + {1}*3";
var compiled = Eval.Compile<Func<int, int, int>>(expression);
result = compiled(10, 15);
Console.WriteLine("{0} = {1}", expression, result);//{0}*2 + {1}*3 = 65

//委託型別2
expression = "a*2 + b*3";
compiled = Eval.Compile<Func<int, int, int>>(expression, "a", "b");
result = compiled(10, 15);
Console.WriteLine("{0} = {1}", expression, result);//a*2 + b*3 = 65

字串擴充套件支援

//字串擴充套件支援-匿名型別
expression = "a*2 + b*3 - 3";
result = expression.Execute<int>(new { a = 10, b = 5 });
Console.WriteLine("{0} = {1}", expression, result);//a*2 + b*3 - 3 = 32

//字串擴充套件支援-字典型別
expression = "a*2 + b*3 - 3";
values = new Dictionary<string, object>()
{
    { "a", 10 },
    { "b", 5 }
};
result = expression.Execute<int>(values);
Console.WriteLine("{0} = {1}", expression, result);//a*2 + b*3 - 3 = 32

可以看出，該元件提供了非常豐富的表示式運算求值處理方式。

2、NReco.LambdaParser 表示式解析

我看中這個元件的處理，主要是因為它能夠傳入引數是字典型別，這樣我可以非常方便的傳入各種型別的引數，並且這個元件比較接近SQL語法，可以設定利用常規的=代替表示式的==，這樣對於SQL語句來說是方便的。

它的案例程式碼如下所示。

/// <summary>
/// NReco.LambdaParser 表示式解析
/// </summary>
private void btnLamdaParser_Click(object sender, EventArgs e)
{
    var lambdaParser = new NReco.Linq.LambdaParser();

    var dict = new Dictionary<string, object>();
    dict["pi"] = 3.14M;
    dict["one"] = 1M;
    dict["two"] = 2M;
    dict["test"] = "test";
    Console.WriteLine(lambdaParser.Eval("pi>one && 0<one ? (1+8)/3+1*two : 0", dict)); // --> 5
    Console.WriteLine(lambdaParser.Eval("test.ToUpper()", dict)); // --> TEST


    Console.WriteLine(lambdaParser.Eval("pi>one && 0<one ", dict)); // --> True
    Console.WriteLine(lambdaParser.Eval("test.ToUpper()", dict)); // --> TEST
}

同樣它支援的算術符號操作有：+, -, *, /, %，以及常規的邏輯判斷：==, !=, >, <, >=, <=，如果需要它允許把=作為==比較，那麼設定屬性 AllowSingleEqualSign = true 即可，如下程式碼。

var lambdaParser = new LambdaParser();
    lambdaParser.AllowSingleEqualSign = true;//可以使用 = 作為邏輯判斷，如Title ="Leader"，而不用Title =="Leader"
    var evalResult = lambdaParser.Eval(repalce, dict);

該元件沒有過多提供例子，不過它的例子提供的關鍵點，基本上都能實現我們實際的表示式求值處理要求了。

3、DynamicExpresso 表示式解析

相對於LambdaParser的簡潔、Z.Expressions收費處理，Dynamic Expresso 可以說是提供了一個非常強大的、免費開源的處理類庫，它提供非常多的表示式求值的實現方式。

簡單的字串表示式求值如下程式碼

var interpreter = new<strong> Interpreter</strong>();
var result = interpreter.Eval("8 / 2 + 2");

但是一般我們需要傳入一定的引數進行表示式求值的。

var target = new<strong> Interpreter</strong>();
double result = target.Eval<double>("Math.Pow(x, y) + 5",
     new Parameter("x", typeof(double), 10),
     new Parameter("y", typeof(double), 2));

或者

var interpreter = new<strong> Interpreter</strong>();
var parameters = new[] {
    new Parameter("x", 23),
    new Parameter("y", 7)
};
Assert.AreEqual(30, interpreter.Eval("x + y", parameters));

或者賦值指定的引數

var target = new Interpreter().SetVariable("myVar", 23);
Assert.AreEqual(23, target.Eval("myVar"));

對於字典型別的處理，是我喜歡的方式，它的案例程式碼如下所示。

var interpreter = new<strong> Interpreter</strong>();
var dict = new Dictionary<string, object>();
dict.Add("a", 1.0);
dict.Add("b", 2);
dict.Add("d", 4);
dict.Add("e", 5);
dict.Add("str", 'f');

foreach (var v in dict)
{
    object value = v.Value;
    int para = 0;
    if (int.TryParse(v.Value.ToString(), out para))
    {
        value = (float)para;
    }
    interpreter.SetVariable(v.Key, value);
}
Console.WriteLine(interpreter.Eval("a+b").ToString()); //3
Console.WriteLine(interpreter.Eval("a/b").ToString()); //0.5
Console.WriteLine(interpreter.Eval("a > b").ToString()); //False
Console.WriteLine(interpreter.Eval("str == 'f'").ToString()); //True

對於類的屬性表示式查詢，測試程式碼如下所示

var customers = new List<Customer> {
        new Customer() { Name = "David", Age = 31, Gender = 'M' },
        new Customer() { Name = "Mary", Age = 29, Gender = 'F' },
        new Customer() { Name = "Jack", Age = 2, Gender = 'M' },
        new Customer() { Name = "Marta", Age = 1, Gender = 'F' },
        new Customer() { Name = "Moses", Age = 120, Gender = 'M' },
    };
    string whereExpression = "<strong>customer.Age > 18 && customer.Gender == 'F'</strong>";

    Func<Customer, bool> dynamicWhere = interpreter.ParseAsDelegate<Func<Customer, bool>>(whereExpression, "<strong>customer</strong>");
    Console.WriteLine(customers.Where(dynamicWhere).Count());//=> 1


    var customer_query = (new List<Customer> {
        new Customer() { Name = "David", Age = 31, Gender = 'M' },
        new Customer() { Name = "Mary", Age = 29, Gender = 'F' },
        new Customer() { Name = "Jack", Age = 2, Gender = 'M' },
        new Customer() { Name = "Marta", Age = 1, Gender = 'F' },
        new Customer() { Name = "Moses", Age = 120, Gender = 'M' },
    }).AsQueryable();
    whereExpression = "<strong>customer.Age > 18 && customer.Gender == 'F'</strong>";

    var expression = interpreter.ParseAsExpression<Func<Customer, bool>>(whereExpression, "<strong>customer</strong>");
    Console.WriteLine(customer_query.Where(expression).Count());//=> 1

4、SQL條件語句的正規表示式和字串求值處理

前面介紹了幾個表示式求值處理的元件，他們基本上都能夠滿足實際的求值處理，只是提供的功能有所側重。

我主要希望用它來對特定的表示式進行求布林值，判斷表示式是否滿足條件的。

例如對於sql條件語句:(Amount> 500 and Title ='Leader') or Age> 32, 以及一個字典物件的引數集合，我希望能夠提取裡面的Amount、Title、Leader、Age這樣的鍵，然後給字典賦值，從而判斷表示式的值。

由於sql表示式和C#程式碼的表示式邏輯語法有所差異，我們需要替換and Or 為實際的&& || 字元，因此給定替換的正規表示式：sand|sor

而我需要先提取條件語句的鍵值內容，然後獲得指定的鍵引數，那麼也要提供一個正規表示式：w*[^>=<!'()s] ，這個正規表示式主要就是提取特定的字元匹配。

提取內容的C#程式碼邏輯如下所示。

private void btnRegexExtract_Click(object sender, EventArgs e)
        {
            var source = this.txtSource.Text;

            //先替換部分內容 sand|sor
            source = Regex.Replace(source, this.txtReplaceRegex.Text, "");//替換表示式
            //增加一行記錄主內容
            this.txtContent.Text += "替換正規表示式後內容:";
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.Text += source;
            this.txtContent.AppendText(Environment.NewLine);

            //在匹配內容處理
            var regex = new Regex(this.txtRegex.Text);
            var matches = regex.Matches(source);

            //遍歷獲得每個匹配的內容
            var fieldList = new List<string>();
            int i = 0;
            foreach (Match match in matches)
            {
                this.txtContent.AppendText(match.Value);
                this.txtContent.AppendText(Environment.NewLine);
                if (i++ % 2 == 0)
                {
                    fieldList.Add(match.Value);
                }
            }
            this.txtContent.AppendText("獲得表示式鍵：");
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(fieldList.ToJson());
            this.txtContent.AppendText(Environment.NewLine);

            var repalce = ReplaceExpress(this.txtSource.Text);
            this.txtContent.AppendText("替換And=>&& or=>|| '=> " 操作符後內容:");
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(repalce);
        }

/// <summary>
        /// 替換And=>&& or=>|| '=> " 操作符後內容
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        private string ReplaceExpress(string source)
        {
            //操作符替換表示式
            var repalce = Regex.Replace(source, @"sands", " && "); //and => &&
            repalce = Regex.Replace(repalce, @"sors", " || "); //or => ||
            repalce = Regex.Replace(repalce, @"'", """); //'=> "

            return repalce;
        }

表示式處理結果如下所示

它的邏輯程式碼如下。

private void btnRunExpression_Click(object sender, EventArgs e)
        {
            //操作符替換表示式
            var repalce = ReplaceExpress(this.txtSource.Text);
            this.txtContent.Text = "替換And=>&& or=>|| '=> " 操作符後內容:";
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.Text += repalce;
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(Environment.NewLine);

            //(Amount> 500 and Title ='Leader') or Age> 32
            var dict = new Dictionary<string, object>();
            dict["Amount"] = 600;
            dict["Title"] = "Leader";
            dict["Age"] = 40;
            
            this.txtContent.AppendText("字典內容");
            foreach(var key in dict.Keys)
            {
                this.txtContent.AppendText($"{key}:{dict[key]} ");
            }
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(Environment.NewLine);

            //var valComparer = new ValueComparer() { NullComparison = ValueComparer.NullComparisonMode.Sql };
            //var lambdaParser = new LambdaParser(valComparer);
            var lambdaParser = new LambdaParser();
            lambdaParser.AllowSingleEqualSign = true;//可以使用=作為判斷，如Title ="Leader"，而不用Title =="Leader"
            var express1 = "(Amount> 500 && Title = "Leader") or Age>30";
            var result1 = lambdaParser.Eval(express1, dict);
            this.txtContent.AppendText("LambdaParser 表示式處理：");
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(express1 + " => " + result1);

            var express2 = "( Amount> 500 && Title ="leader" )"; //字串比較（''=> ""）
            var result2 = lambdaParser.Eval(express2, dict);
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(express2 + " => " + result2);

            var express3 = "Amount> 500";
            var result3 = lambdaParser.Eval(express3, dict);
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(express3 + " => " + result3);

            var express4 = "Title = "Leader" "; //字串比較（''=> ""）
            var result4 = lambdaParser.Eval(express4, dict);
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(express4 + " => " + result4);

            this.txtContent.AppendText(Environment.NewLine);
            Console.WriteLine(lambdaParser.Eval("Title.ToString()", dict)); // --> Leader

            //DynamicExpresso 表示式解析處理
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText("DynamicExpresso 表示式解析處理：");

            var interpreter = new Interpreter();
            foreach (var v in dict)
            {
                interpreter.SetVariable(v.Key, v.Value);
            }
            //express3 = "Amount> 500";
            var result33 = interpreter.Eval(express3);
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(express3 + " => " + result33);

            //使用''出錯，字串比較需要使用""
            try
            {
                express4 = "Title == "Leader" ";
                var result44 = interpreter.Eval(express4);
                this.txtContent.AppendText(Environment.NewLine);
                this.txtContent.AppendText(express4 + " => " + result44);
            }
            catch(Exception ex)
            {
                this.txtContent.AppendText(Environment.NewLine);
                this.txtContent.AppendText(express4 + ",解析出錯 => " + ex.Message);
            }

            //var dict = new Dictionary<string, object>();
            //dict["Amount"] = 600;
            //dict["Title"] = "Leader";
            //dict["Age"] = 40;
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText("Z.Expressions.Eval 表示式解析：");
            var result333 = express3.Execute<bool>(dict);
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(express3 + " => " + result333);

            express4 = "Title == 'Leader'"; //Z.Expressions可以接受 ' 代替 "
            var result444 = express4.Execute<bool>(dict);
            this.txtContent.AppendText(Environment.NewLine);
            this.txtContent.AppendText(express4 + " => " + result444);
        }

這樣我們就可以轉換SQL條件表示式為實際的C#表示式，並通過賦值引數，實現動態表示式的求值處理。

到此這篇關於C#使用第三方元件實現動態解析和求值字串表示式的文章就介紹到這了,更多相關C#解析求值字串表示式內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！

C#使用第三方元件實現動態解析和求值字串表示式

目錄

介紹

1、Z.Expressions.Eval 表示式解析

2、NReco.LambdaParser 表示式解析

3、DynamicExpresso 表示式解析

4、SQL條件語句的正規表示式和字串求值處理

熱門文章