支持的平台:.NET Core 3.1、.NET Core 5.0 及以上版本、.NET 4.6.2
Dynamic Expresso 是一个用 .NET Standard 2.0 编写的简单 C# 语句解释器。 Dynamic Expresso 内置了自己的解析逻辑,通过将 C# 语句转换为 .NET lambda 表达式或委托来真正解释 C# 语句。
使用 Dynamic Expresso,开发人员可以创建可脚本化的应用程序、执行无需编译的 .NET 代码或创建动态 LINQ 语句。
语句使用 C# 语言规范的一个子集编写。全局变量或参数可以被注入并在表达式中使用。它不生成程序集,而是即时创建表达式树。
例如,您可以计算数学表达式:
var interpreter = new Interpreter(); var result = interpreter.Eval("8 / 2 + 2");
或解析带有变量或参数的表达式并多次调用它:
var interpreter = new Interpreter().SetVariable("service", new ServiceExample()); string expression = "x > 4 ? service.OneMethod() : service.AnotherMethod()"; Lambda parsedExpression = interpreter.Parse(expression, new Parameter("x", typeof(int))); var result = parsedExpression.Invoke(5);
或生成委托和 lambda 表达式用于 LINQ 查询:
var prices = new [] { 5, 8, 6, 2 }; var whereFunction = new Interpreter().ParseAsDelegate<Func<int, bool>>("arg > 5"); var count = prices.Where(whereFunction).Count();
Dynamic Expresso 在线演示:http://dynamic-expresso.azurewebsites.net/
Dynamic Expresso 可在 [NuGet] 上获得。您可以使用以下命令安装软件包:
PM> Install-Package DynamicExpresso.Core
用于调试的源代码和符号(.pdb 文件)可在 [Symbol Source] 上获得。
dynamic
(ExpandoObject
用于获取属性、方法调用和索引(#142),见 #72。DynamicObject
用于获取属性和索引,见 #142)您可以解析和执行无返回值的表达式(void 表达式),也可以返回任何有效的 .NET 类型。 解析表达式时,您可以指定预期的表达式返回类型。例如,您可以这样写:
var target = new Interpreter(); double result = target.Eval<double>("Math.Pow(x, y) + 5", new Parameter("x", typeof(double), 10), new Parameter("y", typeof(double), 2));
内置解析器还可以理解任何给定表达式的返回类型,因此您可以检查表达式是否返回您期望的内容。
可以使用 Interpreter.SetVariable
方法在表达式中使用变量:
var target = new Interpreter().SetVariable("myVar", 23); Assert.AreEqual(23, target.Eval("myVar"));
变量可以是基本类型或自定义复杂类型(类、结构、委托、数组、集合等)。
可以使用 Interpreter.SetFunction
方法通过委托变量传递自定义函数:
Func<double, double, double> pow = (x, y) => Math.Pow(x, y); var target = new Interpreter().SetFunction("pow", pow); Assert.AreEqual(9.0, target.Eval("pow(3, 2)"));
可以使用 Interpreter.SetExpression
方法传递自定义 Expression。
解析的表达式可以接受一个或多个参数:
var interpreter = new Interpreter(); var parameters = new[] { new Parameter("x", 23), new Parameter("y", 7) }; Assert.AreEqual(30, interpreter.Eval("x + y", parameters));
参数可以是基本类型或自定义类型。您可以解析一次表达式,然后多次使用不同的参数值调用它:
var target = new Interpreter(); var parameters = new[] { new Parameter("x", typeof(int)), new Parameter("y", typeof(int)) }; var myFunc = target.Parse("x + y", parameters); Assert.AreEqual(30, myFunc.Invoke(23, 7)); Assert.AreEqual(30, myFunc.Invoke(32, -2));
名为 this
的变量或参数可以被隐式引用。
class Customer { public string Name { get; set; } } var target = new Interpreter(); // 'this' 被视为特殊标识符,可以隐式访问 target.SetVariable("this", new Customer { Name = "John" }); // 通过 'this' 变量显式引用上下文 Assert.AreEqual("John", target.Eval("this.Name")); // 隐式引用 'this' 变量 Assert.AreEqual("John", target.Eval("Name"));
当前可用的预定义类型有:
Object object
Boolean bool
Char char
String string
SByte Byte byte
Int16 UInt16 Int32 int UInt32 Int64 long UInt64
Single Double double Decimal decimal
DateTime TimeSpan
Guid
Math Convert
您可以使用 Interpreter.Reference
方法引用任何其他自定义 .NET 类型:
var target = new Interpreter().Reference(typeof(Uri)); Assert.AreEqual(typeof(Uri), target.Eval("typeof(Uri)")); Assert.AreEqual(Uri.UriSchemeHttp, target.Eval("Uri.UriSchemeHttp"));
您可以使用 Interpreter.ParseAsDelegate<TDelegate>
方法直接将表达式解析为可以正常调用的 .NET 委托类型。
在下面的示例中,我生成了一个 Func<Customer, bool>
委托,可以在 LINQ where 表达式中使用。
class Customer { public string Name { get; set; } public int Age { get; set; } public char Gender { get; set; } } [Test] public void Linq_Where() { 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 = "customer.Age > 18 && customer.Gender == 'F'"; var interpreter = new Interpreter(); Func<Customer, bool> dynamicWhere = interpreter.ParseAsDelegate<Func<Customer, bool>>(whereExpression, "customer"); Assert.AreEqual(1, customers.Where(dynamicWhere).Count()); }
这是解析表达式的首选方法,您在编译时就知道它可以接受什么参数以及必须返回什么值。
您可以使用 Interpreter.ParseAsExpression<TDelegate>
方法直接将表达式解析为 .NET lambda 表达式(Expression<TDelegate>
)。
在下面的示例中,我生成了一个 Expression<Func<Customer, bool>>
表达式,可以在可查询的 LINQ where 表达式中使用,或在需要表达式的任何其他地方使用。比如 Entity Framework 或其他类似的库。
class Customer { public string Name { get; set; } public int Age { get; set; } public char Gender { get; set; } } [Test] public void Linq_Queryable_Expression_Where() { IQueryable<Customer> 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' }, }).AsQueryable(); string whereExpression = "customer.Age > 18 && customer.Gender == 'F'"; var interpreter = new Interpreter(); Expression<Func<Customer, bool>> expression = interpreter.ParseAsExpression<Func<Customer, bool>>(whereExpression, "customer"); Assert.AreEqual(1, customers.Where(expression).Count()); }
语句可以使用C#语法的一个子集来编写。以下是支持的表达式列表:
支持的运算符:
<table> <thead> <tr> <th>类别</th><th>运算符</th> </tr> </thead> <tbody> <tr> <td>主要</td><td><code>x.y f(x) a[x] new typeof</code></td> </tr> <tr> <td>一元</td><td><code>+ - ! (T)x</code></td> </tr> <tr> <td>乘法</td><td><code>* / %</code></td> </tr> <tr> <td>加法</td><td><code>+ -</code></td> </tr> <tr> <td>关系和类型测试</td><td><code>< > <= >= is as</code></td> </tr> <tr> <td>相等</td><td><code>== !=</code></td> </tr> <tr> <td>逻辑与</td><td><code>&</code></td> </tr> <tr> <td>逻辑或</td><td><code>|</code></td> </tr> <tr> <td>逻辑异或</td><td><code>^</code></td> </tr> <tr> <td>条件与</td><td><code>&&</code></td> </tr> <tr> <td>条件或</td><td><code>||</code></td> </tr> <tr> <td>条件</td><td><code>?:</code></td> </tr> <tr> <td>赋值</td><td><code>=</code></td> </tr> <tr> <td>空合并</td><td><code>??</code></td> </tr> </tbody> </table>运算符优先级遵循C#规则(运算符优先级和结合性)。
出于安全原因,一些运算符(如赋值运算符)可能被禁用。
字符串或字符字面量中支持以下字符转义序列:
\'
- 单引号,用于字符字面量\"
- 双引号,用于字符串字面量\\
- 反斜杠\0
- Unicode字符0\a
- 警报(字符7)\b
- 退格(字符8)\f
- 换页(字符12)\n
- 换行(字符10)\r
- 回车(字符13)\t
- 水平制表符(字符9)\v
- 垂直引号(字符11)可以调用任何标准.NET方法、字段、属性或构造函数。
var service = new MyTestService(); var context = new MyTestContext(); var target = new Interpreter() .SetVariable("x", service) .SetVariable("this", context); Assert.AreEqual(service.HelloWorld(), target.Eval("x.HelloWorld()")); Assert.AreEqual(service.AProperty, target.Eval("x.AProperty")); Assert.AreEqual(service.AField, target.Eval("x.AField")); // 隐式上下文引用 Assert.AreEqual(context.GetContextId(), target.Eval("GetContextId()")); Assert.AreEqual(context.ContextName, target.Eval("ContextName")); Assert.AreEqual(context.ContextField, target.Eval("ContextField"));
var target = new Interpreter(); Assert.AreEqual(new DateTime(2015, 1, 24), target.Eval("new DateTime(2015, 1, 24)"));
Dynamic Expresso还支持:
var x = new int[] { 10, 30, 4 }; var target = new Interpreter() .Reference(typeof(System.Linq.Enumerable)) .SetVariable("x", x); Assert.AreEqual(x.Count(), target.Eval("x.Count()"));
array[0]
)params
关键字)Dynamic Expresso对Lambda表达式提供部分支持。例如,您可以使用任何Linq方法:
var x = new string[] { "this", "is", "awesome" }; var options = InterpreterOptions.Default | InterpreterOptions.LambdaExpressions; // 启用Lambda表达式 var target = new Interpreter(options) .SetVariable("x", x); var results = target.Eval<IEnumerable<string>>("x.Where(str => str.Length > 5).Select(str => str.ToUpper())"); Assert.AreEqual(new[] { "AWESOME" }, results);
请注意,默认情况下解析Lambda表达式是禁用的,因为它会稍微影响性能。
要启用它们,您必须设置InterpreterOptions.LambdaExpressions
标志。
也可以直接从Lambda表达式创建委托:
var options = InterpreterOptions.Default | InterpreterOptions.LambdaExpressions; // 启用Lambda表达式 var target = new Interpreter(options) .SetVariable("increment", 3); // 从Lambda表达式访问变量 var myFunc = target.Eval<Func<int, string, string>>("(i, str) => str.ToUpper() + (i + increment)"); Assert.AreEqual("TEST8", lambda.Invoke(5, "test"));
默认情况下,所有表达式都区分大小写(VARX
与varx
不同,就像在C#中一样)。
有一个选项可以使用不区分大小写的解析器。例如:
var target = new Interpreter(InterpreterOptions.DefaultCaseInsensitive); double x = 2; var parameters = new[] { new Parameter("x", x.GetType(), x) }; Assert.AreEqual(x, target.Eval("x", parameters)); Assert.AreEqual(x, target.Eval("X", parameters));
有时您需要在解析表达式之前检查表达式中使用了哪些标识符(变量、类型、参数)。 可能是因为您想验证它,或者您想要求用户输入给定表达式的参数值。 因为如果您解析一个没有正确参数的表达式,会抛出异常。
在这些情况下,您可以使用Interpreter.DetectIdentifiers
方法获取已使用的标识符列表,包括已知和未知的。
var target = new Interpreter(); var detectedIdentifiers = target.DetectIdentifiers("x + y"); CollectionAssert.AreEqual(new[] { "x", "y" }, detectedIdentifiers.UnknownIdentifiers.ToArray());
在C#中,数字通常被解释为整数,或者如果有小数点则解释为双精度浮点数。
在某些情况下,如果没有指定特定后缀,能够配置数字的默认类型可能会很有用:例如在金融计算中,通常数字被解释为decimal类型。
在这些情况下,您可以使用Interpreter.SetDefaultNumberType
方法设置默认数字类型。
var target = new Interpreter(); target.SetDefaultNumberType(DefaultNumberType.Decimal); Assert.IsInstanceOf(typeof(System.Decimal), target.Eval("45")); Assert.AreEqual(10M/3M, target.Eval("10/3")); // 3.33333333333 而不是 3
并非所有C#语法都受支持。以下是一些不支持的功能示例:
method<type>(arg)
)dynamic
对象操作(目前只支持属性、方法调用和索引)如果在解析过程中出现错误,总是会抛出ParseException
类型的异常。
ParseException
有几个基于错误类型的专门化类(UnknownIdentifierException、NoApplicableMethodException等)。
Interpreter