表達式樹，一種提高代碼復用性的方式
一、問題源起
在有些情況下，我們的計算邏輯跟傳入數據的內部結構有關係，不僅不同的數據的計算邏輯不同，即使同一種數據結構的計算邏輯也會隨時間變化；例如我們的大數據收集系統，需要根據前方業務人員配置的過濾表達式，來決定數據是否可以入庫；那麼我們就需要這個篩選的邏輯既要有通用性，也需要保證執行的高效性；那麼表達式樹或許是一種可能的選項；
二、什麼是表達式樹
表達式樹是以類似樹的結構來表達代碼邏輯的一種方式；其中每一個節點都是一個表達式，例如一個方法調用或者賦值語句等。
我們可以編譯表達式樹，然後可以像普通方法那樣執行。使用表達式樹，我們可以動態的修改代碼的執行邏輯，同時也可以基於LINQ創建動態查詢並在不同類型的數據上執行。
我們可以使用C#提供的System.Linq.Expressions下的類來手動創建表達式。
三、使用Lambda表達式創建表達式樹
只有將Lambda表達式賦值給Expression
Expression<Func<int, bool>> lambda = num => num < 5;
//生成的表達式樹
.Lambda #Lambda1<System.Func`2[System.Int32,System.Boolean]>(System.Int32 $num) {
$num < 5
}
四、使用API創建表達式樹
我們可以使用System.Linq.Expressions.Expression里提供的眾多的靜態工廠方法，根據需要創建不同類型的節點。
ParameterExpression numParam = Expression.Parameter(typeof(int), "num");
ConstantExpression five = Expression.Constant(5, typeof(int));
BinaryExpression numLessThanFive = Expression.LessThan(numParam, five);
Expression<Func<int, bool>> lambda1 =Expression.Lambda<Func<int, bool>>(
numLessThanFive,
new ParameterExpression[] { numParam }
);
//生成的表達式樹
.Lambda #Lambda1<System.Func`2[System.Int32,System.Boolean]>(System.Int32 $num) {
$num < 5
}
我們可以使用System.Linq.Expressions.Expression里提供的賦值及流程控制的眾多API，來實現更加複雜的代碼邏輯。
// Creating a parameter expression.
ParameterExpression value = Expression.Parameter(typeof(int), "value");
// Creating an expression to hold a local variable.
ParameterExpression result = Expression.Parameter(typeof(int), "result");
// Creating a label to jump to from a loop.
LabelTarget label = Expression.Label(typeof(int));
// Creating a method body.
BlockExpression block = Expression.Block(
// Adding a local variable.
new[] { result },
// Assigning a constant to a local variable: result = 1
Expression.Assign(result, Expression.Constant(1)),
// Adding a loop.
Expression.Loop(
// Adding a conditional block into the loop.
Expression.IfThenElse(
// Condition: value > 1
Expression.GreaterThan(value, Expression.Constant(1)),
// If true: result *= value --
Expression.MultiplyAssign(result,
Expression.PostDecrementAssign(value)),
// If false, exit the loop and go to the label.
Expression.Break(label, result)
),
// Label to jump to.
label
)
);
// Compile and execute an expression tree.
var factorial = Expression.Lambda<Func<int, int>>(block, value);
//生成的表達式樹
.Lambda #Lambda1<System.Func`2[System.Int32,System.Int32]>(System.Int32 $value) {
.Block(System.Int32 $result) {
$result = 1;
.Loop {
.If ($value > 1) {
$result *= $value--
} .Else {
.Break #Label1 { $result }
}
}
.LabelTarget #Label1:
}
}
五、編譯表達式樹
Expression
// Creating an expression tree.
Expression<Func<int, bool>> expr = num => num < 5;
// Compiling the expression tree into a delegate.
Func<int, bool> result = expr.Compile();
// Invoking the delegate and writing the result to the console.
Console.WriteLine(result(4));
// Prints True.
六、表達式樹對方法關鍵部件的表達
我們有以下一個簡單的方法，其中涉及方法的一些重要的基礎部件
- 方法的傳入參數x, y；
- 方法的局部變量sum；
- 方法的返回值類型以及返回操作；
static int Sum(int x, int y)
{
int sum = x + y;
return sum;
}
我們使用Expression.Parameter來聲明需要傳入參數的類型及名字；
var parax = Expression.Parameter(typeof(int), "x");
var paray = Expression.Parameter(typeof(int), "y");
我們使用Expression.Variable來聲明執行過程中需要使用的局部變量；
var sum = Expression.Variable(typeof(int));
我們可以使用LableTarget、GotoExpression、LableExpression來實現方法的return；
static Expression<Func<int, int, int>> SumExpression()
{
var x = Expression.Parameter(typeof(int), "x");
var y = Expression.Parameter(typeof(int), "y");
var sum = Expression.Variable(typeof(int));
var add = Expression.Add(x, y);
var assign = Expression.Assign(sum, add);
var labelTarget = Expression.Label(typeof(int));
var ret = Expression.Return(labelTarget, sum);
var labelExpression = Expression.Label(labelTarget, Expression.Constant(0));
var block = Expression.Block(
new ParameterExpression[] { sum},
assign,
ret,
labelExpression
);
return Expression.Lambda<Func<int, int, int>>(block, x, y);
}
//生成的表達式樹
.Lambda #Lambda1<System.Func`3[System.Int32,System.Int32,System.Int32]>(
System.Int32 $x,
System.Int32 $y) {
.Block(System.Int32 $var1) {
$var1 = $x + $y;
.Return #Label1 { $var1 };
.Label
0
.LabelTarget #Label1:
}
}
七、構建獲取JSON對象字段的值的表達式
構建表達式的時候傳入想要獲取值的字段名字，執行表達式的時候可以獲取對應對象的字段值。
public static Expression<Func<JObject, string>> ValueExpression(string name, ParameterExpression source = null)
{
//JObject obj = null;
//string name = null;
//string result = null;
//if (obj.ContainsKey(name))
//{
// var valueT = obj.GetValue(name);
// result = valueT.ToObject<string>();
//}
//return result;
var result = Expression.Variable(typeof(string));
var paraObj = source ?? Expression.Parameter(typeof(JObject), "jObj");
var constName = Expression.Constant(name);
var getValue = typeof(JObject).GetMethod("GetValue", new Type[] { typeof(string) });
var getValueCall = Expression.Call(paraObj, getValue, constName);
var valueT = Expression.Variable(typeof(JToken));
var valueTAssign = Expression.Assign(valueT, getValueCall);
var toObject = typeof(JToken).GetMethod("ToObject", new Type[] { }).MakeGenericMethod(typeof(string));
var toObjectCall = Expression.Call(valueT, toObject);
var resultAssign = Expression.Assign(result, toObjectCall);
var containBlock = Expression.Block(
valueTAssign,
resultAssign
);
var contain = typeof(JObject).GetMethod("ContainsKey", new Type[] { typeof(string) });
var containCall = Expression.Call(paraObj, contain, constName);
var containCondition = Expression.Condition(containCall, containBlock, Expression.Assign(result, Expression.Constant(string.Empty)));
var target = Expression.Label(typeof(string));
var ret = Expression.Return(target, result);
var block = Expression.Block(
new ParameterExpression[] { result, valueT },
containCondition,
ret,
Expression.Label(target, Expression.Constant(string.Empty))
);
return Expression.Lambda<Func<JObject, string>>(block, paraObj);
}
八、構建Contain的表達式
構建的時候傳入字段名字和測試是否包含的字符串；
public static Expression<Func<JObject, bool>> ContainsExpression(string name, string part, ParameterExpression source = null)
{
var result = Expression.Variable(typeof(bool));
var paraObj = source ?? Expression.Parameter(typeof(JObject), "jObj");
var constPart = Expression.Constant(part);
var fieldValue = Expression.Variable(typeof(string));
var value = ValueExpression(name, paraObj).Body;
var fieldValueAssign = Expression.Assign(fieldValue, value);
var contains = typeof(string).GetMethod("Contains", new Type[] { typeof(string) });
var containsCall = Expression.Call(fieldValue, contains, constPart);
var resultAssign = Expression.Assign(result, containsCall);
var target = Expression.Label(typeof(bool));
var ret = Expression.Return(target, result);
var block = Expression.Block(
new ParameterExpression[] { result, fieldValue },
fieldValueAssign,
resultAssign,
ret,
//Expression.Label(target, Expression.Constant(false))
Expression.Label(target, result)
);
return Expression.Lambda<Func<JObject, bool>>(block, paraObj);
}
九、構建布爾表達式
根據實際的業務需要構建一個簡單的布爾表達式
public static Expression<Func<JObject, bool>> BoolExpression()
{
var paraObj = Expression.Parameter(typeof(JObject), "jObj");
var aContains = ContainsExpression("name", "man", paraObj);
var bContains = ContainsExpression("department", "dev", paraObj);
var and = Expression.AndAlso(aContains.Body, bContains.Body);
return Expression.Lambda<Func<JObject, bool>>(and, paraObj);
}
十、執行布爾表達式
static void Main(string[] args)
{
var obj = JObject.Parse("{" +
"name:'mango'," +
"department:'dev'"+
"}");
var e = BoolExpression();
var result = e.Compile()(obj);
Console.WriteLine(result);
Console.Read();
}
//測試輸出結果 true
//生成的布爾表達式樹
.Lambda #Lambda1<System.Func`2[Newtonsoft.Json.Linq.JObject,System.Boolean]>(Newtonsoft.Json.Linq.JObject $jObj) {
.Block(
System.Boolean $var1,
System.String $var2) {
$var2 = .Block(
System.String $var3,
Newtonsoft.Json.Linq.JToken $var4) {
.If (
.Call $jObj.ContainsKey("name")
) {
.Block() {
$var4 = .Call $jObj.GetValue("name");
$var3 = .Call $var4.ToObject()
}
} .Else {
$var3 = ""
};
.Return #Label1 { $var3 };
.Label
""
.LabelTarget #Label1:
};
$var1 = .Call $var2.Contains("man");
.Return #Label2 { $var1 };
.Label
$var1
.LabelTarget #Label2:
} && .Block(
System.Boolean $var5,
System.String $var6) {
$var6 = .Block(
System.String $var7,
Newtonsoft.Json.Linq.JToken $var8) {
.If (
.Call $jObj.ContainsKey("department")
) {
.Block() {
$var8 = .Call $jObj.GetValue("department");
$var7 = .Call $var8.ToObject()
}
} .Else {
$var7 = ""
};
.Return #Label3 { $var7 };
.Label
""
.LabelTarget #Label3:
};
$var5 = .Call $var6.Contains("dev");
.Return #Label4 { $var5 };
.Label
$var5
.LabelTarget #Label4:
}
}
