将 Where 从 LINQ 子句转换为动态 LINQ

Question

我想离开

        var selectData = (from i in data
                          where i.Name == "Bob1"
                          select i);

到

        var selectData = (from i in data
                          select i).Where("Name==Bob1");

我尝试了各种方法（AsQueryable、Where<SomeData>），但无法编译第二种形式。

我不太了解 C# 的通用扩展方法。 <Tsource> 对我来说没有意义，所以这可能是问题所在。另外，我不明白为什么当智能感知只显示.Where<>（通用）时我可以输入.Where()。我希望看到第二个 Where 没有通用符号...唉，我没有。

类

public class SomeData
{
    public string Name { get; set; }
    public string Address { get; set; }
}

更新
关于如何使用 Where() 似乎有些困惑，这很可能是我的错。请参阅related 问题。根据这个答案，where 子句中的属性名称是完全合法的。我需要该属性保持为字符串。如果这意味着需要动态 LINQ，那就这样吧……这就是我所需要的。

Answer 1

var selectData = (from i in data
                  select i).Where(datum => datum.Name == "Bob1");

Where 方法采用委托，而不是字符串，因此您需要传入委托或 lambda。

编辑：根据您对其他答案之一的评论，您将需要使用反射来动态查找属性值。

编辑：看起来您需要为 Dynamic Linq 库单独 download the source code。

Answer 2

在您的帮助下，我成功地实现了功能转换。

1. 安装 Dynamic LINQ（我使用的是 NUGET。在线搜索 System.Linq.Dynamic）
2. 添加using System.Linq.Dynamic

3. 查询应该是格式

       var selectData = (from i in data
                         select i).AsQueryable().Where("Name = @0","Bob1");//@0 is called an identifier.  "Name = Bob1" straight up fails.
   

4. 安装 ScottGU 的 C# sample library...它会有所帮助。 (VB) (Original Post)

Answer 3

更新

我最初误解了这个问题；解决问题的方法是下载 Dynamic Linq 并引用它。我将在下面留下我的答案，它解决了您提出的有关通用扩展方法的附带问题。

---

var selectData = (from i in data 
    select i).Where(d => d.Name=="Bob1");

但为什么不这样：

var selectData = data.Where(d => d.Name=="Bob1");

关于 where 的“非通用”版本，没有这样的东西。在上面的调用中，泛型方法的类型参数是隐式的；它是由编译器推断出来的，它编译调用的方式与编译它的方式完全相同：

var selectData = data.Where<SomeData>(d => d.Name=="Bob1");

也许Where 方法的草图实现将有助于减少您对TSource 参数的混淆：

public static IEnumerable<TSource> Where(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    foreach (TSource item in source)
        if (predicate(item))
            yield return item;
}

TSource 是您要查询的序列的元素类型。也是结果序列的元素类型。

编译器需要知道类型至少有两个原因：

首先，我们需要对每个元素调用一个函数来确定是否将其包含在结果序列中。编译器必须知道 predicate 参数的引用对象可以安全地接受 TSource 类型的参数。

在这种情况下，第二个原因有些微不足道； item 的赋值必须与 TSource 兼容，因为它在 yield return 语句中使用。当然是兼容的，因为是同一类型的。

Answer 4

我相信这就是您正在寻找的：

http://www.albahari.com/nutshell/predicatebuilder.aspx

例子

IQueryable<Product> SearchProducts (params string[] keywords)
{
  var predicate = PredicateBuilder.False<Product>();

  foreach (string keyword in keywords)
  {
    string temp = keyword;
    predicate = predicate.Or (p => p.Description.Contains (temp));
  }
  return dataContext.Products.Where (predicate);
}

源代码

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Collections.Generic;

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

  public static Expression<Func<T, bool>> Or<T> (this Expression<Func<T, bool>> expr1,
                                                      Expression<Func<T, bool>> expr2)
  {
    var invokedExpr = Expression.Invoke (expr2, expr1.Parameters.Cast<Expression> ());
    return Expression.Lambda<Func<T, bool>>
          (Expression.OrElse (expr1.Body, invokedExpr), expr1.Parameters);
  }

  public static Expression<Func<T, bool>> And<T> (this Expression<Func<T, bool>> expr1,
                                                       Expression<Func<T, bool>> expr2)
  {
    var invokedExpr = Expression.Invoke (expr2, expr1.Parameters.Cast<Expression> ());
    return Expression.Lambda<Func<T, bool>>
          (Expression.AndAlso (expr1.Body, invokedExpr), expr1.Parameters);
  }
}

Answer 5

这里有一些简单的代码，使用表达式树来做你想做的事。这仅适用于针对该特定类型的 Property == "..." 查询。你当然可以修改它，让它变得像你需要的那样通用。

    public void Test()
    {
        List<SomeData> data = new List<SomeData>();
        data.Add(new SomeData("Mark", "Ledgewood Drive"));
        data.Add(new SomeData("Tim", "Sumpter Drive"));
        data.Add(new SomeData("Sean", "Leroy Drive"));
        data.Add(new SomeData("Bob", "Wilmington Road"));
        data.Add(new SomeData("Sean", "Sunset Blvd"));

        List<SomeData> result = data.Where(BuildExpression("Name", "Mark")).ToList();
        List<SomeData> result2 = data.Where(BuildExpression("Address", "Wilmington Road")).ToList();
    }

    private Func<SomeData, bool> BuildExpression(string propertyName, string value)
    {
        ParameterExpression pe = Expression.Parameter(typeof(SomeData), "someData");
        Expression left = Expression.Property(pe, propertyName);
        Expression right = Expression.Constant(value);
        BinaryExpression binary = Expression.Equal(left, right);
        Expression<Func<SomeData, bool>> lambda = Expression.Lambda<Func<SomeData, bool>>(binary, pe);
        return lambda.Compile();
    }