C# Linq到对象谓词生成器

使用LINQtoObject（而不是LINQtoSQL）执行条件查询的最佳方法是什么

目前我正在使用这里找到的谓词生成器 并将编译后的谓词传递给IEnumerable.Where和它似乎工作得很好

我想解决的问题的示例代码：

我有这个

 string keyword1 = "Test1";
 string keyword2 = "Test3";

        IEnumerable<TestObject> tests = new List<TestObject>()
                                     {
                                         new TestObject() {Name1 = "Test1", Name2 = "Test1"},
                                         new TestObject() {Name1 = "Test2", Name2 = "Test2"},
                                         new TestObject() {Name1 = "Test3", Name2 = "Test3"},

                                     };

        if (!String.IsNullOrEmpty(keyword1) && String.IsNullOrEmpty(keyword2))
            tests = tests.Where(e => e.Name1.Contains(keyword1));
        else if (!String.IsNullOrEmpty(keyword2) && !String.IsNullOrEmpty(keyword1))
            tests = tests.Where(e => e.Name2.Contains(keyword2) || e.Name1.Contains(keyword1));

        return tests.ToList();

string关键字1=“Test1”；
string关键字2=“Test3”；
IEnumerable tests=新列表（）
{
新建TestObject（）{Name1=“Test1”，Name2=“Test1”}，
新建TestObject（）{Name1=“Test2”，Name2=“Test2”}，
新建TestObject（）{Name1=“Test3”，Name2=“Test3”}，
};
if（！String.IsNullOrEmpty（关键字1）和&String.IsNullOrEmpty（关键字2））
tests=tests.Where（e=>e.Name1.Contains（关键字1））；
如果（！String.IsNullOrEmpty（关键字2）和&！String.IsNullOrEmpty（关键字1））为else
测试=测试。其中（e=>e.Name2.Contains（关键字2）| | e.Name1.Contains（关键字1））；
返回测试。ToList（）；

只需更改

PredicateBuilder

以使用委托而不是表达式树，并使用lambdas生成结果：

public static class DelegatePredicateBuilder
{
  public static Func<T, bool> True<T>()  { return f => true;  }
  public static Func<T, bool> False<T>() { return f => false; }

  public static Func<T, bool> Or<T>(this Func<T, bool> expr1,
                                     Func<T, bool> expr2)
  {
      return t => expr1(t) || expr2(t);
  }

  public static Func<T, bool> And<T>(this Func<T, bool> expr1,
                                     Func<T, bool> expr2)
  {
      return t => expr1(t) && expr2(t);
  }
}

公共静态类DelegatePredicateBuilder
{
public static Func True（）{return f=>True；}
public static Func False（）{return f=>False；}
公共静态函数或（此函数expr1，
Func expr2）
{
返回t=>expr1（t）| | expr2（t）；
}
公共静态函数和（此函数expr1，
Func expr2）
{
返回t=>expr1（t）和&expr2（t）；
}
}

这很管用，谢谢Jon，像这样构建查询与手动使用长if语句相比，是否会导致性能问题