NET Lambda表达式工具类
帮助类
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
using System; using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; using System.Reflection; using xFramework.Enums; using xFramework.Extends; namespace Commx.Utilx { /// <summary> /// 表达式工具类 /// </summary> public static class ExpressionUtil { /// <summary> /// 把 查询对象 转换成 拉姆达表达式 /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="TSearch"></typeparam> /// <param name="searchData"></param> /// <returns></returns> public static Func<T, bool> ConvertWhereLambda<T, TSearch>(TSearch searchData) { // x => true Expression<Func<T, bool>> where = xBiz => true; if (searchData == null) return where.Compile(); var tPropertityArr = typeof(T).GetProperties(); var tsearchPropertityArr = typeof(TSearch).GetProperties(); //构建Lambda表达式 x => var parameter = Expression.Parameter(typeof(T), "x"); foreach (var itemPropertity in tsearchPropertityArr) { var fieldName = itemPropertity.Name; if (fieldName == "ROWUID") continue; var contains = tPropertityArr.FirstOrDefault(x => x.Name == fieldName); if (contains == null) continue; var checkTuple = itemPropertity.CheckValidValue(searchData); if (!checkTuple.isValid) continue; // 表达式左侧 like: p.Name var left = Expression.PropertyOrField(parameter, fieldName); // 表达式右侧,比较值, like '张三' var fieldValue = checkTuple.value; var right = Expression.Constant(fieldValue); // 表达式连接符 Expression constant; // 属性的连接符 var searchConditionEnum = itemPropertity.GetSearchConditionAttribute(); // 属性的连接符 Convert 表达式连接符 switch (searchConditionEnum) { case SearchConditionEnum.Gt: constant = Expression.GreaterThan(left, right); break; case SearchConditionEnum.Gte: constant = Expression.GreaterThanOrEqual(left, right); break; case SearchConditionEnum.Lt: constant = Expression.LessThan(left, right); break; case SearchConditionEnum.Lte: constant = Expression.LessThanOrEqual(left, right); break; case SearchConditionEnum.DateRange: var itemValue = right.Value; if (itemValue == null) continue; var itemDateArr = itemValue as string[]; var tuple = itemDateArr.ConvertArrToDateTuple(); var itemStartDateBoo = tuple.firstBoo; var itemStartDate = tuple.firstDate; var itemEndDateBoo = tuple.secondBoo; var itemEndDate = tuple.secondDate; if (itemStartDateBoo && itemEndDateBoo) { // x => x.Date >= yesterday var itemLeft = Expression.Constant(itemStartDate); var itemLeftConstant = Expression.GreaterThanOrEqual(left, itemLeft); // x => x.Date <= tomorrow var itemRight = Expression.Constant(itemEndDate); var itemRightConstant = Expression.LessThanOrEqual(left, itemRight); constant = Expression.And(itemLeftConstant, itemRightConstant); } else if (itemStartDateBoo && !itemEndDateBoo) { // x => x.Date >= yesterday var itemLeft = Expression.Constant(itemStartDate); constant = Expression.GreaterThanOrEqual(left, itemLeft); } else if (!itemStartDateBoo && itemEndDateBoo) { // x => x.Date >= yesterday var itemRight = Expression.Constant(itemEndDate); constant = Expression.GreaterThanOrEqual(left, itemRight); } else { constant = null; } break; case SearchConditionEnum.In: constant = CaseIn(itemPropertity, left, right); break; case SearchConditionEnum.Equals: default: constant = Expression.Equal(left, right); break; } if (constant != null) where = where.And(Expression.Lambda<Func<T, bool>>(constant, parameter)); } return where.Compile(); } /// <summary> /// 特殊处理 In: 集合/数组/字符串/数字 /// </summary> /// <param name="itemPropertity"></param> /// <param name="left"></param> /// <param name="right"></param> /// <returns></returns> private static Expression CaseIn(PropertyInfo itemPropertity, MemberExpression left, ConstantExpression right) { Expression constant; var propertyType = itemPropertity.PropertyType; // like 查询,需要调用外部int或string的Contains方法 MethodInfo method = null; if (propertyType.Name.Contains("List") || propertyType.IsArray) { method = propertyType.GenericTypeArguments.FirstOrDefault() == typeof(int) ? typeof(List<int>).GetMethod("Contains", new Type[] { typeof(int) }) : typeof(List<string>).GetMethod("Contains", new Type[] { typeof(string) }); constant = Expression.Call(right, method, left); } else { // TODO: 如果值为null,会引发空异常 method = propertyType == typeof(int) ? typeof(int).GetMethod("Contains", new Type[] { typeof(int) }) : typeof(string).GetMethod("Contains", new Type[] { typeof(string) }); constant = Expression.Call(left, method, right); } return constant; } public static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge) { // build parameter map (from parameters of second to parameters of first) var map = first.Parameters.Select((f, i) => new { f, s = second.Parameters[i] }).ToDictionary(p => p.s, p => p.f); // replace parameters in the second lambda expression with parameters from the first var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body); // apply composition of lambda expression bodies to parameters from the first expression return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters); } public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second) { return first.Compose(second, Expression.And); } } public class ParameterRebinder : ExpressionVisitor { private readonly Dictionary<ParameterExpression, ParameterExpression> map; public ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map) { this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>(); } public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp) { return new ParameterRebinder(map).Visit(exp); } protected override Expression VisitParameter(ParameterExpression p) { ParameterExpression replacement; if (map.TryGetValue(p, out replacement)) { p = replacement; } return base.VisitParameter(p); } } }