需求描述
数据列表如List<Customer>
加载到DataGridView后，如果记录比较多可能需要对其进行二次过滤，即客户端过滤
过滤条件做成可由用户设置的，如下图：
在数据源是DataTable时，使用DataView的RowFilter可以轻松按用户的配置拼接出过滤表达式字符串来，
设置RowFilter就可以实现过滤效果，但是当数据源是List<T>这样由EF,Linq
to sql 等框架返回的集合时要实现上面的功能就需要费点力气了。
问题分析:
首先参考上面的截图,用户设置好过滤条件后会形成:" (工号 = 222 And 部门=人力) Or 性别=女" 这样的过滤表达式,可以表示成(Exp1
And Exp2) Or Exp3
这样的形式.针对"工号=222"这样的Exp求值我们会转变成针对Employe实体的EmpId属性是否等于222的判断(Employe.EmpId==222)，这个可以通过反射方式来实现，将多个Exp求值的结果通过And或Or连接并运算得出最终结果，True表示这一行(Employe)符合.
不过考虑Exp1 Or Exp2 Or
Exp3 这样的条件，如果第一个Exp1是True的话结果必定是True，这个时候还去计算Exp2,Exp3是完全多余的，如果List集合有几万条记录（当然超过几千行的列表对用户来说是没有多少意义的，一般人不会看那么多行，这个时候应该想想过滤条件设置是否合理）那么针对列表的每个实体的每个属性(字段)使用反射的方式计算一遍Exp将是一个比较大的开销,好在And与Or跟算术操作符(+,-,*,/)有所不同，And运算时只要两个操作数中有一个是False就没必要计算另外一个操作数(这里的是Exp)而Or在一个操作数是True时就可以忽略另一个操作数。不过当所的Exp都是false时针对上面"Exp1
Or Exp2 Or
Exp3"这样的表达式计算每个Exp是不可避免的
到这里我们可以看到该问题的本质就是表达式求值,而操作符只限And与Or两个二元操作符，最后结果是True或False.
设计实现:
首先我们将用户设置的过滤表达式转变成逆波兰式(后缀表达式),接着传入每个要判断的实体,使用后缀表达式求出该实体是否符合过滤条件，
当然我们也可以将后缀表达式构建成Expression树，接着将该Expression编译成动态方法(委托)，使用该委托对每个实体做出判断，下面的代码给出了这两种实现，
经过测试发现两种方法速度区别不大。
自己对逆波兰式求值时需要下面的判定表,如果构建Expression树则Expression.AndAlso或Expression.OrElse会自己判断是否对两个操作数都进行计算(参考下面的代码）
代码:
View Code
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Linq.Expressions; using System.Reflection; namespace FIStudio.WinUI.Core { public class ExpParser { public ExpParser(List<Elem> midfixList) { this.MidfixList = midfixList; } public List<Elem> PostfixList { get; private set; } public List<Elem> MidfixList { get; private set; } private Stack<Elem> CalcStack = new Stack<Elem>(); private void GuardMidfixListExist() { if (MidfixList == null || MidfixList.Count <= 0) throw new Exception("中序列表为null或为空!"); } private void EnsurePostfixReady() { if (PostfixList == null) { PostfixList = DoParse(MidfixList); if (PostfixList == null || PostfixList.Count <= 0) throw new Exception("后序列表为null或为空!"); } } /// <summary> /// 判断元素是否符合要求 /// </summary> /// <param name="ent"></param> /// <returns></returns> public bool IsSatisfy(object ent) { GuardMidfixListExist(); EnsurePostfixReady(); CalcStack.Clear(); foreach (var item in PostfixList) { if (item is ExpElem) { CalcStack.Push(item); continue; } #region And 运算 if (item is AndElem) { var op1 = CalcStack.Pop() as ExpElem; var op2 = CalcStack.Pop() as ExpElem; //任意一个是false则直接压入false if (op1.Result == false || op2.Result == false) { CalcStack.Push(new ExpElem() { Result = false }); continue; } if (!op1.Result.HasValue && !op2.Result.HasValue) { op1.Compare(ent); if (op1.Result.Value == false) { CalcStack.Push(new ExpElem() { Result = false }); continue; } op2.Compare(ent); CalcStack.Push(new ExpElem() { Result = op2.Result }); continue; } if (!op1.Result.HasValue && op2.Result == true) { op1.Compare(ent); CalcStack.Push(new ExpElem() { Result = op1.Result }); continue; } if (op1.Result == true && !op2.Result.HasValue) { op2.Compare(ent); CalcStack.Push(new ExpElem() { Result = op2.Result }); continue; } if (op1.Result == true && op2.Result == true) { CalcStack.Push(new ExpElem() { Result = true }); continue; } } #endregion #region Or 运算 if (item is OrElem) { var op1 = CalcStack.Pop() as ExpElem; var op2 = CalcStack.Pop() as ExpElem; //任意一个是true则直接压入true if (op1.Result == true || op1.Result == true) { CalcStack.Push(new ExpElem() { Result = true }); continue; } if (!op1.Result.HasValue && !op2.Result.HasValue) { op1.Compare(ent); if (!op1.Result == true) { CalcStack.Push(new ExpElem() { Result = true }); continue; } op2.Compare(ent); CalcStack.Push(new ExpElem() { Result = op2.Result }); } if (!op1.Result.HasValue && op2.Result == false) { op1.Compare(ent); CalcStack.Push(new ExpElem() { Result = op1.Result }); continue; } if (op1.Result == false && !op2.Result.HasValue) { op2.Compare(ent); CalcStack.Push(new ExpElem() { Result = op2.Result }); continue; } if (op1.Result == false && op2.Result == false) { CalcStack.Push(new ExpElem() { Result = false }); } } #endregion } return (CalcStack.Pop() as ExpElem).Result.Value; } /// <summary> /// 生成判断函数 /// </summary> /// <returns></returns> public Expression<Func<T,bool>> GenIsSatisfyFunc<T>() { GuardMidfixListExist(); EnsurePostfixReady(); Stack<object> stack = new Stack<object>(); ParameterExpression entExp = Expression.Parameter(typeof(T), "ent"); foreach (var elem in PostfixList) { if (elem is ExpElem) { stack.Push(elem); continue; } if (elem is AndElem) { var elem1 = stack.Pop(); var elem2 = stack.Pop(); var exp= Expression.AndAlso(GetCallExpression(elem1,entExp),GetCallExpression(elem2,entExp)); stack.Push(exp); continue; } if(elem is OrElem) { var elem1 = stack.Pop(); var elem2 = stack.Pop(); var exp= Expression.OrElse(GetCallExpression(elem1,entExp),GetCallExpression(elem2,entExp)); stack.Push(exp); continue; } } LambdaExpression lambda= Expression.Lambda<Func<T,bool>>( stack.Pop() as Expression,entExp); return lambda as Expression<Func<T,bool>>; } private Expression GetCallExpression(object elem, ParameterExpression entExp) { if (elem is ExpElem) { return Expression.Call(Expression.Constant(elem), typeof(ExpElem).GetMethod("Compare"), entExp); } return elem as Expression; } /// <summary> /// 中序表达式转后缀表达式 /// </summary> /// <param name="midfix"></param> /// <returns></returns> private List<Elem> DoParse(List<Elem> midfix) { Stack<Elem> stack = new Stack<Elem>(); var list=new List<Elem>(); foreach (var elem in midfix) { if (elem is ExpElem) { list.Add(elem); continue; } if (elem is LBElem) { stack.Push(elem); continue; } if (elem is RBElem) { var e = stack.Pop(); while (!(e is LBElem)) { list.Add(e); e = stack.Pop(); } continue; } if((elem is AndElem) || (elem is OrElem)) { if (stack.Count > 0) { var e = stack.Peek(); while ( !(e is LBElem) && elem.Priority <= e.Priority) { list.Add(stack.Pop()); if (stack.Count <= 0) break; e = stack.Peek(); } } stack.Push(elem); } } while (stack.Count > 0) { list.Add(stack.Pop()); } return list; } } #region 节点定义 public class Elem { public virtual string Name { get; set; } public virtual int Priority { get; set; } public Object Data { get; set; } } /// <summary> /// 左括号 /// 注意stack中只会压入'(','And','Or' /// </summary> public class LBElem : Elem { public override string Name { get { return "("; } } public override int Priority { get { return 59; } } } /// <summary> /// 右括号 /// </summary> public class RBElem : Elem { public override string Name { get { return ")"; } } public override int Priority { get { return 99; } } } public class AndElem : Elem { public override string Name { get { return "And"; } } public override int Priority { get { return 88; } } } public class OrElem : Elem { public override string Name { get { return "Or"; } } public override int Priority { get { return 77; } } } public class ExpElem : Elem { public override int Priority { get { return 66; } } public bool Compare(object ent) { Console.WriteLine("计算了:" + Name); bool? ret=null; if (AssertType == Core.CompareType.Equal) { ret= string.Compare(GetV(ent),Value,true)==0; } if (AssertType == Core.CompareType.NotEqual) { ret = string.Compare(GetV(ent), Value, true) != 0; } if (AssertType == Core.CompareType.Greate) { ret = string.Compare(GetV(ent), Value, true) > 0; } if (AssertType == Core.CompareType.GreateOrEqual) { ret = string.Compare(GetV(ent), Value, true) >= 0; } if (AssertType == Core.CompareType.Less) { ret = string.Compare(GetV(ent), Value, true) < 0; } if (AssertType == Core.CompareType.LessOrEqual) { ret = string.Compare(GetV(ent), Value, true) <= 0; } if (AssertType == Core.CompareType.Contains) { ret = GetV(ent).Contains(Value); } if (AssertType == Core.CompareType.NoContains) { ret =! GetV(ent).Contains(Value); } if (AssertType == Core.CompareType.StartWith) { ret = GetV(ent).StartsWith(Value); } if (AssertType == Core.CompareType.EndWith) { ret = GetV(ent).EndsWith(Value); } if (!ret.HasValue) throw new Exception("未知的CompareType!"); Result = ret; return ret.Value; } public bool? Result { get; set; } public PropertyInfo Property { get; set; } public CompareType AssertType { get; set; } public string Value { get; set; } private string GetV(object ent) { var tmp= Property.GetValue(ent, null); if (tmp == null) tmp = string.Empty; return tmp.ToString(); } } public enum CompareType { Equal, NotEqual, Less, LessOrEqual, Greate, GreateOrEqual, Contains, NoContains, StartWith, EndWith }; #endregion }
参考:
逆波兰式构建方法
1、从左至右扫描一中缀表达式。
2、若读取的是操作数，则判断该操作数的类型，并将该操作数存入操作数堆栈
3、若读取的是运算符
(1)
该运算符为左括号"("，则直接存入运算符堆栈。
(2)
该运算符为右括号")"，则输出运算符堆栈中的运算符到操作数堆栈，直到遇到左括号为止，此时抛弃该左括号。
(3)
该运算符为非括号运算符：
(a)
若运算符堆栈栈顶的运算符为左括号，则直接存入运算符堆栈。
(b)
若比运算符堆栈栈顶的运算符优先级高，则直接存入运算符堆栈。
(c)
若比运算符堆栈栈顶的运算符优先级低或相等，则输出栈顶运算符到操作数堆栈，
直至运算符栈栈顶运算符低于（不包括等于）该运算符优先级,或为左括号，并将当前运算符压入运算符堆栈。
4、当表达式读取完成后运算符堆栈中尚有运算符时，则依序取出运算符到操作数堆栈，直到运算符堆栈为空。
逆波兰表达式求值算法：
1、循环扫描语法单元的项目。
2、如果扫描的项目是操作数，则将其压入操作数堆栈，并扫描下一个项目。
3、如果扫描的项目是一个二元运算符，则对栈的顶上两个操作数执行该运算。
4、如果扫描的项目是一个一元运算符，则对栈的最顶上操作数执行该运算。
5、将运算结果重新压入堆栈。
6、重复步骤2-5，堆栈中即为结果值。
1150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
