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

最新推荐文章于 2025-03-20 10:18:55 发布
最新推荐文章于 2025-03-20 10:18:55 发布
阅读量2.1k 收藏 2
点赞数 1
文章标签： c# linq 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/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;
                }
            }
        }
    }

}

zhangyuli1
关注
Automapper 系列之Expression（一）
飞上云层
09-24 383
Expression 文章目录Expression一、安装扩展包二、表达式目录树转换方法一三、表达式目录树转换方法二 一、安装扩展包 如果需要进行表达式目录树从一个对象转换为其他对象，需要安装另外的独立的包。 使用Package Manager安装 Install-Package AutoMapper.Extensions.ExpressionMapping -Version 4.1.2 使用NuGet安装 搜索AutoMapper.Extensions.ExpressionMapping安装最新
利用EFCore 封装Repository（可扩展不同数据的sql操作）
weixin_33875564的博客
04-30 5595
本篇是对EFCore进行下封装并实现基本的增删改查的同步异步方法及针对不同数据库的批量插入、sql语句直接操作数据库； 一、 先定义基础仓储接口IRepository public interface IRepository<TEntity,TKey> where TEntity : class { ...
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
Expression<Func<T, bool>>与Func<T, bool>的区别
天天写代码⎝⏠⏝⏠⎠
08-12 1万+
转自：http://www.cnblogs.com/wow-xc/articles/4952233.html Func是委托(delegate) Expression>是表达式 Expression编译后就会变成delegate，才能运行。比如 Expression> ex = x=>x Func func = ex.Compile(); 
C# 中的 Func 委托详解
最新发布
lijunhe1991的博客
03-20 496
1.Func的定义与基础用法Func​输入参数表示方法的输入参数类型（最多 16 个）。​返回值TResult表示方法的返回值类型。示例// 定义一个接受两个整数参数并返回字符串的 Func// 返回 "8"应用场景​动态调用方法：将方法作为参数传递，例如在算法中注入自定义逻辑。​LINQ 查询：LINQ 的SelectWhere等方法依赖Func实现数据转换和过滤。
Expression<Func<T, bool>>
Robert_cao1995的博客
06-16 470
public static Expression<Func<T, bool>> True<T>() { return f => true; } public static Expression<Func<T, bool>> False<T>() { return f => false; } /// &...
.NET Core中Expression＜Func＜T,bool＞＞简洁明了
刘毅鹏的博客
08-19 2366
文章目录一、Func 委托用法及作用是什么？1.语法2.类型参数3.返回值二、示例一 一、Func 委托用法及作用是什么？ 1.语法 //delegate 委托 public delegate TResult Func<out TResult>(); 封装一个方法，该方法不具有参数，且返回由 TResult 参数指定的类型的值。 2.类型参数 TResult 此委托封装的方法的返回值类型。 3.返回值 此委托封装的方法的返回值。 二、示例一 创建一个控制台程序；声明两个不同返回值
关于Expression<Func<T,bool>>表达式目录树的形式的强类型 lambda 表达式的拼接
weixin_30617797的博客
08-23 825
当前在封装类EF的Where条件的表达式的解析逻辑，遇到的问题是：运用过程中可能需要将复杂的条件在不同的处理逻辑中Expression表达式进行拼接。 针对于遇到的问题写了示例进行记录，主要为了能够将Lambda表达式转为可执行的SQL语句，例子如下： （相关的Lambda表达式转为SQL语句的整理待有空的时候再整理，这边先记录一下表达式的拼接） // ...
如何完成数据库复杂查询的动态构建？
厦门在乎科技
11-11 1161
有的时候，你需要动态构建一个比较复杂的查询条件，传入数据库中进行查询。而条件本身可能来自前端请求或者配置文件。那么这个时候，表达式树，就可以帮助到你。 Where当中可以传入固定的条件 以下是一个简单的单元测试用例。接下来，我们将这个测试用例改的面目全非。 [Test] public void Normal() { var re = Enumerable.Range(0, 10).AsQueryable() // 0-9 .Where(x => x >= 1 &a
.NetCore 使用 Linq 动态拼接Expression表达式条件来实现 对EF、EF Core 扩展查询排序操作...
weixin_30363509的博客
08-01 3328
相信在使用EF的时候对查询条件或者排序上的处理令人心烦，下面我们就来动态拼接表达式解决这一问题 当我们在查询中使用Where的时候可以看到如下参数 下面我们就来扩展 Expression<Func<T,bool>> 这个参数 第一步： 建立处理功能类 首先我们要创建一个查询条件转化为表达式的泛型功能类 如UosoExpressionParser<T&gt...
C# Expression组合多条件表达式
学习和分享
08-25 621
在C#中，使用LINQ表达式（特别是通过System.Linq.Expressions命名空间中的类）来组合多条件表达式时，通常涉及到构建Expression树的复杂过程。不过，对于大多数开发者来说，直接使用LINQ查询语法（基于IQueryable或IEnumerable）或Lambda表达式来构建多条件查询是更常见和更直观的方法。
C#条件拼接Expression＜Func＜T, bool＞＞
风，停了
04-22 5055
使用代码 特别注意 拼接条件时，所使用到的条件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
Expression<Func<T>>和Func<T>
weixin_34205826的博客
05-03 798
　　以前用EF的时候,由于where的时候有Expression<Func<T>>和Func<T>两种查询条件,误用了Func<T>那个重载,后来还想通过func创建查询来着,不过失败了,导致了全表查询,真是无语.国内的人答的比较言简意赅(其实我觉得讲的不好).还是老外讲的明白点. 　　翻译过来吧,就是...
Expression 《Func《T》 bool》》 组合两个表达式
junjie008的专栏
12-04 779
Expression<Func<T bool>> 组合两个表达式 合并成一个。 先写下参考文档网址吧：http://www.albahari.com/nutshell/predicatebuilder.aspx 这里主要使用 PredicateBuilder 中的方法，具体见上面参考文档网址。 关于 表达式的理解：参考此文档https://www.cnblo...
c# Expression 扩展
dieruowan6112的博客
02-14 305
一、简介 当查询比较复杂时，需要很多判断或者跨方法传递参数时使用 二、扩展类 public static class DynamicLinqExpressions { public static Expression<Func<T, bool>> True<T>() { return f => tru...
拉姆达表达式 追加 条件判断 Expression<Func<T, bool>>
weixin_33948416的博客
07-16 769
2019独角兽企业重金招聘Python工程师标准>>> ...
Func<T, bool>与Expression<Func<T, bool>>的区别
weixin_30835933的博客
11-11 743
Func<T, bool>与Expression<Func<T, bool>>的区别 Func<T, bool>是委托(delegate) Expression<Func<T, bool>>是表达式 Expression编译后就会变成delegate，才能运行。比如 Expression<Func<int,...
动态拼接Expression＜Func＜T, bool＞＞ lambda表达式
我是阿兰的博客
08-19 938
【代码】动态拼接Expression lambda表达式。
C#类库 Expression扩展方法
wgq2020的博客
10-24 262
Expression类是C#语言中用于表示表达式树的类库。表达式树是一种以代码形式表示代码的结构。在C#中，我们可以通过Expression类创建表达式树，并且使用表达式树来执行一些高级的操作，例如动态生成代码、延迟执行、编写可重用的查询构造器等。在这些操作中，扩展方法的使用显得非常重要。以上是几个比较常用的C#类库Expression扩展方法的例子。这些方法可以帮助我们更加方便地操作表达式树，提高我们的编程效率。1.扩展方法：获取属性名称。2.扩展方法：获取方法名称。3.扩展方法：获取查询条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值