C# linq动态查询

已于 2024-08-01 10:54:49 修改
阅读量282 收藏
点赞数 2
分类专栏： linq 文章标签： c# linq
于 2024-08-01 09:52:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/five_s/article/details/140838519
版权

本文记录一下 动态生成linq查询条件

实现代码

var filterList = LinqFilterHelper.GetFilterList<Model>(searchModel);
var lambda = LinqFilterHelper.CombineExpressions(filterList.ToArray());
var list = list.Where(lambda.Compile()).ToList();

相关帮助类 LinqFilterHelper

/// <summary>
/// 
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="searchModel"></param>
/// <returns></returns>
public static List<Expression<Func<T, Boolean>>> GetFilterList<T>(object searchModel)
{
    try
    {
        var dynamicSearchModel = JsonHelper.JsonToObject<Models.Models.DynamicSearchModel>(JsonHelper.ObjectToJson(searchModel));
        if (dynamicSearchModel == null || dynamicSearchModel.ConditionList == null)
            return null;

        // 创建参数表达式
        // 创建一个表示类型T的参数表达式，名称为"x"。
        ParameterExpression param = Expression.Parameter(typeof(T), "x");
        var list = new List<Expression<Func<T, Boolean>>>();
        var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance);
        foreach (var fieldCondition in dynamicSearchModel.ConditionList)
        {
            Expression<Func<T, Boolean>> combinedCondition = null;
            // 临时存储or条件
            var tempOrFilterList = new List<Expression<Func<T, Boolean>>>();
            foreach (var condition in fieldCondition.Conditions)
            {
                var fieldFilter = GetFieldFilter<T>(props, param, fieldCondition.Field, condition.Type, condition.FirstValue, condition.SecondValue);
                if (fieldFilter != null)
                {
                    tempOrFilterList.Add(fieldFilter);
                }
            }
            if (tempOrFilterList.Count > 0)
            {
                if (combinedCondition == null)
                {
                    combinedCondition = tempOrFilterList[0];
                }
                if (tempOrFilterList.Count > 1)
                {
                    for (int i = 1; i < tempOrFilterList.Count; i++)
                    {
                        var orElse = Expression.OrElse(combinedCondition.Body, tempOrFilterList[i].Body);
                        combinedCondition = Expression.Lambda<Func<T, Boolean>>(orElse, combinedCondition.Parameters[0]);
                    }
                }
                else
                {
                    combinedCondition = tempOrFilterList[0];
                }
                list.Add(combinedCondition);
            }
        }
        return list;
    }
    catch (Exception ex)
    {
        return null;
    }
}


/// <summary>
/// 生成具体查询语句
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="param">参数表达式</param>
/// <param name="fieldName">字段名</param>
/// <param name="logicType">查询类型  eq/in/between</param>
/// <param name="firstValue">查询值</param>
/// <param name="secondValue">查询次值</param>
/// <returns></returns>
private static Expression<Func<T, bool>> GetFieldFilter<T>(PropertyInfo[] props, ParameterExpression param, string fieldName, string logicType, object firstValue, object secondValue)
{
    var prop = props.FirstOrDefault(p => p.Name.ToLower() == fieldName.ToLower());
    Expression<Func<T, bool>> condition = null;
    if (prop != null)
    {
        // 创建一个表示属性或字段访问的  属性表达式， 将参数param和过滤条件的键(filter.Key)关联起来
        MemberExpression member = Expression.PropertyOrField(param, fieldName);
        // 创建一个包含过滤条件值的      常量表达式
        ConstantExpression constant = Expression.Constant(firstValue);
        
        switch (logicType.ToLower())
        {
            case "eq":
                MethodInfo equalsMethod = typeof(string).GetMethod("Equals", new[] { typeof(string), typeof(StringComparison) });
                MethodCallExpression equalsCall = Expression.Call(member, equalsMethod, constant, Expression.Constant(StringComparison.OrdinalIgnoreCase));
                // 创建 Lambda 表达式
                condition = Expression.Lambda<Func<T, bool>>(equalsCall, param);
                break;
            case "in":
                // 创建一个包含过滤条件值的      常量表达式
                constant = Expression.Constant(JsonHelper.JsonToObject<List<string>>(JsonHelper.ObjectToJson(firstValue)).Select(s => s.ToLowerInvariant()));
                // 创建将属性转换为小写的表达式
                MethodInfo toLowerMethod = typeof(string).GetMethod("ToLowerInvariant", Type.EmptyTypes);
                MethodCallExpression toLowerCall = Expression.Call(member, toLowerMethod);

                // 获取 Contains 方法的 MethodInfo，并泛型化为 string 类型
                MethodInfo containsMethod = typeof(Enumerable)
                      .GetMethods(BindingFlags.Public | BindingFlags.Static)
                      .First(m => m.Name == "Contains" && m.GetParameters().Length == 2)
                      .MakeGenericMethod(typeof(string)); // 泛型化为集合元素类型

                // 构建 MethodCallExpression，调用 Enumerable.Contains 方法，传入集合和属性 表示 collection.Contains(property.ToLower())
                MethodCallExpression containsCall = Expression.Call(
                    containsMethod,
                    constant,
                    toLowerCall
                );
                // 创建 Lambda 表达式
                condition = Expression.Lambda<Func<T, bool>>(containsCall, param);
                break;
            case "lt":
                if (prop.PropertyType.Name.ToLower() == "string")
                {
                    // 创建将属性转换为小写的表达式
                    MethodInfo toLowerMethod1 = typeof(string).GetMethod("ToLowerInvariant", Type.EmptyTypes);
                    MethodCallExpression toLowerMember = Expression.Call(member, toLowerMethod1!);
                    MethodCallExpression toLowerConstant = Expression.Call(constant, toLowerMethod1!);

                    // 创建string.Compare方法调用表达式
                    MethodInfo compareMethodInfo = typeof(string).GetMethod("Compare", new[] { typeof(string), typeof(string), typeof(StringComparison) });
                    Expression comparison = Expression.Call(compareMethodInfo, toLowerMember, toLowerConstant, Expression.Constant(StringComparison.Ordinal));

                    // 创建比较表达式（GreaterThanOrEqual）
                    Expression lessThan = Expression.LessThan(comparison, Expression.Constant(0));

                    condition = Expression.Lambda<Func<T, bool>>(lessThan, param);
                }
                else
                {
                    // 创建大于等于表达式
                    BinaryExpression body = Expression.LessThan(param, constant);
                    // 创建lambda表达式
                    condition = Expression.Lambda<Func<T, bool>>(body, param);
                }
                break;
            case "lte":
                if (prop.PropertyType.Name.ToLower() == "string")
                {
                    // 创建将属性转换为小写的表达式
                    MethodInfo toLowerMethod1 = typeof(string).GetMethod("ToLowerInvariant", Type.EmptyTypes);
                    MethodCallExpression toLowerMember = Expression.Call(member, toLowerMethod1!);
                    MethodCallExpression toLowerConstant = Expression.Call(constant, toLowerMethod1!);

                    // 创建string.Compare方法调用表达式
                    MethodInfo compareMethodInfo = typeof(string).GetMethod("Compare", new[] { typeof(string), typeof(string), typeof(StringComparison) });
                    Expression comparison = Expression.Call(compareMethodInfo, toLowerMember, toLowerConstant, Expression.Constant(StringComparison.Ordinal));

                    // 创建比较表达式（GreaterThanOrEqual）
                    Expression lessThanOrEqual = Expression.LessThanOrEqual(comparison, Expression.Constant(0));

                    condition = Expression.Lambda<Func<T, bool>>(lessThanOrEqual, param);
                }
                else
                {
                    // 创建大于等于表达式
                    BinaryExpression body = Expression.LessThanOrEqual(param, constant);
                    // 创建lambda表达式
                    condition = Expression.Lambda<Func<T, bool>>(body, param);
                }
                break;
            case "gt":
                if (prop.PropertyType.Name.ToLower() == "string")
                {
                    // 创建将属性转换为小写的表达式
                    MethodInfo toLowerMethod1 = typeof(string).GetMethod("ToLowerInvariant", Type.EmptyTypes);
                    MethodCallExpression toLowerMember = Expression.Call(member, toLowerMethod1!);
                    MethodCallExpression toLowerConstant = Expression.Call(constant, toLowerMethod1!);

                    // 创建string.Compare方法调用表达式
                    MethodInfo compareMethodInfo = typeof(string).GetMethod("Compare", new[] { typeof(string), typeof(string), typeof(StringComparison) });
                    Expression comparison = Expression.Call(compareMethodInfo, toLowerMember, toLowerConstant, Expression.Constant(StringComparison.Ordinal));

                    // 创建比较表达式
                    Expression greaterThan = Expression.GreaterThan(comparison, Expression.Constant(0));

                    condition = Expression.Lambda<Func<T, bool>>(greaterThan, param);
                }
                else
                {
                    // 创建大于等于表达式
                    BinaryExpression body = Expression.GreaterThan(param, constant);
                    // 创建lambda表达式
                    condition = Expression.Lambda<Func<T, bool>>(body, param);
                }
                break;
            case "gte": //大于等于
                if (prop.PropertyType.Name.ToLower() == "string")
                {
                    // 创建将属性转换为小写的表达式
                    MethodInfo toLowerMethod1 = typeof(string).GetMethod("ToLowerInvariant", Type.EmptyTypes);
                    MethodCallExpression toLowerMember = Expression.Call(member, toLowerMethod1!);
                    MethodCallExpression toLowerConstant = Expression.Call(constant, toLowerMethod1!);

                    // 创建string.Compare方法调用表达式
                    MethodInfo compareMethodInfo = typeof(string).GetMethod("Compare", new[] { typeof(string), typeof(string), typeof(StringComparison) });
                    Expression comparison = Expression.Call(compareMethodInfo, toLowerMember, toLowerConstant, Expression.Constant(StringComparison.Ordinal));

                    // 创建比较表达式
                    Expression greaterThanOrEqual = Expression.GreaterThanOrEqual(comparison, Expression.Constant(0));

                    condition = Expression.Lambda<Func<T, bool>>(greaterThanOrEqual, param);
                }
                else
                {
                    // 创建大于等于表达式
                    BinaryExpression body = Expression.GreaterThanOrEqual(param, constant);
                    // 创建lambda表达式
                    condition = Expression.Lambda<Func<T, bool>>(body, param);
                }
                break;
            case "between":
                // 创建一个包含过滤条件值的      常量表达式
                ConstantExpression secondConstant = Expression.Constant(secondValue);
                if (prop.PropertyType.Name.ToLower() == "string")
                {
                    // 创建将属性转换为小写的表达式
                    MethodInfo toLowerMethod1 = typeof(string).GetMethod("ToLowerInvariant", Type.EmptyTypes);
                    // 创建ToLowerInvariant方法调用表达式（对于member、constant和secondConstant）
                    MethodCallExpression toLowerMember = Expression.Call(member, toLowerMethod1!);
                    MethodCallExpression toLowerConstant = Expression.Call(constant, toLowerMethod1!);
                    MethodCallExpression toLowerSecondConstant = Expression.Call(secondConstant, toLowerMethod1!);

                    // 创建string.Compare方法调用表达式
                    MethodInfo compareMethodInfo = typeof(string).GetMethod("Compare", new[] { typeof(string), typeof(string), typeof(StringComparison) });
                    Expression greaterComparison = Expression.Call(compareMethodInfo, toLowerMember, toLowerConstant, Expression.Constant(StringComparison.Ordinal));
                    // 创建 大于等于 比较表达式
                    Expression greaterThanOrEqual = Expression.GreaterThanOrEqual(greaterComparison, Expression.Constant(0));

                    Expression lessComparison = Expression.Call(compareMethodInfo, toLowerMember, toLowerSecondConstant, Expression.Constant(StringComparison.Ordinal));
                    // 创建 小于等于 比较表达式
                    Expression lessThanOrEqual = Expression.LessThanOrEqual(lessComparison, Expression.Constant(0));
                    
                    // 组合两个比较表达式为逻辑与（AndAlso）
                    BinaryExpression andExpression = Expression.AndAlso(greaterThanOrEqual, lessThanOrEqual);
                    condition = Expression.Lambda<Func<T, bool>>(andExpression, param);
                } 
                else
                {
                    // 创建大于等于表达式
                    BinaryExpression greaterThanOrEqual = Expression.GreaterThanOrEqual(param, constant);
                    BinaryExpression lessThanOrEqual = Expression.LessThanOrEqual(param, secondConstant);
                    // 组合两个比较表达式为逻辑与（AndAlso）
                    BinaryExpression andExpression = Expression.AndAlso(greaterThanOrEqual, lessThanOrEqual);

                    // 创建lambda表达式
                    condition = Expression.Lambda<Func<T, bool>>(andExpression, param);
                }
                break;
            default:
                condition = null;
                break;
        }
    }
    return condition;
}

/// <summary>
/// 条件汇总
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="expressions"></param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
public static Expression<Func<T, bool>> CombineExpressions<T>(params Expression<Func<T, bool>>[] expressions)
{
    if (expressions == null || expressions.Length == 0)
    {
        throw new ArgumentException("No expressions provided.");
    }

    // 第一个表达式作为起点
    Expression<Func<T, bool>> combined = expressions[0];

    // 逐个拼接剩余的表达式
    for (int i = 1; i < expressions.Length; i++)
            {
                // 创建 AndAlso 表达式
                var andAlso = Expression.AndAlso(combined.Body, expressions[i].Body);

                // 使用 LambdaExpression.Update 方法来更新参数和主体
                combined = Expression.Lambda<Func<T, bool>>(andAlso, combined.Parameters[0]);
            }

    return combined;
}

相关实体类

/// <summary>
/// 动态查询类
/// </summary>
public class DynamicSearchModel
{
    /// <summary>
    /// 排序
    /// </summary>
    public List<SortModel> SortList { get; set; }

    /// <summary>
    /// 
    /// </summary>
    public List<TableHeaderModel> TableHead { get; set; }
    /// <summary>
    /// 描述 : 查询条件列表 当条件列表为空或不填时，则不设查询条件
    /// 空值 : False
    /// 默认 : 
    /// </summary>
    public List<ConditionFieldModel> ConditionList { get; set; }

}

/// <summary>
/// 字段条件
/// </summary>
public class ConditionFieldModel
{
    /// <summary>
    /// 描述 : 字段
    /// 空值 : False
    /// 默认 : 
    /// </summary>
    public string Field { get; set; }

    /// <summary>
    /// 描述 : 条件
    /// 空值 : False
    /// 默认 : 
    /// </summary>
    public List<ConditionModel> Conditions { get; set; }
}

/// <summary>
/// 条件
/// </summary>
public class ConditionModel
{
    /// <summary>
    /// 描述 : 条件类型 eq：等于，ne：不等于，lt：小于，lte：小于等于，gt：大于，gte：大于等于，like：模糊匹配，in：包含， notin：不包含，between：在...之间
    /// 空值 : False
    /// 默认 : 
    /// </summary>
    public string Type { get; set; }

    /// <summary>
    /// 描述 : 该参数可为任意值，当类型为boolean时，只可以使用eq类型。当类型为in时，需传输Array对象
    /// 空值 : False
    /// 默认 : 
    /// </summary>
    public object FirstValue { get; set; }

    /// <summary>
    /// 描述 : 该参数只在类型为between时使用，为between的第二个值
    /// 空值 : False
    /// 默认 : 
    /// </summary>
    public object SecondValue { get; set; }
}
灯火明亮
关注
专栏目录
C# linq where 条件表达式动态生成
03-18 612
C# Expression 动态生成linq where 表达式
使用LINQ动态查询库
Mobidogs Blog
10-31 1289
【原文地址】Dynamic LINQ (Part 1: Using the LINQ Dynamic Query Library) 【原文发表日期】 Monday, January 07, 2008 11:02 PM LINQ （语言级集成查询）是VS 2008 和 .NET 3.5中提供的一个新特性。LINQ使得数据查询的概念成为.NET中的一等编程概念，允许你在你喜欢的编程语言中有效地表达查
.net linq动态组合查询条件及排序
03-26
.net linq动态组合查询条件及排序，让linq像ado.net那样动态组合条件查询
C#在DataTable中使用LINQ
最新发布
zhaotianff的专栏
08-18 1376
C#在DataTable中使用LINQ
LINQ动态条件查询（一）
左右为南的专栏
07-10 3847
动态查询 有这样一个场景：应用程序可能会提供一个用户界面，用户可以使用该用户界面指定一个或多个谓词来筛选数据。这种情况在编译时不知道查询的细节，动态查询将十分有用。 在LINQ中，Lambda表达式是许多标准查询运算符的基础，编译器创建lambda表达式以捕获基础查询方法（例如 Where、Select、Order By、Take While 以及其他方法）中定义的计算。表达式目录树用于针对数
[C#] Linq 动态条件查询
weixin_30633405的博客
09-02 290
应用背景：以货品为例，在基础数据中配置货品的判断规则，要根据这个规则筛选出符合条件的集合。 创建货品类 public class Product { public string Name { get; set; } public string Code { get; set; } public string Unit ...
Linq动态条件
dibengpo4955的博客
03-28 222
很多情况下，我们开发程序，需要动态拼接SQL查询语句; 比如 select top 1 * from User where age= 18 and name = 'renruiquan' 其中红色的代码，是我们需要根据查询条件是否为空，来判，要不要加在查询的SQL里; 换成Linq里就不能这么直接的去拼接了，好在国外的大神有给我们解决方案。下面直接上代码： （新手同学不需要...
C# linq查询之动态OrderBy用法实例
01-01
本文实例讲述了C# linq查询之动态OrderBy用法。分享给大家供大家参考。具体分析如下： groupList是原始数据集合，List sortOrder是排序类型，desc 或者asc sortName是排序属性名称 1.使用反射。 private static ...
Linq动态查询、行转列
05-07
首先，让我们来理解什么是LINQ动态查询。在传统的LINQ查询中，我们通常使用lambda表达式或方法链来定义查询条件。然而，在某些场景下，查询条件可能在运行时才确定，这就是动态LINQ发挥作用的地方。`System.Linq....
C#使用LINQ查询表达式的基本子句总结
09-02
me="博客园",Age=6,TelTable=new List(){"666666"}}, new GustInfo2{Name="M&MSoft",Age=9,TelTable=new List(){"55555","9999999"}} }; var query2 = from gust2 in gList2 from tel in gust2.TelTable where gust2...
C# Linq查询
09-28
**C# LINQ查询详解** LINQ（Language Integrated Query，语言集成查询）是.NET Framework 3.5引入的一项重要特性，它为C#提供了一种强大的数据查询能力，使得开发者可以使用一致的语法来处理各种数据源，如数组、...
c# 配置类属性动态显示值(Linq)
05-26
c# 配置类属性动态显示值(Linq) 版本：vs2013
Linq动态条件查询
水工鸟的专栏
05-10 3398
1、添加类PredicateExtensions.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Linq.Expressions;namespace Www24100Net.PlayingWithLinq{  public static class
c#——表达式树在LINQ动态查询
世界中心的专栏
10-30 7126
一般如果逻辑比较简单，只是存在有的情况多一个查询条件，有的情况不需要添加该查询条件 简单方式这样操作就可以了 public IQueryable DynamicChainedSyntax (IQueryable files, bool pastOnly) { var query = files.Where(file => file.ImportDate > DateTime.No
Linq 动态条件查询
qq_34276316的博客
05-12 282
应用背景：以货品为例，在基础数据中配置货品的判断规则，要根据这个规则筛选出符合条件的集合。
linq动态添加查询条件
aiweizhao的博客
02-24 1932
动态添加查询条件简易用法 //置入AND条件 Expression<Func<object, bool>> where = p => （条件1）&& （条件2）; foreach (string item in LIST) { //定义OR条件 Expression<Func<object, bool>> temp = p => （条件3,4,5...）; //放入INVOKE var in...
Linq之动态条件(1)
weixin_34007886的博客
07-13 146
  在开发项目的过程中，我们经常会遇到这样的需求，动态组合条件的查询。比如淘宝中的高级搜索： 要实现这个功能，通常的做法是拼接SQL查询字符串，不管是放在程序中或是在存储过程中。现在出现了Linq，下面来看看用Linq是怎样实现动态条件查询？ 还是以Northwind数据库为例，如果要查询所有CustomerID以A或者B字母开头的Customer，一般我们会这样写： var resul...
让LINQ支持动态查询
无天的博客
07-10 1780
当对一个Model的List使用LINQ查询或排序时，希望通过传入不同的参数，动态的使用LINQ进行操作。可以引入System.Linq.dynamic
c# LINQ 动态查询
06-07
在 C# 中使用 LINQ 进行动态查询，可以使用 `System.Linq.Dynamic` 库。这个库可以让我们在运行时动态构建 LINQ 查询表达式。下面是一个示例代码： ```csharp using System.Linq.Dynamic; string propertyName = "Name"; string propertyValue = "Tom"; var query = list.Where($"{propertyName} == @0", propertyValue); ``` 在这个示例中，我们使用 `System.Linq.Dynamic` 库中的 `Where` 扩展方法来实现动态查询。我们首先定义了要查询的属性名和属性值，然后使用字符串插值语法将其拼接成一个字符串表达式。在字符串表达式中，我们使用 `@0` 来表示第一个参数（即 `propertyValue`）。最后，我们调用 `Where` 方法，并传入这个字符串表达式和属性值，即可完成动态查询。 需要注意的是，使用 `System.Linq.Dynamic` 库进行动态查询时，拼接的字符串表达式必须符合一定的语法规则，否则会抛出异常。具体的语法规则可以参考该库的文档。 希望这个答案能够解决您的问题。如果您有其他问题，可以继续提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值