第一种方法：

public static class PredicateExtensions    {        public static Expression
     
      
       > True
       
        () { return f => true; }        public static Expression
        
         
          > False
          
           () { return f => false; } public static Expression
           
            
             > Or
             
              (this Expression
              
               
                > expression1, Expression
                
                 
                  > expression2) { var invokedExpression = Expression.Invoke(expression2, expression1.Parameters .Cast
                  
                   ()); return Expression.Lambda
                   
                    
                     >(Expression.Or(expression1.Body, invokedExpression), expression1.Parameters); } public static Expression
                     
                      
                       > And
                       
                        (this Expression
                        
                         
                          > expression1, Expression
                          
                           
                            > expression2) { var invokedExpression = Expression.Invoke(expression2, expression1.Parameters .Cast
                            
                             ()); return Expression.Lambda
                             
                              
                               >(Expression.And(expression1.Body, invokedExpression), expression1.Parameters); } }
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     

第二种方法：

public static class PredicateBuilder    {        public static Expression
     
      
       > True
       
        () { return f => true; }        public static Expression
        
         
          > False
          
           () { return f => false; } public static Expression
           
             Compose
            
             (this Expression
             
               first, Expression
              
                second, Func
               
                 merge) { // build parameter 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 parameters from the first var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body); // apply composition of lambda expression bodies to parameters from the first expression return Expression.Lambda
                
                 (merge(first.Body, secondBody), first.Parameters); } public static Expression
                 
                  
                   > And
                   
                    (this Expression
                    
                     
                      > first, Expression
                      
                       
                        > second) { return first.Compose(second, Expression.And); } public static Expression
                        
                         
                          > Or
                          
                           (this Expression
                           
                            
                             > first, Expression
                             
                              
                               > second) { return first.Compose(second, Expression.Or); } } public class ParameterRebinder : ExpressionVisitor { private readonly Dictionary
                               
                                 map; public ParameterRebinder(Dictionary
                                
                                  map) { this.map = map ?? new Dictionary
                                 
                                  (); } public static Expression ReplaceParameters(Dictionary
                                  
                                    map, Expression exp) { return new ParameterRebinder(map).Visit(exp); } protected override Expression VisitParameter(ParameterExpression p) { ParameterExpression replacement; if (map.TryGetValue(p, out replacement)) { p = replacement; } return base.VisitParameter(p); } }
                                  
                                 
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     

 

注意，经我实际应用，发现第一种方法PredicateExtensions类有个缺陷，就是仅适合在DbDataContext中使用，若用在EntityContext中，则会报错：LINQ to Entities 不支持 LINQ 表达式节点类型“Invoke”。而使用第二种方法则不会有这个问题，至于问题的根源我还没有找到原因，还望高手指教，谢谢！