目錄
1、表達(dá)式樹表達(dá)式樹，在C#中是Expression來定義的，它是一種語法樹，或者說是一種數(shù)據(jù)結(jié)構(gòu)。其主要用于存儲(chǔ)需要計(jì)算、運(yùn)算的一種結(jié)構(gòu)，它只提供存儲(chǔ)功能，不進(jìn)行運(yùn)算。通常Expression是配合Lambda一起使用，lambda可以是匿名方法。Expression可以動(dòng)態(tài)創(chuàng)建。 聲明一個(gè)lambda表達(dá)式，其中可以指明類型，也可以是匿名方法： //Func<int, int, int> func = new Func<int, int, int>((m, n) => m * n + 2); Func<int, int, int> func = (m, n) => m * n + 2; 上述代碼可以使用Expression來定義： Expression<Func<int, int, int>> exp = (m, n) => m * n + 2;//lambda表達(dá)式聲明表達(dá)式樹 Expression的方法體只能是一個(gè)整體，不能具有花括號(hào)，以下代碼是不允許的： Expression<Func<int, int, int>> exp1 = (m, n) =>//方法體只能一體 { return m * n + 2; }; 上述func和exp執(zhí)行結(jié)果相同： int iResult1 = func.Invoke(3, 2); int iResult2 = exp.Compile().Invoke(3, 2); 2、構(gòu)建表達(dá)式樹上述表達(dá)式示例可以通過Expression來自主構(gòu)建，把m、n定義為ParameterExpression參數(shù)，把2定義為常數(shù)表達(dá)式ConstantExpression，使用Expression的靜態(tài)方法，表示乘和加： ParameterExpression parameterLeft = Expression.Parameter(typeof(int), "m");//定義參數(shù) ParameterExpression parameterRight = Expression.Parameter(typeof(int), "n");//定義參數(shù) BinaryExpression binaryMultiply = Expression.Multiply(parameterLeft, parameterRight);//組建第一步的乘法 ConstantExpression constant = Expression.Constant(2, typeof(int)); //定義常數(shù)參數(shù) BinaryExpression binaryAdd = Expression.Add(binaryMultiply, constant);//組建第二步的加法 var expression = Expression.Lambda<Func<int, int, int>>(binaryAdd, parameterLeft, parameterRight);//構(gòu)建表達(dá)式 var func = expression.Compile(); //編譯為lambda表達(dá)式 int iResult3 = func(3, 2); int iResult4 = expression.Compile().Invoke(3, 2); int iResult5 = expression.Compile()(3, 2); 自主構(gòu)建Expression是，參數(shù)名稱的定義，可以不是m、n，可以是其他的a、b或者x、y。 如何構(gòu)建一個(gè)復(fù)雜的表達(dá)式樹？需要使用到Expression中更多的方法、屬性、擴(kuò)展方法等。首先定義一個(gè)類： public class People { public int Age { get; set; } public string Name { get; set; } public int Id; } 基于上面的類，構(gòu)建表達(dá)式： Expression<Func<People, bool>> lambda = x => x.Id.ToString().Equals("5"); 這個(gè)示例中，使用到了int自身的ToString()方法，還使用到了字符串的Equals方法。構(gòu)建過程如下： //以下表達(dá)式樹實(shí)現(xiàn)lambda的表達(dá)式 Expression<Func<People, bool>> lambda = x => x.Id.ToString().Equals("5"); //聲明一個(gè)參數(shù)對(duì)象 ParameterExpression parameterExpression = Expression.Parameter(typeof(People), "x"); //查找字段, 并綁定訪問參數(shù)對(duì)象字段（屬性）的方法：x.Id MemberExpression member = Expression.Field(parameterExpression, typeof(People).GetField("Id")); //以上可以用這個(gè)代替 var temp =Expression.PropertyOrField(parameterExpression, "Id"); //調(diào)用字段的ToString方法：x.Id.ToString() MethodCallExpression method = Expression.Call(member, typeof(int).GetMethod("ToString", new Type[] { }), new Expression[0]); //調(diào)用字符串的Equals方法：x.Id.ToString().Equals("5") MethodCallExpression methodEquals = Expression.Call(method, typeof(string).GetMethod("Equals", new Type[] { typeof(string) }), new Expression[] { Expression.Constant("5", typeof(string))//與常量進(jìn)行比較，也可以是參數(shù) }); //創(chuàng)建表達(dá)式樹 ar expression = Expression.Lambda<Func<People, bool>>(methodEquals, new ParameterExpression[] {parameterExpression }); bool bResult = expression.Compile().Invoke(new People() { Id = 5, Name = "Nigle", Age = 31 }); 3、使用Expression來進(jìn)行不同對(duì)象的相同名字的屬性映射前面構(gòu)建了類People，現(xiàn)在我們構(gòu)建一個(gè)新的類PeopleCopy： public class PeopleCopy { public int Age { get; set; } public string Name { get; set; } public int Id; } 現(xiàn)在聲明一個(gè)People對(duì)象，然后對(duì)People對(duì)象的數(shù)據(jù)進(jìn)行拷貝到PeopleCopy新對(duì)象中去，直接硬編碼的方式： 1. 硬編碼 People people = new People() { Id = 11, Name = "Nigle", Age = 31 }; PeopleCopy peopleCopy = new PeopleCopy() { Id = people.Id, Name = people.Name, Age = people.Age }; 如果這樣編寫，對(duì)于屬性或者字段比較多的類，在拷貝時(shí)，我們需要編寫很多次賦值，代碼也會(huì)很長(zhǎng)。此時(shí)，我們能想到的是通過反射的方式進(jìn)行拷貝： 2. 反射拷貝 public static TOut Trans<TIn, TOut>(TIn tIn) { TOut tOut = Activator.CreateInstance<TOut>(); foreach (var itemOut in tOut.GetType().GetProperties()) { foreach (var itemIn in tIn.GetType().GetProperties()) { if (itemOut.Name.Equals(itemIn.Name)) { itemOut.SetValue(tOut, itemIn.GetValue(tIn)); break; } } } foreach (var itemOut in tOut.GetType().GetFields()) { foreach (var itemIn in tIn.GetType().GetFields()) { if (itemOut.Name.Equals(itemIn.Name)) { itemOut.SetValue(tOut, itemIn.GetValue(tIn)); break; } } } return tOut; } 通過反射，我們可以通過輸出類型的屬性或者字段去查找原類型對(duì)應(yīng)的屬性和字段，然后獲取值，并設(shè)置值的方式進(jìn)行賦值拷貝。除此之外，我們還能想到的是深克隆的序列化方式，進(jìn)行反序列化數(shù)據(jù)： 3. 序列化和反序列化 public class SerializeMapper { /// <summary>序列化反序列化方式/summary> public static TOut Trans<TIn, TOut>(TIn tIn) { //采用的是json序列化，也可以采用其他序列化方式 return JsonConvert.DeserializeObject<TOut>(JsonConvert.SerializeObject(tIn)); } } 前面的三種方法是最為常用的方法，但未使用到本文介紹的表達(dá)式樹。如何將表達(dá)式樹與拷貝結(jié)合起來？有兩種方式【緩存+表達(dá)式】，【泛型+表達(dá)式】 4. 緩存+表達(dá)式樹 /// <summary> /// 生成表達(dá)式樹 緩存 /// </summary> public class ExpressionMapper { private static Dictionary<string, object> _Dic = new Dictionary<string, object>(); /// <summary> /// 字典緩存表達(dá)式樹 /// </summary> public static TOut Trans<TIn, TOut>(TIn tIn) { string key = string.Format("funckey_{0}_{1}", typeof(TIn).FullName, typeof(TOut).FullName); if (!_Dic.ContainsKey(key)) { ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p"); List<MemberBinding> memberBindingList = new List<MemberBinding>(); foreach (var item in typeof(TOut).GetProperties()) { MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name)); //綁定Out和In之間的關(guān)系：Age = p.Age MemberBinding memberBinding = Expression.Bind(item, property); memberBindingList.Add(memberBinding); } foreach (var item in typeof(TOut).GetFields()) { MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name)); MemberBinding memberBinding = Expression.Bind(item, property); memberBindingList.Add(memberBinding); } MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray()); Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, parameterExpression); Func<TIn, TOut> func = lambda.Compile();//拼裝是一次性的 _Dic[key] = func; } return ((Func<TIn, TOut>)_Dic[key]).Invoke(tIn); } } 5. 泛型+表達(dá)式 /// <summary> /// 生成表達(dá)式樹 泛型緩存 /// </summary> /// <typeparam name="TIn"></typeparam> /// <typeparam name="TOut"></typeparam> public class ExpressionGenericMapper<TIn, TOut>//Mapper`2 { private static Func<TIn, TOut> func = null; static ExpressionGenericMapper() { ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p"); List<MemberBinding> memberBindingList = new List<MemberBinding>(); foreach (var item in typeof(TOut).GetProperties()) { MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name)); MemberBinding memberBinding = Expression.Bind(item, property); memberBindingList.Add(memberBinding); } foreach (var item in typeof(TOut).GetFields()) { MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name)); MemberBinding memberBinding = Expression.Bind(item, property); memberBindingList.Add(memberBinding); } MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray()); Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[] { parameterExpression }); func = lambda.Compile();//拼裝是一次性的 } public static TOut Trans(TIn t) { return func(t); } } 除了上述5中方法，還可以使用框架自帶的AutoMapper，首先我們要nuget添加引用AutoMapper即可直接使用，具體代碼為： 6. AutoMapper public class AutoMapperTest { public static TOut Trans<TIn, TOut>(TIn tIn) { return AutoMapper.Mapper.Instance.Map<TOut>(tIn); } } 測(cè)評(píng)：對(duì)上述6種方式進(jìn)行測(cè)評(píng)，每一種拷貝方式運(yùn)行100 0000次： Stopwatch watch = new Stopwatch(); watch.Start(); for (int i = 0; i < 1000000; i++) { //測(cè)試六種方法 PeopleCopy peopleCopy = new PeopleCopy() {Id = people.Id, Name = people.Name,Age = people.Age}; //直接賦值的方式復(fù)制--22ms //PeopleCopy peopleCopy = ReflectionMapper.Trans<People, PeopleCopy>(people); //反射賦值的方式復(fù)制---1573ms //PeopleCopy peopleCopy = SerializeMapper.Trans<People, PeopleCopy>(people); //序列化方式---2716ms //PeopleCopy peopleCopy = ExpressionMapper.Trans<People, PeopleCopy>(people); //表達(dá)式樹 緩存 復(fù)制---517ms //PeopleCopy peopleCopy = ExpressionGenericMapper<People, PeopleCopy>.Trans(people); //表達(dá)式樹 泛型緩存--77ms //PeopleCopy peopleCopy = AutoMapperTest.Trans<People, PeopleCopy>(people); //AutoMapper---260ms } watch.Stop(); Console.WriteLine($"耗時(shí)：{ watch.ElapsedMilliseconds} ms"); 4、表達(dá)式樹構(gòu)建SQL刪選傳統(tǒng)的sql在構(gòu)建條件語句時(shí)，需要通過諸多判斷，進(jìn)而構(gòu)建成完整的查詢語句。 People p = new People()
{
Id = 11,
Name = "Nigle",
Age = 31
};
//拼裝sql的方式
string sql = "SELECT * FROM USER WHERE Id=1";
if (string.IsNullOrWhiteSpace(p.Name))
{
sql += $" and name like '%{p.Name}%'";
}
sql += $" and age >{p.Age}";
事實(shí)上，我們偶爾我們會(huì)使用linq查詢或者lambda表達(dá)式，用于條件篩選，如var lambda = x => x.Age > 5; 事實(shí)上，我們可以構(gòu)建上述Expression: People p = new People()
{
Id = 11,
Name = "Nigle",
Age = 31
};
//拼裝表達(dá)式樹，交給下端用
ParameterExpression parameterExpression = Expression.Parameter(typeof(People), "x");//聲明一個(gè)參數(shù)
Expression propertyExpression = Expression.Property(parameterExpression, typeof(People).GetProperty("Age"));//聲明訪問參數(shù)屬性的對(duì)象
//Expression property = Expression.Field(parameterExpression, typeof(People).GetField("Id"));
ConstantExpression constantExpression = Expression.Constant(5, typeof(int));//聲明一個(gè)常量
BinaryExpression binary = Expression.GreaterThan(propertyExpression, constantExpression);//添加比較方法
var lambda = Expression.Lambda<Func<People, bool>>(binary, new ParameterExpression[] { parameterExpression });//構(gòu)建表達(dá)式主體
bool bResult = lambda.Compile().Invoke(p); //比較值
5、修改表達(dá)式樹本示例將把已經(jīng)構(gòu)建完成的表達(dá)式樹的加法進(jìn)行修改為減法。修改、拼接、讀取節(jié)點(diǎn)，需要使用到ExpressionVisitor類，ExpressionVisitor類能動(dòng)態(tài)的解耦，讀取相關(guān)的節(jié)點(diǎn)和方法。 ExpressionVisitor類中的Visit（Expression node）是解讀表達(dá)式的入口，然后能夠神奇的區(qū)分參數(shù)和方法體，然后將表達(dá)式調(diào)度到此類中更專用的訪問方法中，然后一層一層的解析下去，直到最終的葉節(jié)點(diǎn)！ 首先編寫OperationsVisitor類，用于修改： internal class OperationsVisitor : ExpressionVisitor { public Expression Modify(Expression expression) { return this.Visit(expression); } protected override Expression VisitBinary(BinaryExpression b) { if (b.NodeType == ExpressionType.Add) { Expression left = this.Visit(b.Left); Expression right = this.Visit(b.Right); return Expression.Subtract(left, right); } return base.VisitBinary(b); } protected override Expression VisitConstant(ConstantExpression node) { return base.VisitConstant(node); } } 然后，編寫lambda表達(dá)式，進(jìn)行修改并計(jì)算結(jié)果： //修改表達(dá)式樹 Expression<Func<int, int, int>> exp = (m, n) => m * n + 2; OperationsVisitor visitor = new OperationsVisitor(); Expression expNew = visitor.Modify(exp); int? iResult = (expNew as Expression<Func<int, int, int>>)?.Compile().Invoke(2, 3); Visit這個(gè)這個(gè)方法能夠識(shí)別出來 m*n+2 是個(gè)二叉樹，會(huì)通過下面的圖然后一步一步的進(jìn)行解析，如果遇到m*n 這會(huì)直接調(diào)用VisitBinary(BinaryExpression b)這個(gè)方法，如果遇到m或者n會(huì)調(diào)用VisitParameter(ParameterExpression node)這個(gè)方法，如果遇到2常量則會(huì)調(diào)用VisitConstant(ConstantExpression node)。 ORM與表達(dá)式樹的關(guān)系： 經(jīng)常用到EF，其實(shí)都是繼承Queryable，然后我們使用的EF通常都會(huì)使用 var items = anserDo.GetAll().Where(x => x.OrganizationId == input.oid || input.oid == 0) ,where其實(shí)傳的就是表達(dá)式樹。EF寫的where等lambda表達(dá)式，就是通過ExpressionVisitor這個(gè)類來反解析的！后面將構(gòu)建模擬EF的解析方法。 6、構(gòu)建模擬EF的表達(dá)式樹解析首先，構(gòu)建解析表達(dá)式樹的方法，不能再使用默認(rèn)的。 /// <summary> /// 表達(dá)式樹中的訪問者 /// </summary> internal class ConditionBuilderVisitor : ExpressionVisitor { /// <summary> /// 用于存放條件等數(shù)據(jù) /// </summary> private Stack<string> _StringStack = new Stack<string>(); /// <summary> /// /// </summary> /// <returns></returns> internal string Condition() { string condition = string.Concat(this._StringStack.ToArray()); this._StringStack.Clear(); return condition; } /// <summary> /// 如果是二元表達(dá)式 /// </summary> /// <param name="node"></param> /// <returns></returns> protected override Expression VisitBinary(BinaryExpression node) { if (node == null) throw new ArgumentNullException("BinaryExpression"); this._StringStack.Push(")"); base.Visit(node.Right);//解析右邊 this._StringStack.Push(" " + ToSqlOperator(node.NodeType) + " "); base.Visit(node.Left);//解析左邊 this._StringStack.Push("("); return node; } /// <summary> /// /// </summary> /// <param name="node"></param> /// <returns></returns> protected override Expression VisitMember(MemberExpression node) { if (node == null) throw new ArgumentNullException("MemberExpression"); this._StringStack.Push(" [" + node.Member.Name + "] "); return node; return base.VisitMember(node); } /// <summary> /// 將節(jié)點(diǎn)類型轉(zhuǎn)換為Sql的操作符 /// </summary> /// <param name="type"></param> /// <returns></returns> string ToSqlOperator(ExpressionType type) { switch (type) { case (ExpressionType.AndAlso): case (ExpressionType.And): return "AND"; case (ExpressionType.OrElse): case (ExpressionType.Or): return "OR"; case (ExpressionType.Not): return "NOT"; case (ExpressionType.NotEqual): return "<>"; case ExpressionType.GreaterThan: return ">"; case ExpressionType.GreaterThanOrEqual: return ">="; case ExpressionType.LessThan: return "<"; case ExpressionType.LessThanOrEqual: return "<="; case (ExpressionType.Equal): return "="; default: throw new Exception("不支持該方法"); } } /// <summary> /// 常量表達(dá)式 /// </summary> /// <param name="node"></param> /// <returns></returns> protected override Expression VisitConstant(ConstantExpression node) { if (node == null) throw new ArgumentNullException("ConstantExpression"); this._StringStack.Push(" '" + node.Value + "' "); return node; } /// <summary> /// 方法表達(dá)式 /// </summary> /// <param name="m"></param> /// <returns></returns> protected override Expression VisitMethodCall(MethodCallExpression m) { if (m == null) throw new ArgumentNullException("MethodCallExpression"); string format; switch (m.Method.Name) { case "StartsWith": format = "({0} LIKE {1}+'%')"; break; case "Contains": format = "({0} LIKE '%'+{1}+'%')"; break; case "EndsWith": format = "({0} LIKE '%'+{1})"; break; default: throw new NotSupportedException(m.NodeType + " is not supported!"); } this.Visit(m.Object); this.Visit(m.Arguments[0]); string right = this._StringStack.Pop(); string left = this._StringStack.Pop(); this._StringStack.Push(String.Format(format, left, right)); return m; } } 然后，外部就可以通過編寫表達(dá)式樹的查詢條件，再通過這個(gè)類的實(shí)例進(jìn)行解析成對(duì)應(yīng)的SQL語句： { Expression<Func<People, bool>> lambda = x => x.Age > 5 && x.Id > 5 && x.Name.StartsWith("1") && x.Name.EndsWith("1") && x.Name.Contains("2"); //“ x => x.Age > 5 && x.Id > 5”等同于sql語句 string sql = string.Format("Delete From [{0}] WHERE {1}", typeof(People).Name, " [Age]>5 AND [ID] >5"); ConditionBuilderVisitor vistor = new ConditionBuilderVisitor(); vistor.Visit(lambda); Console.WriteLine(vistor.Condition()); } { Expression<Func<People, bool>> lambda = x => x.Age > 5 && x.Name == "A" || x.Id > 5; ConditionBuilderVisitor vistor = new ConditionBuilderVisitor(); vistor.Visit(lambda); Console.WriteLine(vistor.Condition()); } { Expression<Func<People, bool>> lambda = x => x.Age > 5 || (x.Name == "A" && x.Id > 5); ConditionBuilderVisitor vistor = new ConditionBuilderVisitor(); vistor.Visit(lambda); Console.WriteLine(vistor.Condition()); } { Expression<Func<People, bool>> lambda = x => (x.Age > 5 || x.Name == "A") && x.Id > 5; ConditionBuilderVisitor vistor = new ConditionBuilderVisitor(); vistor.Visit(lambda); Console.WriteLine(vistor.Condition()); } 7、連接表達(dá)式樹表達(dá)式樹除了可以修改外，我們還可以通過對(duì)其進(jìn)行表達(dá)式樹的拼接，將兩個(gè)及其以上的表達(dá)式樹進(jìn)行拼接在一起。先編寫一個(gè)新的NewExpressionVisitor，繼承自ExpressionVisitor，用于拼接時(shí)，調(diào)用的。它是一個(gè)內(nèi)部類，放在訪問拼接類的內(nèi)部ExpressionExtend。然后再編寫對(duì)應(yīng)的擴(kuò)展方法：Add、Or、Not /// <summary> /// 合并表達(dá)式 And Or Not擴(kuò)展 /// </summary> public static class ExpressionExtend { /// <summary>合并表達(dá)式 expLeft and expRight</summary> public static Expression<Func<T, bool>> And<T>(this Expression<Func<T,bool>> expLeft,Expression<Func<T,bool>> expRight) { //用于將參數(shù)名進(jìn)行替換，二者參數(shù)不一樣 ParameterExpression newParameter = Expression.Parameter(typeof(T), "c"); NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter); //需要先將參數(shù)替換為一致的，可能參數(shù)名不一樣 var left = visitor.Replace(expLeft.Body);//左側(cè)的表達(dá)式 var right = visitor.Replace(expRight.Body);//右側(cè)的表達(dá)式 var body = Expression.And(left, right);//合并表達(dá)式 return Expression.Lambda<Func<T, bool>>(body, newParameter); } /// <summary>合并表達(dá)式 expr1 or expr2</summary> public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2) { ParameterExpression newParameter = Expression.Parameter(typeof(T), "c"); NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter); //需要先將參數(shù)替換為一致的，可能參數(shù)名不一樣 var left = visitor.Replace(expr1.Body); var right = visitor.Replace(expr2.Body); var body = Expression.Or(left, right); return Expression.Lambda<Func<T, bool>>(body, newParameter); } public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expr) { var candidateExpr = expr.Parameters[0]; var body = Expression.Not(expr.Body); return Expression.Lambda<Func<T, bool>>(body, candidateExpr); } /// <summary>參數(shù)替換者 </summary> class NewExpressionVisitor : ExpressionVisitor { public ParameterExpression _NewParameter { get; private set; } public NewExpressionVisitor(ParameterExpression param) { this._NewParameter = param;//用于把參數(shù)替換了 } /// <summary> 替換</summary> public Expression Replace(Expression exp) { return this.Visit(exp); } protected override Expression VisitParameter(ParameterExpression node) { //返回新的參數(shù)名 return this._NewParameter; } } } 下面是測(cè)試代碼： Expression<Func<People, bool>> lambda1 = x => x.Age > 5; Expression<Func<People, bool>> lambda2 = p => p.Id > 5; Expression<Func<People, bool>> lambda3 = lambda1.And(lambda2); Expression<Func<People, bool>> lambda4 = lambda1.Or(lambda2); Expression<Func<People, bool>> lambda5 = lambda1.Not(); List<People> people = new List<People>() { new People(){Id=4,Name="123",Age=4}, new People(){Id=5,Name="234",Age=5}, new People(){Id=6,Name="345",Age=6}, }; List<People> lst1 = people.Where(lambda3.Compile()).ToList(); List<People> lst2 = people.Where(lambda4.Compile()).ToList(); List<People> lst3 = people.Where(lambda5.Compile()).ToList(); Expression目前只支持ExpressionType的84種操作符Add， AndAlso等等，然后VisitMethodCall這個(gè)方法中表示lambda能解析出來的方法名字，如果需要可以自行修改會(huì)得到對(duì)應(yīng)的sql語句的where條件！
|
|
|
