C# linq where 条件表达式动态生成

已于 2024-05-10 14:19:00 修改
阅读量468 收藏
点赞数 4
文章标签： c# linq express
于 2024-03-18 14:07:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sw6809172/article/details/136807112
版权
文章介绍了C#中的ConditionExpression类，用于构建复杂的逻辑表达式，包括运算符重载和转换，以及如何将其与LINQ查询的WhereExpression方法结合，以实现动态查询条件的设置。
摘要由CSDN通过智能技术生成

基础类 

public class ConditionExpression
{
    public ConditionExpression()
    {

    }
    public ConditionExpression(ConditionExpression left, ConditionExpression right, string op)
    {
        this.Left = left;
        this.Right = right;
        this.Op = op;
    }

    private ConditionExpression _left;
    public ConditionExpression Left
    {
        get
        {
            return _left;
        }
        set
        {
            if (value.isbottom)
            {
                value.isfield = true;
            }
            _left = value;
        }
    }
    public ConditionExpression Right { get; set; }
    public string Op { get; set; }
    private bool isfield = false;
    private bool isbottom = false;
    private object _value;
    public object Value
    {
        get { return _value; }
        set { _value = value; }
    }

    public override string ToString()
    {
        if (isbottom)
        {
            if (!isfield)
            {
                if (Value == null)
                    return null;
                return  Convert.ToString("'" + Value + "'");
            }
            else
            {
                return Convert.ToString(Value);
            }
        }

        else
        {
            if(Right==null&& Op=="=")
                return Left + " is null ";
            else 
            return Left + " " + Op + " " + Right;
        }

    }

    public static implicit operator ConditionExpression(string value)
    {
        ConditionExpression condition = new ConditionExpression();
        condition.Value = value;
        condition.isbottom = true;
        return condition;
    }

    public static implicit operator ConditionExpression(int value)
    {
        ConditionExpression condition = new ConditionExpression();
        condition.Value = value;
        condition.isbottom = true;
        return condition;
    }
    public static ConditionExpression operator &(ConditionExpression Condition1, ConditionExpression Condition2)
    {
        if (Condition1 != null && Condition2 != null)
        {
            ConditionExpression condition = new ConditionExpression();
            condition.Left = Condition1;
            condition.Right = Condition2;
            condition.Op = "and";
            return condition;
        }
        else if (Condition1 != null)
        {
            return Condition1;
        }
        else if (Condition2 != null)
        {
            return Condition2;
        }
        return null;
    }

    public static ConditionExpression operator |(ConditionExpression Condition1, ConditionExpression Condition2)
    {
        if (Condition1 != null && Condition2 != null)
        {
            ConditionExpression condition = new ConditionExpression();
            condition.Left = Condition1;
            condition.Right = Condition2;
            condition.Op = "or";
            return condition;
        }
        else if (Condition1 != null)
        {
            return Condition1;
        }
        else if (Condition2 != null)
        {
            return Condition2;
        }
        return null;
    }
    private bool IsCompareThan<T>(Type PropertyType)
    {
        if (PropertyType.Name == typeof(Int32).Name || PropertyType.Name == typeof(Int64).Name ||
            PropertyType.Name == typeof(Int16).Name || PropertyType.Name == typeof(float).Name ||
            PropertyType.Name == typeof(decimal).Name || PropertyType.Name == typeof(double).Name ||
             PropertyType.Name == typeof(DateTime).Name)
        {
            return true;
        }
        else return false;
    }

    private ParameterExpression parameterExpression { get; set; }
    private Expression GetBodyExpression<T>(ConditionExpression parent)
    {
        if (isfield && isbottom)
        {
            Type PropertyType = typeof(T).GetProperty(parent.Left.ToString()).PropertyType;
            if (PropertyType.IsGenericType && PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                PropertyType = PropertyType.GetGenericArguments()[0];
            }
            Expression ru;
            MemberExpression memberExpression = Expression.Property(parent.parameterExpression, Convert.ToString(Value));
            if (IsCompareThan<T>(PropertyType))
            {
                ru = memberExpression;
            }
            else
            {
                if (parent.Op == "=")
                {
                    ru = memberExpression;
                }
                else if (parent.Op == ">" || parent.Op == ">=" || parent.Op == "<" || parent.Op == "<=")
                {
                    MethodInfo method = memberExpression.Type.GetMethod("CompareTo", new Type[] { typeof(string) });
                    Object Ovalue = Convert.ChangeType(parent.Right.Value, PropertyType);
                    ConstantExpression rightExpression = Expression.Constant(Ovalue, PropertyType);
                    MethodCallExpression methodCallExpression = Expression.Call(memberExpression, method, rightExpression);
                    ru = methodCallExpression;
                }
                else if (parent.Op == "like")
                {
                    MethodInfo method = memberExpression.Type.GetMethod("Contains", new Type[] { typeof(string) });
                    Object Ovalue = Convert.ChangeType(parent.Right.Value, PropertyType);
                    ConstantExpression rightExpression = Expression.Constant(Ovalue, PropertyType);
                    MethodCallExpression methodCallExpression = Expression.Call(memberExpression, method, rightExpression);
                    ru = methodCallExpression;
                }
                else
                {
                    throw new Exception("不支持的比较操作符与数据类型 参考 >=<like");
                }
            }

            return ru;
        }
        else if (isbottom)
        {
            Type PropertyType = typeof(T).GetProperty(parent.Left.ToString()).PropertyType;
            Type BPropertyType = PropertyType;
            ConstantExpression constantExpression = null;
            if (PropertyType.IsGenericType && PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                PropertyType = PropertyType.GetGenericArguments()[0];
            }

            Object Ovalue = Convert.ChangeType(Value, PropertyType);

            if (IsCompareThan<T>(PropertyType))
            {
                constantExpression = Expression.Constant(Ovalue, PropertyType);
            }
            else
            {
                if (parent.Op == "=")
                {
                    if (PropertyType.Name == typeof(bool).Name)
                    {
                        constantExpression = Expression.Constant(Ovalue, typeof(bool));
                    }
                    else
                    {
                        constantExpression = Expression.Constant(Value, typeof(string));
                    }

                }
                else if (parent.Op == "like")
                {
                    constantExpression = Expression.Constant(true, typeof(bool));
                }
                else if (parent.Op == ">" || parent.Op == ">=" || parent.Op == "<" || parent.Op == "<=")
                {
                    constantExpression = Expression.Constant(0, typeof(int));
                }
                else
                {
                    throw new Exception("不支持的比较操作符与数据类型 参考 >=<like");
                }
            }
            Expression typeFilter = constantExpression;
            if (BPropertyType.IsGenericType && BPropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                typeFilter = Expression.Convert(constantExpression, BPropertyType);
            }
          ;
            return typeFilter;

        }

        if (Op == ">")
        {
            parameterExpression = parent.parameterExpression;
            Expression body = Expression.GreaterThan(Left.GetBodyExpression<T>(this), Right.GetBodyExpression<T>(this));
            return body;
        }
        if (Op == ">=")
        {
            parameterExpression = parent.parameterExpression;
            Expression body = Expression.GreaterThanOrEqual(Left.GetBodyExpression<T>(this), Right.GetBodyExpression<T>(this));
            return body;
        }
        if (Op == "<")
        {
            parameterExpression = parent.parameterExpression;
            Expression body = Expression.LessThan(Left.GetBodyExpression<T>(this), Right.GetBodyExpression<T>(this));
            return body;
        }
        if (Op == "<=")
        {
            parameterExpression = parent.parameterExpression;
            Expression body = Expression.LessThanOrEqual(Left.GetBodyExpression<T>(this), Right.GetBodyExpression<T>(this));
            return body;
        }

        if (Op == "=")
        {
            parameterExpression = parent.parameterExpression;

            Expression body = Expression.Equal(Left.GetBodyExpression<T>(this), Right.GetBodyExpression<T>(this));
            return body;
        }

        if (Op == "like")
        {
            parameterExpression = parent.parameterExpression;
            Expression body = Expression.Equal(Left.GetBodyExpression<T>(this), Right.GetBodyExpression<T>(this));
            return body;
        }

        if (Op == "and")
        {
            parameterExpression = parent.parameterExpression;
            Expression body = Expression.And(Left.GetBodyExpression<T>(this), Right.GetBodyExpression<T>(this));
            return body;
        }

        if (Op == "or")
        {
            parameterExpression = parent.parameterExpression;
            Expression body = Expression.Or(Left.GetBodyExpression<T>(this), Right.GetBodyExpression<T>(this));
            return body;
        }
        throw new NotImplementedException();
    }



    public Expression ToExpression<T>(ParameterExpression parameter = null)
    {
        parameterExpression = Expression.Parameter(typeof(T), "o");
        Expression body = GetBodyExpression<T>(this);
        Expression expression = Expression.Lambda(body, parameterExpression);
        return expression;
    }
}
 public static  class Extensions
 {
     public static Expression<Func<T, bool>> ToWhereExpression<T>(this Condition condition,bool ignoreTypeError=true )
     {
        
         ConditionExpression andCondition = null;
         ConditionExpression expression = null;
         if (condition != null)
         {
             if (condition.AndCondition.Count > 0)
             {
                 
                 for (int i = 0; i < condition.AndCondition.Count; i++)
                 {

                     if (!string.IsNullOrEmpty(condition.AndCondition[i].Value))
                     {
                         
                         ConditionExpression cexpre = new ConditionExpression();
                         string Field=   condition.AndCondition[i].Field;
                         string Value = condition.AndCondition[i].Value;
                      
                         if (ignoreTypeError)
                         {
                             Type PropertyType = typeof(T).GetProperty(Field).PropertyType;
                             if (PropertyType.IsGenericType && PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                             {
                                 PropertyType = PropertyType.GetGenericArguments()[0];
                             }
                             try
                             {
                                 if (PropertyType == typeof(bool)&&Value=="1")
                                 {
                                     Value = "true";
                                 }
                                 if (PropertyType == typeof(bool) && Value == "0")
                                 {
                                     Value = "false";
                                 }
                                 Object Ovalue = Convert.ChangeType(Value, PropertyType);
                                 cexpre.Left = Field;
                                 cexpre.Right = Value;
                                 cexpre.Op = condition.AndCondition[i].Op;
                             }
                             catch 
                             {
                                 cexpre = null;
                             }
                         }
                         else
                         {
                             cexpre.Left = Field;
                             cexpre.Right = Value;
                             cexpre.Op = condition.AndCondition[i].Op;
                         }

                         andCondition = andCondition & cexpre;

                     }

                 }
             }
             ConditionExpression orCondition = null;
             if (condition.OrCondition.Count > 0)
             {
                 for (int i = 0; i < condition.OrCondition.Count; i++)
                 {
                     if (!string.IsNullOrEmpty(condition.OrCondition[i].Value))
                     {
                         ConditionExpression cexpre = new ConditionExpression();


                         string Field = condition.OrCondition[i].Field;
                         string Value = condition.OrCondition[i].Value;

                         if (ignoreTypeError)
                         {
                             Type PropertyType = typeof(T).GetProperty(Field).PropertyType;
                             if (PropertyType.IsGenericType && PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                             {
                                 PropertyType = PropertyType.GetGenericArguments()[0];
                             }
                             try
                             {
                                 Object Ovalue = Convert.ChangeType(Value, PropertyType);
                                 cexpre.Left = Field;
                                 cexpre.Right = Value;
                                 cexpre.Op = condition.OrCondition[i].Op;
                             }
                             catch
                             {
                                 cexpre = null;
                             }
                         }
                         else
                         {
                             cexpre.Left = Field;
                             cexpre.Right = Value;
                             cexpre.Op = condition.OrCondition[i].Op;
                         }

                        
                         orCondition = orCondition | cexpre;
                     }
                 }
             }

             if (condition.Concat == "and")
             {
                 expression = andCondition & orCondition;
             }
             if (condition.Concat == "or")
             {
                 expression = andCondition | orCondition;
             }
         }
       
         if (condition == null|| expression==null)
         {
             var be = Expression.Equal(Expression.Constant(1), Expression.Constant(1));
             var ree = Expression.Lambda(be, Expression.Parameter(typeof(T), "o"));
             return (Expression<Func<T, bool>>)ree;
         }
         LambdaExpression re = (LambdaExpression ) expression.ToExpression<T>();
         return (Expression<Func<T, bool>>)re;
     }
     public static Expression<Func<T, bool>> ToWhereExpression<T>(this IQueryable<T> iqueryable, Condition condition, bool ignoreTypeError = true)
     {

         ConditionExpression andCondition = null;
         ConditionExpression expression = null;
         if (condition != null)
         {
             if (condition.AndCondition.Count > 0)
             {

                 for (int i = 0; i < condition.AndCondition.Count; i++)
                 {

                     if (!string.IsNullOrEmpty(condition.AndCondition[i].Value))
                     {

                         ConditionExpression cexpre = new ConditionExpression();
                         string Field = condition.AndCondition[i].Field;
                         string Value = condition.AndCondition[i].Value;

                         if (ignoreTypeError)
                         {
                             Type PropertyType = typeof(T).GetProperty(Field).PropertyType;
                             if (PropertyType.IsGenericType && PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                             {
                                 PropertyType = PropertyType.GetGenericArguments()[0];
                             }
                             try
                             {
                                 if (PropertyType == typeof(bool) && Value == "1")
                                 {
                                     Value = "true";
                                 }
                                 if (PropertyType == typeof(bool) && Value == "0")
                                 {
                                     Value = "false";
                                 }
                                 Object Ovalue = Convert.ChangeType(Value, PropertyType);
                                 cexpre.Left = Field;
                                 cexpre.Right = Value;
                                 cexpre.Op = condition.AndCondition[i].Op;
                             }
                             catch
                             {
                                 cexpre = null;
                             }
                         }
                         else
                         {
                             cexpre.Left = Field;
                             cexpre.Right = Value;
                             cexpre.Op = condition.AndCondition[i].Op;
                         }

                         andCondition = andCondition & cexpre;

                     }

                 }
             }
             ConditionExpression orCondition = null;
             if (condition.OrCondition.Count > 0)
             {
                 for (int i = 0; i < condition.OrCondition.Count; i++)
                 {
                     if (!string.IsNullOrEmpty(condition.OrCondition[i].Value))
                     {
                         ConditionExpression cexpre = new ConditionExpression();


                         string Field = condition.OrCondition[i].Field;
                         string Value = condition.OrCondition[i].Value;

                         if (ignoreTypeError)
                         {
                             Type PropertyType = typeof(T).GetProperty(Field).PropertyType;
                             if (PropertyType.IsGenericType && PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                             {
                                 PropertyType = PropertyType.GetGenericArguments()[0];
                             }
                             try
                             {
                                 Object Ovalue = Convert.ChangeType(Value, PropertyType);
                                 cexpre.Left = Field;
                                 cexpre.Right = Value;
                                 cexpre.Op = condition.OrCondition[i].Op;
                             }
                             catch
                             {
                                 cexpre = null;
                             }
                         }
                         else
                         {
                             cexpre.Left = Field;
                             cexpre.Right = Value;
                             cexpre.Op = condition.OrCondition[i].Op;
                         }


                         orCondition = orCondition | cexpre;
                     }
                 }
             }

             if (condition.Concat == "and")
             {
                 expression = andCondition & orCondition;
             }
             if (condition.Concat == "or")
             {
                 expression = andCondition | orCondition;
             }
         }

         if (condition == null || expression == null)
         {
             var be = Expression.Equal(Expression.Constant(1), Expression.Constant(1));
             var ree = Expression.Lambda(be, Expression.Parameter(typeof(T), "o"));
             return (Expression<Func<T, bool>>)ree;
         }
         LambdaExpression re = (LambdaExpression)expression.ToExpression<T>();
         return (Expression<Func<T, bool>>)re;
     }


 }
public class Condition
{
    public Condition()
    {
        AndCondition = new List<ConditionModel>();
        OrCondition = new List<ConditionModel>();
        Concat = "and";
    }
    public  List<ConditionModel> AndCondition { get; set; }
    public List<ConditionModel> OrCondition { get; set; }
    public string Concat { get; set; }
}
public class ConditionModel
{
    public string Field { get; set; }
    public string Value { get; set; }
    public string Op { get; set; }
}

使用方法

var condition= new Condition ()
//第一种  匿名

var query = from a in  xxx
             select new
             {
                //
             };
query= query.Where(query.ToWhereExpression(condition));

//第二种

condition.OrCondition.Add(
new ConditionModel() { Field = "xxx", Value = 'xxx_SearchValue', Op = "like" }
);

condition.Concat = "and";

condition.AndCondition.Add(
new ConditionModel() { Field = "yyyy", Value = "yyy_SearchValue", Op = "=" }
);

condition.ToWhereExpression<T>();

 附加：配合前端使用更舒服


class Pagination{
    constructor(PageSize,PageIndex,Sort,SortType,TotalCount,keywords,cdition){
        this.PageSize=PageSize
        this.PageIndex=PageIndex
        this.Sort=Sort
        this.SortType=SortType
        this.TotalCount=TotalCount
        this.keywords=keywords
        if(cdition){
            if(cdition instanceof condition)
                this.cdition=cdition
            else
            {
                console.log('cdition 错误 请用 new condition');
            }
        }
    }
      toJSON() {
        let obj={
            __className: 'Pagination', 
            PageSize: this.PageSize, 
            PageIndex: this.PageIndex,
            Sort: this.Sort,
            SortType: this.SortType,
            TotalCount: this.TotalCount,
            keywords: this.keywords
        }
        if(this.cdition)
            obj.condition=this.cdition.toJSON()
        return obj;
      }
     
      static fromJSON(json) {
        return new Pagination(
            json.PageSize,
            json.PageIndex,
            json.Sort,
            json.SortType,
            json.TotalCount,
            json.keywords,
            json.cdition
            );
      }
}
class conditionItem{
    constructor(Field,Value,Op){
        this.Field=Field
        this.Value=Value
        this.Op=Op
    }
    toJSON(){
        let obj={
            __className: 'conditionItem', 
            Field: this.Field, 
            Value: this.Value,
            Op: this.Op,
        }
        return obj
    }
}

class condition{
    constructor(options){
        if(options.AndCondition)
        {
            if(!Array.isArray(options.AndCondition)){
                throw new Error('options.AndCondition 必须是conditionItem数组')
            }
            this.AndCondition=options.AndCondition
        }
        if(options.OrCondition)
        {
            if(!Array.isArray(options.OrCondition)){
                throw new Error('options.OrCondition 必须是conditionItem数组')
            }
            this.OrCondition=options.OrCondition
        }
        if(options.Concat)
         this.Concat=options.Concat
    }
    toJSON(){
        let obj={
            __className: 'condition'
        }
       
        if(this.AndCondition)
        { 
            obj.AndCondition=[]
            for (let item of this.AndCondition){
                obj.AndCondition.push(item.toJSON())
            }
        }
        if(this.OrCondition)
        {
             obj.OrCondition=[]
            for (let item of this.OrCondition){
                obj.OrCondition.push(item.toJSON())
            }
        }
        if(this.Concat)
            obj.Concat=this.Concat
        return obj;
    }
}
/**
var cond=new condition({
    AndCondition:[
        new conditionItem("name","此","="),
        new conditionItem("age","32","=")
    ],
    OrCondition:[]
})
var pagination=new Pagination(12,1,'id','asc',0,'',cond)
var s=pagination.toJSON()
console.log(JSON.stringify(s)) 
 */

export  {Pagination,condition,conditionItem}

sw6809172
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于LINQ的模糊查询
dongnihao的博客
11-01 1236
利用linq中的WhereIf扩展方法。
.netLinq动态Where条件
weixin_30822451的博客
03-27 1593
.netLinq动态Where条件 文章介绍全网最佳方式使用EF+Linq实现多条件组合查询；代码中没有使用到网上主流自定义Expression表达式而是采用linq原生态功能编写示例直观、易懂，且有效解决自定义Expression不支持EF问题。 一、EF+Linq代码片段示例如下(注意只是片段，如果对EF熟悉可轻松理解，model变量为数...
动态拼接linq Where条件
最新发布
hengyua的博客
06-14 167
定义一个动态拼接lambda 的帮助类。
Linq之动态条件(1)
weixin_34007886的博客
07-13 135
  在开发项目的过程中，我们经常会遇到这样的需求，动态组合条件的查询。比如淘宝中的高级搜索： 要实现这个功能，通常的做法是拼接SQL查询字符串，不管是放在程序中或是在存储过程中。现在出现了Linq，下面来看看用Linq是怎样实现动态条件查询？ 还是以Northwind数据库为例，如果要查询所有CustomerID以A或者B字母开头的Customer，一般我们会这样写： var resul...
【温故知新】C# Linq中 Where使用技巧
dotNET跨平台
08-12 672
微信公众号：趣编程ACE关注可了解更多的.NET日常实战开发技巧，如需源码 后台回复 源码 即可;如果觉得对你有帮助，欢迎关注C# Linq中 Where使用技巧hello 大家好，很开心又能重新分享C#编程开发技巧了，之前因为工作和生活没有达成一个很好的平衡，导致状态下滑，好像断更很久了。在这里不得自我检讨一波，以后继续分享~大家一起交流呀~你可能不知道的源码网站.Ne...
C# Linq源码分析之Where
weixin_43263355的博客
07-23 2000
概要 在Dotnet 开发过程中，无论是Web还是Form或是其他领域的开发，Where作为IEnumerable的扩展方法，十分常用。本文对Where方法的关键源码进行简要分析，以方便大家日后更好的使用该方法。 本文分析的源码来自 https://github.com/dotnet/runtime.git 代码结构分析 Where方法的过滤功能主要通过迭代器实现，其源代码包含7个迭代器。按照功能划分如下： 索引参与过滤操作运算的迭代器WhereIterator，容器包含Enmuerable，List和A
C#使用LINQ查询表达式的基本子句总结
09-02
var query2 = from gust2 in gList2 from tel in gust2.TelTable where gust2.Age > 9 select new { GustName = gust2.Name, Tel = tel }; foreach (var item in query2) { Console.WriteLine("客人: {0} 手机号: {...
C# Linq lambda表达式.doc
11-06
在C#中，Lambda表达式是LINQ的核心部分，它用于创建匿名函数，使得我们可以更加便捷地进行过滤、查找、排序、分组等操作。 1. **过滤（Filtering）** 在C#中，我们可以使用Lambda表达式配合`Where()`方法来过滤...
.net linq动态组合查询条件及排序
03-26
在这个例子中，`DynamicExpression.ParseLambda`方法用于将字符串条件转换为Lambda表达式，然后我们将其传递给`Where()`方法，从而实现动态条件查询。 至于动态排序，我们可以使用`OrderBy()`或`OrderByDescending...
C#高级编程_Lambda表达式和LINQ的原理和使用
07-09
在C#编程中，Lambda表达式和LINQ是两种强大的工具，它们极大地简化了代码的编写，特别是处理数据查询和事件处理。理解这两者的工作原理和使用方式是成为C#高级程序员的关键步骤。 Lambda表达式是匿名函数的一种简洁...
.Net C# Linq Where 方法
u010992421的专栏
12-20 2181
.Net C# Linq Where 方法
C# LINQ中的Where方法的内部实现
yasenRK的博客
03-13 1677
C# LINQ中的Where方法的内部实现 写C#快一年多了，今天在b站搜到一个进阶的课程，打算提高一些自己的水平，然后就开始学习了。课程讲的是我平时开发过程中用的最多的LINQ内部实现和实际运行过程剖析，我会把每节课程的学习内容写成博客记录下来，只为了记录自己的学习和成长过程，如果有人能够从中受益，那我是更加开心啦。 引子: 假设我们有一个0-10的数组，需要挑出所有的奇数，那么我们就可以用Where语句来过滤出满足条件的数字 var items=new []{1,2,3,4,
C#-linq实战003-查询-Where
lingzhanfang的博客
09-25 596
Where语句检查符合条件的元素，并返回新的迭代器 1：基于谓词筛选值序列 IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) 1.1：foreach解析： //IEnumerable<TSource> Where<TSource>(this IEnume
Linq 动态表达式 多条件查询
weixin_30435261的博客
11-23 390
转自 using System.Linq.Expressions;// <summary>/// LinqExpressions 的摘要描述/// </summary>public static class DynamicLinqExpressions//注意static靜態型別{public static Expression<Func<T, bool&gt...
C#系 常用的LinQ查询表达式之where
杨勇博客之家
01-13 5589
MSDN解释：where 子句用于查询表达式中，用于指定将在查询表达式中返回数据源中的哪些元素。它将一个布尔条件（"谓词"）应用于每个源元素（由范围变量引用），并返回满...
mongodb.driver 2.4.4 c# 第二篇 动态where条件查询
彭磊的专栏
01-17 2903
string name="abc";  var wheres = Builders.Filter.Exists("unique_id"); // 逻辑或 |    逻辑与&   根据实际逻辑判断   if (!string.IsNullOrEmpty(name)) wheres = wheres & (Builders.Filter.Regex("name", new BsonRegula
Linq动态条件查询
水工鸟的专栏
05-10 3385
1、添加类PredicateExtensions.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Linq.Expressions;namespace Www24100Net.PlayingWithLinq{  public static class
Linq语法之Where语句
TxNet
02-03 693
Where运算符（Linq扩展方法）基于给定的条件表达式过滤集合并返回新集合。可以将标准指定为lambda表达式或Func委托类型。Where扩展方法有以下两个重载。两种重载方法都接受Func委托类型参数。一个重载需要Func 输入参数，第二个重载方法需要Func 输入参数，其中int用于索引：你也可以通过Where()方法的重载调用任何与Func形参匹配的方法。示例：Where子句。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值