很多情况下，我们开发程序，需要动态拼接SQL查询语句;

比如  select top 1 * from User where age= 18  and  name = 'renruiquan'

其中红色的代码，是我们需要根据查询条件是否为空，来判，要不要加在查询的SQL里;

换成Linq里就不能这么直接的去拼接了，好在国外的大神有给我们解决方案。下面直接上代码：

（新手同学不需要关心代码具体是怎么实现的，只需要知道怎么调用就好。当然，你能研究一下，给自己充电，也是再好不过了）

using System;using System.Collections.Generic;using System.Collections.ObjectModel;using System.Linq;using System.Linq.Expressions;using System.Reflection;using System.Text;using System.Threading.Tasks;namespace JQ.GameClient.Common{    /// 
    /// Enables the efficient, dynamic composition of query predicates.    /// 
    public static class PredicateBuilder    {        /// 
        /// Creates a predicate that evaluates to true.        /// 
        public static Expression
     
      
       > True
       
        () { return param => true; }        /// 
        
        /// Creates a predicate that evaluates to false.        /// 
        public static Expression
        
         
          > False
          
           () { return param => false; } /// 
           
 /// Creates a predicate expression from the specified lambda expression. /// 
 public static Expression
           
            
             > Create
             
              (Expression
              
               
                > predicate) { return predicate; } /// 
                
 /// Combines the first predicate with the second using the logical "and". /// 
 public static Expression
                
                 
                  > And
                  
                   (this Expression
                   
                    
                     > first, Expression
                     
                      
                       > second) { return first.Compose(second, Expression.AndAlso); } /// 
                       
 /// Combines the first predicate with the second using the logical "or". /// 
 public static Expression
                       
                        
                         > Or
                         
                          (this Expression
                          
                           
                            > first, Expression
                            
                             
                              > second) { return first.Compose(second, Expression.OrElse); } /// 
                              
 /// Negates the predicate. /// 
 public static Expression
                              
                               
                                > Not
                                
                                 (this Expression
                                 
                                  
                                   > expression) { var negated = Expression.Not(expression.Body); return Expression.Lambda
                                   
                                    
                                     >(negated, expression.Parameters); } /// 
                                     
 /// Combines the first expression with the second using the specified merge function. /// 
 static Expression
                                     
                                       Compose
                                      
                                       (this Expression
                                       
                                         first, Expression
                                        
                                          second, Func
                                         
                                           merge) { // zip parameters (map from parameters of second to parameters of first) var map = first.Parameters .Select((f, i) => new { f, s = second.Parameters[i] }) .ToDictionary(p => p.s, p => p.f); // replace parameters in the second lambda expression with the parameters in the first var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body); // create a merged lambda expression with parameters from the first expression return Expression.Lambda
                                          
                                           (merge(first.Body, secondBody), first.Parameters); } /// 
                                           
 /// ParameterRebinder /// 
 class ParameterRebinder : ExpressionVisitor { /// 
                                           
 /// The ParameterExpression map /// 
 readonly Dictionary
                                           
                                             map; /// 
                                            
 /// Initializes a new instance of the 
                                              class. /// 
 /// 
                                            The map. ParameterRebinder(Dictionary
                                            
                                              map) { this.map = map ?? new Dictionary
                                             
                                              (); } /// 
                                              
 /// Replaces the parameters. /// 
 /// 
                                              The map. /// 
                                              The exp. /// 
                                              
                                               Expression
                                               public static Expression ReplaceParameters(Dictionary
                                              
                                                map, Expression exp) { return new ParameterRebinder(map).Visit(exp); } /// 
                                               
 /// Visits the parameter. /// 
 /// 
                                               The p. /// 
                                               
                                                Expression
                                                protected override Expression VisitParameter(ParameterExpression p) { ParameterExpression replacement; if (map.TryGetValue(p, out replacement)) { p = replacement; } return base.VisitParameter(p); } } }}
                                              
                                             
                                            
                                           
                                          
                                         
                                        
                                       
                                      
                                     
                                    
                                   
                                  
                                 
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     

代码调用：

//动态构造查询条件            var predicate = PredicateBuilder.True
     
      ();　　　　　　　//查询用户状态为1的数据            predicate = predicate.And(x => x.status == 1);            if (!string.IsNullOrEmpty(name))            {
    　　　　　　　　　//如果查询的用户名不为空，则拼接表达式                predicate = predicate.And(x => x.name == name);            }            var list = bll.GetList
      
       (predicate,o=>o.orderno);
      
     

其中UserInfo为用户表的实体类。

list即为查询的结果。