zoukankan      html  css  js  c++  java
  • 使用Expression动态创建lambda表达式

    一、前言

      根据前端传来的数据条件进行字段过滤时,如果使用判断字段名再手写lambda的方式,在条件多的情况下会非常繁琐。所以寻找可以动态创建lamada的方式,直接根据传来的字段进行过过滤,后端不用关心传来的是啥字段,实现前后端解耦。

    二、代码

    using System;
    using System.Collections.Generic;
    using System.Linq.Expressions;
    using System.Reflection;
    using System.Text;
    
    namespace Do.Common.Helper
    {
        public class LambdaHelper
        {
            /// <summary>
            /// 创建lambda表达式:p=>true
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <returns></returns>
            public static Expression<Func<T, bool>> True<T>()
            {
                return p => true;
            }
    
            /// <summary>
            /// 创建lambda表达式:p=>false
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <returns></returns>
            public static Expression<Func<T, bool>> False<T>()
            {
                return p => false;
            }
    
            /// <summary>
            /// 创建lambda表达式:p=>p.propertyName
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <typeparam name="TKey"></typeparam>
            /// <param name="sort"></param>
            /// <returns></returns>
            public static Expression<Func<T, TKey>> GetOrderExpression<T, TKey>(string propertyName)
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "p");
                return Expression.Lambda<Func<T, TKey>>(Expression.Property(parameter, propertyName), parameter);
            }
    
            /// <summary>
            /// 创建lambda表达式:p=>p.propertyName == propertyValue
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="column"></param>
            /// <param name="value"></param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> CreateEqual<T>(string propertyName, string propertyValue)
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "p");//创建参数p
                MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
                ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
                return Expression.Lambda<Func<T, bool>>(Expression.Equal(member, constant), parameter);
            }
    
            /// <summary>
            /// 创建lambda表达式:p=>p.propertyName != propertyValue
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="propertyName"></param>
            /// <param name="propertyValue"></param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> CreateNotEqual<T>(string propertyName, string propertyValue)
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "p");//创建参数p
                MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
                ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
                return Expression.Lambda<Func<T, bool>>(Expression.NotEqual(member, constant), parameter);
            }
    
            /// <summary>
            /// 创建lambda表达式:p=>p.propertyName > propertyValue
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="column"></param>
            /// <param name="value"></param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> CreateGreaterThan<T>(string propertyName, string propertyValue)
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "p");//创建参数p
                MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
                ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
                return Expression.Lambda<Func<T, bool>>(Expression.GreaterThan(member, constant), parameter);
            }
    
            /// <summary>
            /// 创建lambda表达式:p=>p.propertyName < propertyValue
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="column"></param>
            /// <param name="value"></param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> CreateLessThan<T>(string propertyName, string propertyValue)
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "p");//创建参数p
                MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
                ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
                return Expression.Lambda<Func<T, bool>>(Expression.LessThan(member, constant), parameter);
            }
    
            /// <summary>
            /// 创建lambda表达式:p=>p.propertyName >= propertyValue
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="column"></param>
            /// <param name="value"></param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> CreateGreaterThanOrEqual<T>(string propertyName, string propertyValue)
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "p");//创建参数p
                MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
                ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
                return Expression.Lambda<Func<T, bool>>(Expression.GreaterThanOrEqual(member, constant), parameter);
            }
    
            /// <summary>
            /// 创建lambda表达式:p=>p.propertyName <= propertyValue
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="column"></param>
            /// <param name="value"></param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> CreateLessThanOrEqual<T>(string propertyName, string propertyValue)
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "p");//创建参数p
                MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
                ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
                return Expression.Lambda<Func<T, bool>>(Expression.LessThanOrEqual(member, constant), parameter);
            }
    
            /// <summary>
            /// 创建lambda表达式:p=>p.propertyName.Contains(propertyValue)
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="column"></param>
            /// <param name="value"></param>
            /// <returns></returns>
            private static Expression<Func<T, bool>> GetContains<T>(string propertyName, string propertyValue)
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "p");
                MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
                MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
                ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
                return Expression.Lambda<Func<T, bool>>(Expression.Call(member, method, constant), parameter);
            }
    
            /// <summary>
            /// 创建lambda表达式:!(p=>p.propertyName.Contains(propertyValue))
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="column"></param>
            /// <param name="value"></param>
            /// <returns></returns>
            private static Expression<Func<T, bool>> GetNotContains<T>(string propertyName, string propertyValue)
            {
                ParameterExpression parameter = Expression.Parameter(typeof(T), "p");
                MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
                MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
                ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
                return Expression.Lambda<Func<T, bool>>(Expression.Not(Expression.Call(member, method, constant)), parameter);
            }
        }
    }

    转载请注明出处,原文链接:
    https://blog.csdn.net/yl2isoft/article/details/53196092

  • 相关阅读:
    模板jinja2常用方法
    简单实用的日志类CLog (Python版)
    Databus架构分析与初步实践
    AWS API 2.0签名规范
    django学习——通过get_FOO_display 查找模型中的choice值
    Twitter如何在数千台服务器上快速部署代码?
    mysql 添加索引 mysql 如何创建索引
    sql中的like和正则的区别
    python2.7运行出现的Warning: UnicodeWarning: Unicode equal comparison failed to convert both arguments to Unicode
    Python命令模块argparse学习笔记(四)
  • 原文地址:https://www.cnblogs.com/gaozejie/p/12652228.html
Copyright © 2011-2022 走看看