C#使用第三方組件實現動態解析和求值字符串表達式
介紹
在進行項目開發的時候，剛好需要用到對字符串表達式進行求值的處理場景，因此尋找瞭幾個符合要求的第三方組件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, @"\sand\s", " && "); //and => &&
repalce = Regex.Replace(repalce, @"\sor\s", " || "); //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#解析 求值字符串表達式內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- Python eval() 函數看這一篇就夠瞭
- python中的eval函數使用實例
- Python函數的作用域及內置函數詳解
- C#值類型、引用類型、泛型、集合、調用函數的表達式樹實踐
- C#目錄和文件管理操作詳解