Expression＜Func＜T, bool＞＞ 扩展方法的使用方法

最新推荐文章于 2023-04-09 11:20:30 发布
最新推荐文章于 2023-04-09 11:20:30 发布
阅读量1.8k 收藏 2
点赞数
文章标签： c# linq 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang8593/article/details/125586360
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Linq.Expressions;

namespace ZhaoXi.ASP.NET.MVC5.AuthorityProject.Models
{

    namespace Core.Util
    {

        //用法
         // var predicate = PredicateBuilder.GetTrue<Student>();
         //predicate = predicate.And(it => it.id.ToString().Contains(strID));
         //predicate = predicate.And(it => it.Birthday.ToString().Contains(strBir));
         //predicate = predicate.And(it => it.Sex.ToString().Contains(strSex));
         //predicate = predicate.And(it => it.Age == 20);
         //var lst = db.Queryable<Student>.Where(predicate).ToList();
        /// 
        /// 
        /// </summary>
        public static partial class Extention
        {
            #region 拓展AndIf与AndOr

            /// <summary>
            /// 符合条件则And
            /// </summary>
            /// <typeparam name="T">实体类型</typeparam>
            /// <param name="left">原表达式</param>
            /// <param name="need">是否符合条件</param>
            /// <param name="right">新表达式</param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> AndIf<T>(this Expression<Func<T, bool>> left, bool need, Expression<Func<T, bool>> right)
            {
                if (need)
                {
                    // return left.And(right);
                    return left;
                }
                else
                {
                    return left;
                }
            }

            public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
            {
                return 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)
            {
                return 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)
                {
                    _oldValue = oldValue;
                    _newValue = newValue;
                }

                public override Expression Visit(Expression node)
                {
                    if (node == _oldValue)
                        return _newValue;
                    return base.Visit(node);
                }
            }

            /// <summary>
            /// 符合条件则Or
            /// </summary>
            /// <typeparam name="T">实体类型</typeparam>
            /// <param name="left">原表达式</param>
            /// <param name="need">是否符合条件</param>
            /// <param name="right">新表达式</param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> OrIf<T>(this Expression<Func<T, bool>> left, bool need, Expression<Func<T, bool>> right)
            {
                if (need)
                {
                    // return left.Or(right);
                    return left;
                }
                else
                {
                    return left;
                }
            }

            #endregion

            #region 拓展BuildExtendSelectExpre方法

            /// <summary>
            /// 组合继承属性选择表达式树,无拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, TResult>> BuildExtendSelectExpre<TBase, TResult>(this Expression<Func<TBase, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,1个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, TResult>> BuildExtendSelectExpre<TBase, T1, TResult>(this Expression<Func<TBase, T1, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,2个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, TResult>> BuildExtendSelectExpre<TBase, T1, T2, TResult>(this Expression<Func<TBase, T1, T2, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,3个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, TResult>(this Expression<Func<TBase, T1, T2, T3, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,4个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,5个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,6个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="T6">拓展类型6</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, T6, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, T6, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, T6, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, T6, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,7个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="T6">拓展类型6</typeparam>
            /// <typeparam name="T7">拓展类型7</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, T6, T7, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, T6, T7, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,8个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="T6">拓展类型6</typeparam>
            /// <typeparam name="T7">拓展类型7</typeparam>
            /// <typeparam name="T8">拓展类型8</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, TResult>>(expression);
            }

            /// <summary>
            /// 组合继承属性选择表达式树,9个拓展参数
            /// TResult将继承TBase的所有属性
            /// </summary>
            /// <typeparam name="TBase">原数据类型</typeparam>
            /// <typeparam name="T1">拓展类型1</typeparam>
            /// <typeparam name="T2">拓展类型2</typeparam>
            /// <typeparam name="T3">拓展类型3</typeparam>
            /// <typeparam name="T4">拓展类型4</typeparam>
            /// <typeparam name="T5">拓展类型5</typeparam>
            /// <typeparam name="T6">拓展类型6</typeparam>
            /// <typeparam name="T7">拓展类型7</typeparam>
            /// <typeparam name="T8">拓展类型8</typeparam>
            /// <typeparam name="T9">拓展类型9</typeparam>
            /// <typeparam name="TResult">返回类型</typeparam>
            /// <param name="expression">拓展表达式</param>
            /// <returns></returns>
            public static Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> BuildExtendSelectExpre<TBase, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(this Expression<Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
            {
                return GetExtendSelectExpre<TBase, TResult, Func<TBase, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>>(expression);
            }

            #endregion

            #region 私有成员

            private static Expression<TDelegate> GetExtendSelectExpre<TBase, TResult, TDelegate>(Expression<TDelegate> expression)
            {
                NewExpression newBody = Expression.New(typeof(TResult));
                MemberInitExpression oldExpression = (MemberInitExpression)expression.Body;

                ParameterExpression[] oldParamters = expression.Parameters.ToArray();
                List<string> existsProperties = new List<string>();
                oldExpression.Bindings.ToList().ForEach(aBinding =>
                {
                    existsProperties.Add(aBinding.Member.Name);
                });

                List<MemberBinding> newBindings = new List<MemberBinding>();
                typeof(TBase).GetProperties().Where(x => !existsProperties.Contains(x.Name)).ToList().ForEach(aProperty =>
                {
                    if (typeof(TResult).GetMembers().Any(x => x.Name == aProperty.Name))
                    {
                        MemberBinding newMemberBinding = null;
                        var valueExpre = Expression.Property(oldParamters[0], aProperty.Name);
                        if (typeof(TBase).IsAssignableFrom(typeof(TResult)))
                        {
                            newMemberBinding = Expression.Bind(aProperty, valueExpre);
                        }
                        else
                        {
                            newMemberBinding = Expression.Bind(typeof(TResult).GetProperty(aProperty.Name), valueExpre);
                        }
                        newBindings.Add(newMemberBinding);
                    }
                });

                newBindings.AddRange(oldExpression.Bindings);

                var body = Expression.MemberInit(newBody, newBindings.ToArray());
                var resExpression = Expression.Lambda<TDelegate>(body, oldParamters);

                return resExpression;
            }

            #endregion
        }

        /// <summary>
        /// 继承ExpressionVisitor类，实现参数替换统一
        /// </summary>
        internal class ParameterReplaceVisitor : System.Linq.Expressions.ExpressionVisitor
        {
            public ParameterReplaceVisitor(ParameterExpression paramExpr)
            {
                _parameter = paramExpr;
            }

            //新的表达式参数
            private readonly ParameterExpression _parameter;

            protected override Expression VisitParameter(ParameterExpression p)
            {
                if (p.Type == _parameter.Type)
                {
                    return _parameter;
                }

                else
                {
                    return p;
                }
            }
        }
    }

}

xisghiu
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Expression表达式转换为SQL语句，支持SqlServer、MySql、Oracle、Sqlite、PostgreSql
06-03
.NET Standard 2.1、.NET 5、.NET 6、.NET 7 版本SQLBuilder，Expression表达式转换为SQL语句，支持SqlServer、MySql、Oracle、Sqlite、PostgreSql；基于Dapper实现了不同数据库对应的数据仓储Repository；
C#中Predicate<T>与Func<T, bool>泛型委托的用法实例
09-04
为了解决这个问题，我们可以编写一个扩展方法，将`Func<T, bool>`转换为`Predicate<T>`，如示例中的`ToPredicate<T>`方法所示。这个扩展方法创建了一个新的`Predicate<T>`实例，其内部调用了原始的`Func<T, bool>`。...
动态拼接Expression＜Func＜T, bool＞＞ lambda表达式
我是阿兰的博客
08-19 761
【代码】动态拼接Expression lambda表达式。
拉姆达表达式 追加 条件判断 Expression<Func<T, bool>>
weixin_33948416的博客
07-16 712
2019独角兽企业重金招聘Python工程师标准>>> ...
.NET Core中Expression＜Func＜T,bool＞＞简洁明了
刘毅鹏的博客
08-19 2065
文章目录一、Func 委托用法及作用是什么？1.语法2.类型参数3.返回值二、示例一 一、Func 委托用法及作用是什么？ 1.语法 //delegate 委托 public delegate TResult Func<out TResult>(); 封装一个方法，该方法不具有参数，且返回由 TResult 参数指定的类型的值。 2.类型参数 TResult 此委托封装的方法的返回值类型。 3.返回值 此委托封装的方法的返回值。 二、示例一 创建一个控制台程序；声明两个不同返回值
Expression<Func<T, bool>>拼接查询条件
热门推荐
sunho89的专栏
03-11 2万+
由于项目中经常要用到类似db.students.where多条件查询，因此需要拼接查询条件。 网上搜索大部分出自 Dynamically Composing Expression Predicates  code如下 using System; using System.Linq; using System.Linq.Expressions; using System.Collections
C#条件拼接Expression＜Func＜T, bool＞＞
风，停了
04-22 4581
使用代码 特别注意 拼接条件时，所使用到的条件strID，strBir必须是独立的 var predicate = PredicateBuilder.GetTrue<Student>(); predicate = predicate.And(it => it.id.ToString().Contains(strID)); predicate = predicate.And(it => it.Birthday.ToString().Contains(strBir)); predicat
Func<T, bool>与Expression<Func<T, bool>>的区别
weixin_30835933的博客
11-11 632
Func<T, bool>与Expression<Func<T, bool>>的区别 Func<T, bool>是委托(delegate) Expression<Func<T, bool>>是表达式 Expression编译后就会变成delegate，才能运行。比如 Expression<Func<int,...
Expression<Func<T, bool>>
Robert_cao1995的博客
06-16 405
public static Expression<Func<T, bool>> True<T>() { return f => true; } public static Expression<Func<T, bool>> False<T>() { return f => false; } /// &...
提交表单时执行func方法实现代码
12-01
charset=utf-8″%> <!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”> <html xmlns=”http://www.w3.org/1999/xhtml”> ...
C#3.0中Lambda表达式详解
09-05
Func<string, string> convert = s => s.ToUpper(); string name = "Dakota"; outputBlock.Text += convert(name) + "\n"; } ``` Lambda表达式的这种简洁性使得它成为 LINQ（Language Integrated Query）查询的...
Expression表达式目录树
段丛磊
03-17 664
一、初识Expression 1、在上一篇我们讲到了委托（忘记了可以在看看，点赞在看养成习惯），今天要讲的Expression也和委托有一点点关系吧（没有直接关系，只是想要大家看看我其他的文章），Expression是.NET准备为Linq to Sql准备的，它的命名空间是System.Linq.Expressions 2、不知道大家有没有用户ORM(对象映射实体...
Expression与Func学习
tide的博客
01-19 1038
Expression用于实现动态的查询语句 int[] intlist = { 1, 3, 5, 7, 9 };             List result = new List();             Expression> me = a => a.ToString();             //MessageBox.Show(me.Compile()(66));
Expression 《Func《T》 bool》》 组合两个表达式
junjie008的专栏
12-04 681
Expression<Func<T bool>> 组合两个表达式 合并成一个。 先写下参考文档网址吧：http://www.albahari.com/nutshell/predicatebuilder.aspx 这里主要使用 PredicateBuilder 中的方法，具体见上面参考文档网址。 关于 表达式的理解：参考此文档https://www.cnblo...
有关Entity Framework的数据模型的操作
风雨无阻学习之路
11-10 1254
初次学习EF的时候，在网上收集了不少资料，但很少有对EF系统的介绍和例子，比如如何通过EF对实体模型进行AMD.这使得我不得不自己去研究和实验，通过反复的测试，总算摸索了一些方法，今天把代码粘贴出来以供大家指点和批评。 public interface IOperate     {         #region 属性         ///         ///     获取 当前
关于Expression<Func<T,bool>>表达式目录树的形式的强类型 lambda 表达式的拼接
weixin_30617797的博客
08-23 753
当前在封装类EF的Where条件的表达式的解析逻辑，遇到的问题是：运用过程中可能需要将复杂的条件在不同的处理逻辑中Expression表达式进行拼接。 针对于遇到的问题写了示例进行记录，主要为了能够将Lambda表达式转为可执行的SQL语句，例子如下： （相关的Lambda表达式转为SQL语句的整理待有空的时候再整理，这边先记录一下表达式的拼接） // ...
sql-DbContext
ultramand的博客
04-09 790
DbContext 是 Entity Framework Core 中的一个类，用于定义数据库上下文。
C# 动态Expression
foreverhot1019的博客
01-19 1950
///         /// 扩展IQueryable方法        /// 可以直接.出来        ///         ///         ///         ///         ///         public static IQueryable GetTop(this IQueryable source,            Expression> Orde
Expression<Func<T, bool>>.or
最新发布
05-18
在C#中，可以使用`Expression<Func<T, bool>>`来表示一个lambda表达式，其中`T`是要操作的类型。如果要将两个lambda表达式合并为一个逻辑或条件，可以使用`Expression.Or`方法。 例如，考虑以下两个lambda表达式： ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值