关于C#动态表达式树扩展的一些应用和处理办法（本文主要解决高级搜索/自定义搜索等相关问题）

已于 2023-08-31 16:15:21 修改
阅读量306 收藏 1
点赞数 1
分类专栏： .Net Core 文章标签： linq c#
于 2023-01-05 10:40:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peixiaofei0721/article/details/125335230
版权

为了更好的处理高级搜索功能，可以根据用户自定义搜索条件执行动态表达式，以下是动态表达式扩展的核心代码，请铁子们验收，下边还总结了重要的核心知识点，各位可以点击进行阅读学习。

核心知识点：Expression、反射

//自定义对象
public class AdvanceSearchInput
    {
        public enum SqlOperator
        {
            Contains,
            NotContains,
            Equal,
            NotEqual,
            Greater,
            GreaterEqual,
            Less,
            LessEqual,
            InSetOf,
            NotInSetOf
        }

        public string FieldName
        {
            get;
            set;
        }

        public string FieldValue
        {
            get;
            set;
        }

        public SqlOperator Operator
        {
            get;
            set;
        }

        public bool AndAlso
        {
            get;
            set;
        }
    }
//核心代码扩展
public static class ExpressionExtension
    {
        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second) => first.AndAlso<T>(second, Expression.AndAlso);
        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second) => first.AndAlso<T>(second, Expression.OrElse);
        private static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2, Func<Expression, Expression, BinaryExpression> func)
        {
            var parameter = Expression.Parameter(typeof(T));
            var leftVisitor = new ReplaceExpressionVisitor(expr1.Parameters[0], parameter);
            var left = leftVisitor.Visit(expr1.Body);
            var rightVisitor = new ReplaceExpressionVisitor(expr2.Parameters[0], parameter);
            var right = rightVisitor.Visit(expr2.Body);
            return Expression.Lambda<Func<T, bool>>(func(left, right), parameter);
        }
        private class ReplaceExpressionVisitor : ExpressionVisitor
        {
            private readonly Expression oldValue;
            private readonly Expression newValue;

            public ReplaceExpressionVisitor(Expression oldValue, Expression newValue)
            {
                this.oldValue = oldValue;
                this.newValue = newValue;
            }
            public override Expression Visit(Expression node)
            {
                if (node == this.oldValue)
                {
                    return this.newValue;
                }
                return base.Visit(node);
            }
        }
    }
    public class ExpressionVisitorExtensions : Collection<AdvanceSearchInput>
    {
        public Expression<Func<T, bool>> AsExpression<T>() where T : class
        {
            var type = typeof(T);
            var typeInfo = type.GetTypeInfo();
            var parameter = Expression.Parameter(type, "m");
            Expression expression = null;
            static Expression func(bool andAlso, Expression exp1, Expression exp2)
            {
                if (exp1 == null)
                {
                    return exp2;
                }
                return andAlso ? Expression.AndAlso(exp1, exp2) : Expression.OrElse(exp1, exp2);
            }
            foreach (var item in this)
            {
                var property = typeInfo.GetProperty(item.FieldName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
                if (property == null || !property.CanRead || string.IsNullOrWhiteSpace(item.FieldValue))
                {
                    continue;
                }
                var valueType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
                Expression<Func<object>> valueLambda = () => GetValue(item.FieldValue, valueType);

                switch (item.Operator)
                {
                    case AdvanceSearchInput.SqlOperator.Equal:
 if (valueType == typeof(string))
                        {
                            var nameToLower = Expression.Call(Expression.Property(parameter, item.FieldName), typeof(String).GetMethod("ToLower", new Type[] { }));
                            var valueToLower = Expression.Call(Expression.Convert(valueLambda.Body, property.PropertyType), typeof(String).GetMethod("ToLower", new Type[] { }));
                            expression = func(item.AndAlso, expression, Expression.Call(nameToLower, "Equal", null, valueToLower));
                        }
                        else
                        {
                            expression = func(item.AndAlso, expression, Expression.Equal(Expression.Property(parameter, item.FieldName), valueType.IsEnum ? Expression.Constant(Enum.Parse(valueType, item.FieldValue)) : Expression.Convert(valueLambda.Body, property.PropertyType)));
                        }
                        break;
                    case AdvanceSearchInput.SqlOperator.NotEqual:
 
                        if (valueType == typeof(string))
                        {
                            var nameToLower = Expression.Call(Expression.Property(parameter, item.FieldName), typeof(String).GetMethod("ToLower", new Type[] { }));
                            var valueToLower = Expression.Call(Expression.Convert(valueLambda.Body, property.PropertyType), typeof(String).GetMethod("ToLower", new Type[] { }));
                            expression = func(item.AndAlso, expression, Expression.Call(nameToLower, "NotEqual", null, valueToLower));
                        }
                        else
                        {
                            expression = func(item.AndAlso, expression, Expression.NotEqual(Expression.Property(parameter, item.FieldName), Expression.Convert(valueLambda.Body, property.PropertyType)));
                        }
                        break;
                    case AdvanceSearchInput.SqlOperator.Contains:
                         var nullCheck = Expression.Not(Expression.Call(typeof(string), "IsNullOrEmpty", null, Expression.Property(parameter, item.FieldName)));
                            var afterToLower = Expression.Call(Expression.Property(parameter, item.FieldName), typeof(String).GetMethod("ToLower", new Type[] { }));
                            var beforeToLower = Expression.Call(Expression.Convert(valueLambda.Body, property.PropertyType), typeof(String).GetMethod("ToLower", new Type[] { }));//ToUpper
                            var contains = Expression.Call(afterToLower, "Contains", null, beforeToLower);
                            expression = func(item.AndAlso, expression, Expression.AndAlso(nullCheck, contains));
                        break;
                    case AdvanceSearchInput.SqlOperator.NotContains:
                        var nullCheck_n = Expression.Not(Expression.Call(typeof(string), "IsNullOrEmpty", null, Expression.Property(parameter, item.FieldName)));
                            var fieldNameToLower = Expression.Call(Expression.Property(parameter, item.FieldName), typeof(String).GetMethod("ToLower", new Type[] { }));
                            var fieldValueToLower = Expression.Call(Expression.Convert(valueLambda.Body, property.PropertyType), typeof(String).GetMethod("ToLower", new Type[] { }));//ToUpper
                            var contains_n = Expression.Call(fieldNameToLower, "Contains", null, fieldValueToLower);
                            expression = func(item.AndAlso, expression, Expression.Not(Expression.AndAlso(nullCheck_n, contains_n)));
                        break;
                    case AdvanceSearchInput.SqlOperator.Greater:
                        expression = func(item.AndAlso, expression, Expression.GreaterThan(Expression.Property(parameter, item.FieldName), Expression.Convert(valueLambda.Body, property.PropertyType)));
                        break;
                    case AdvanceSearchInput.SqlOperator.GreaterEqual:
                        expression = func(item.AndAlso, expression, Expression.GreaterThanOrEqual(Expression.Property(parameter, item.FieldName), Expression.Convert(valueLambda.Body, property.PropertyType)));
                        break;
                    case AdvanceSearchInput.SqlOperator.Less:
                        expression = func(item.AndAlso, expression, Expression.LessThan(Expression.Property(parameter, item.FieldName), Expression.Convert(valueLambda.Body, property.PropertyType)));
                        break;
                    case AdvanceSearchInput.SqlOperator.LessEqual:
                        expression = func(item.AndAlso, expression, Expression.LessThanOrEqual(Expression.Property(parameter, item.FieldName), Expression.Convert(valueLambda.Body, property.PropertyType)));
                        break;
                    case AdvanceSearchInput.SqlOperator.InSetOf:
                         Expression leftExpression = null;
                        if (valueType.IsEnum)
                        {
                            var values = item.FieldValue.Split(",").Select(s => (int)Enum.Parse(valueType, s)).ToList();
                            leftExpression = Expression.Constant(values, values.GetType());
                            expression = func(item.AndAlso, expression, Expression.Call(leftExpression, "Contains", null, Expression.Convert(Expression.Property(parameter, item.FieldName), typeof(int))));
                        }
                        else
                        {
                            if (valueType == typeof(int))
                            {
                                List<int> values = item.FieldValue.Split(",").Select(s => Convert.ToInt32(s)).ToList();
                                leftExpression = Expression.Constant(values, values.GetType());
                            }
                            else if (valueType == typeof(string))
                            {
                                List<string> values = item.FieldValue.Split(",").ToList<String>();
                                leftExpression = Expression.Constant(values, values.GetType());
                            }
                            else if (valueType == typeof(long))
                            {
                                List<long> values = item.FieldValue.Split(",").Select(s => Convert.ToInt64(s)).ToList();
                                leftExpression = Expression.Constant(values, values.GetType());
                            }
                            else if (valueType == typeof(float) || valueType == typeof(double))
                            {
                                List<double> values = item.FieldValue.Split(",").Select(s => Convert.ToDouble(s)).ToList();
                                leftExpression = Expression.Constant(values, values.GetType());
                            }
                            if(leftExpression != null)
                                expression = func(item.AndAlso, expression, Expression.Call(leftExpression, "Contains", null, Expression.Property(parameter, item.FieldName)));
                        }
                        break;
                    case AdvanceSearchInput.SqlOperator.NotInSetOf:
                        Expression leftExpressionNo = null;
                        if (valueType.IsEnum)
                        {
                            var values = item.FieldValue.Split(",").Select(s => (int)Enum.Parse(valueType, s)).ToList();
                            leftExpressionNo = Expression.Constant(values, values.GetType());
                            expression = func(item.AndAlso, expression, Expression.Not(Expression.Call(leftExpressionNo, "Contains", null, Expression.Convert(Expression.Property(parameter, item.FieldName), typeof(int)))));
                        }
                        else
                        {
                            if (valueType == typeof(int))
                            {
                                List<int> values = item.FieldValue.Split(",").Select(s => Convert.ToInt32(s)).ToList();
                                leftExpressionNo = Expression.Constant(values, values.GetType());
                            }
                            else if (valueType == typeof(string))
                            {
                                List<string> values = item.FieldValue.Split(",").ToList<String>();
                                leftExpressionNo = Expression.Constant(values, values.GetType());
                            }
                            else if (valueType == typeof(long))
                            {
                                List<long> values = item.FieldValue.Split(",").Select(s => Convert.ToInt64(s)).ToList();
                                leftExpressionNo = Expression.Constant(values, values.GetType());
                            }
                            else if (valueType == typeof(float) || valueType == typeof(double))
                            {
                                List<double> values = item.FieldValue.Split(",").Select(s => Convert.ToDouble(s)).ToList();
                                leftExpressionNo = Expression.Constant(values, values.GetType());
                            }
                            if (leftExpressionNo != null)
                                expression = func(item.AndAlso, expression, Expression.Not(Expression.Call(leftExpressionNo, "Contains", null, Expression.Property(parameter, item.FieldName))));
                        }
                        break;
                }
            }
            if (expression == null)
            {
                Expression<Func<T, bool>> defaultExpression = x => true;
                return defaultExpression;
            }
            return (Expression<Func<T, bool>>)Expression.Lambda(expression, parameter);
        }
    }

    private object GetValue(string value, Type type)
    {
        if (type == typeof(bool))
        {
            bool boolValue;
            if (bool.TryParse(value, out boolValue))
                return boolValue;
            else
            {
                int intValue;
                if (int.TryParse(value, out intValue))
                    return Convert.ChangeType(intValue, type);
                else
                    return null;
            }
        }
        else
        {
            return System.Convert.ChangeType(value, type);
        }
    }

 //使用案例
 ExpressionVisitorExtensions advanceSearchInputs = new ExpressionVisitorExtensions();
                foreach (var item in listCondition.AdvanceConditions)
                {
                    advanceSearchInputs.Add(item);
                }
                var reply = this.DBContext.T.Where(advanceSearchInputs.AsExpression<T>())

丶羊先生丶
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#动态执行字符串，可以将字符串作为表达式执行
08-17
可以动态解析并执行字符串 参见http://blog.csdn.net/hsrzq/archive/2009/08/17/4456361.aspx 别忘了引用EvalGuy命名空间！
c# 动态表达式
eidolon's blog
05-25 933
利用ExpressionEvaluator，实现简单表达式，带变量的表达式的结果计算。
.NET Framework 3.5 版中的新增功能（2）[整理]
weixin_34194359的博客
04-08 249
转自：Johnson(大可山)的Blog 续前：.NET Framework 3.5 中的功能简介(1)   上文做了简要介绍，下面根据MSDN上的具体描述，作了资料整理： .NET Framework 3.5 版中的新增功能体现在以下诸多方面： - .NET Compact Framework - ASP.NET - 外接程序和扩展性（AddIn） - 公共语言运行库 ...
C# 中的执行表达式树（Expression Tree）
最新发布
qq_35320456的博客
02-28 1231
C# 中的执行表达式树（Expression Tree）
LINQ体验(3)——C# 3.0新语言特性和改进(下篇) 【转】
weixin_34292402的博客
01-14 97
C# 3.0新语言特性和改进包括： 自动属性(Auto-Implemented Properties) 隐含类型局部变量(Local Variable Type Inference) 匿名类型(Anonymous Types) 对象与集合初始化器(Object and Collection Initializers) 扩展方法(Extensio...
关于Expression扩展ExpressionExtension的用法
ID_Dexter的博客
10-14 639
定义lambda表达式树形结构 Expression<Func<T, bool>> lambda = t => true; 定义查询条件 StartTime =2017/10/13 0:00:00 添加查询条件 lambda = lambda.And(t => t.StartTime >StartTime); 对查询条件重新复制 Star...
C# Lambda表达式和表达式树
极客神殿
08-31 517
当方法的参数是委托类型时，lambda表达式可以作为参数传递，而实际上编译器会生成一个方法，然后用该方法创建一个委托实例作为参数。在进程外LINQ提供者的核心是，你可以从熟悉的语言（这里指C#）产生一个表达式树，将其结果作为一个中间格式，然后被转换为特定平台的本地语言。虽然我们可能永远也不会像这样来使用表达式树，甚至也不会以编程的方式来构造表达式树，但是这些底层的信息能帮我们更好的理解LINQ是如何工运作的。通过组合lambda表达式，可以提供表达式树的编译时检查，由此从期望的逻辑中抽象出执行模型。...
C# 动态构建表达式(Expression)
xk_hypothesis的博客
10-11 437
问题来源：前端文本输入框以分隔符(比如"aa|bb|cc")传进来的字符串，针对一个字段做的查询条件；由于该字符串分隔符数量不确定，因此需要动态构建出来；旨在实现例如以下效果：以下是后端代码的相关实现。
c# 生成表达式树 - 动态表达式帮助类
刘联其的个人分享
11-14 309
// 生成表达式树。/// 动态表达式帮助类。
C#构造Expression表达式调用字符串Contains
网络大杂烩
04-22 1822
如果你是一个C#开发人员，学会用Expression，会对编写一些功能带来一些好处，例如我们在开发一个分页功能时，会拥有很多的查询条件，对于新手来说这些查询条件的代码他们可能会通过拼接 sql的where条件方式来处理，当你学会用表达式，这将是非常简单的一个功能。 这个贴子中的示例代码，是来源于我在基于 asp.net 实现服务器端对提交的表单数据自动进行合法性验证时提取出的代码，因为其中有一个功能就是根据表单控件添加的自定义属性进行”>”, “<“, “=”, “>=”, “<=
Expression＜Func＜T, bool＞＞ 扩展方法的使用方法
07-03 1845
Expression 扩展方法的使用方法
【翻译】C#表达式中的动态查询
biyusr的专栏
07-19 346
当您使用LINQ来处理数据库时，这种体验是一种神奇的体验，对吗？你把数据库实体像一个普通的收集，使用Linq中像Where，Select或者Take，这些简单的使用就能让代码可用了。但是，让我们考虑一下这里是如何通过动态查询和表达式树实现此功能的幕后发生的事情。您编写的LINQ查询将转换为SQL（或其他方式），并将该SQL查询发送到数据库。然后将数据库的响应映射到C＃对象。但是，如何完全转换为SQL？...
C#实现的表达式解析与计算动态库TExprParser.dll（V1.5）
07-19
一组C#实现的算术、关系、逻辑与函数等的表达式解析与计算类TExprParser（V1.5）及测试exe程序，可以使用{n}占位符参数等，并提供详细的错误解析提示。具体使用参考http://blog.csdn.net/hulihui。测试程序需要.net 3.5环境。
RecordParser:基于简单表达式树的解析器，专注于高性能，可扩展性和简单用法
03-21
RecordParser-简单，快速，可扩展的记录解析RecordParser是基于表达式树的解析器，可帮助您编写可维护，快速且简单的解析器。通过自动化不相关的代码，开发人员可以更轻松地进行解析，从而使开发人员可以专注于映射...
QueryInterceptor:提供了一种使用自定义表达式访问者来拦截IQueryable表达式树的通用方法
05-09
问题 通常，当您尝试修改表达式树时，您需要编写一个表达式访问者。 尝试将表达式访问者插入IQuerable的表达式树时，需要编写一个linq提供程序（yikes）。 基于实现 解决方案 QueryInterceptor在IQueryable...
C#实现表达式树Expression的与、或、非运算
DHZYKN
10-10 1272
以下使用扩展方式实现 /// <summary> /// 表达式树运算 扩展方法 /// </summary> public static class ExpressionExtension { /// <summary> /// 并 expr1 AND expr2 //...
c# 委托 表达式树
07-27
使用委托和表达式树，我们可以创建动态的委托实例，并将其用作回调函数或事件处理程序。这使得我们能够在运行时动态地决定要调用的方法。 如果你有更具体的问题或示例代码，我可以为你提供更详细的解答。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值