使用List<T>.Contains方法为LINQ构建表达式树

Question

问题

我正在重构我们 Web 应用程序中几个报表的一些 LINQ 查询，并尝试将一些重复的查询谓词移动到它们自己的 IQueryable 扩展方法中，以便我们可以在这些报表和未来的报表中重用它们。正如您可能推断的那样，我已经重构了组的谓词，但代码的谓词给我带来了问题。这是我目前拥有的一个报告方法的示例：

DAL 方法：

public List<Entities.QueryView> GetQueryView(Filter filter)
{
    using (var context = CreateObjectContext())
    {
        return (from o in context.QueryViews
                    where (!filter.FromDate.HasValue || o.RepairDate >= EntityFunctions.TruncateTime(filter.FromDate))
                    && (!filter.ToDate.HasValue || o.RepairDate <= EntityFunctions.TruncateTime(filter.ToDate))
                    select o)
                .WithCode(filter)
                .InGroup(filter)
                .ToList();
    }
}

IQueryable扩展：

public static IQueryable<T> WithCode<T>(this IQueryable<T> query, Filter filter)
{
    List<string> codes = DAL.GetCodesByCategory(filter.CodeCategories);

    if (codes.Count > 0)
        return query.Where(Predicates.FilterByCode<T>(codes));

    return query;
}

谓词：

public static Expression<Func<T, List<string>, bool>> FilterByCode<T>(List<string> codes)
{
    // Method info for List<string>.Contains(code).
    var methodInfo = typeof(List<string>).GetMethod("Contains", new Type[] { typeof(string) });

    // List of codes to call .Contains() against.
    var instance = Expression.Variable(typeof(List<string>), "codes");

    var param = Expression.Parameter(typeof(T), "j");
    var left = Expression.Property(param, "Code");
    var expr = Expression.Call(instance, methodInfo, Expression.Property(param, "Code"));

    // j => codes.Contains(j.Code)
    return Expression.Lambda<Func<T, List<string>, bool>>(expr, new ParameterExpression[] { param, instance });
}

我遇到的问题是Queryable.Where不接受类型为Expression<Func<T，List<string>, bool>的参数。我能想到的动态创建这个谓词的唯一方法是使用两个参数，而这正是困扰我的部分。

我没有理解的是以下方法的工作原理。我可以传递我正在尝试动态创建的精确lambda表达式，并且它可以正确地过滤我的数据。

public List<Entities.QueryView> GetQueryView(Filter filter)
{
    // Get the codes here.
    List<string> codes = DAL.GetCodesByCategory(filter.CodeCategories);

    using (var context = CreateObjectContext())
    {
        return (from o in context.QueryViews
                    where (!filter.FromDate.HasValue || o.RepairDate >= EntityFunctions.TruncateTime(filter.FromDate))
                    && (!filter.ToDate.HasValue || o.RepairDate <= EntityFunctions.TruncateTime(filter.ToDate))
                    select o)
                .Where(p => codes.Contains(p.Code)) // This works fine.
                //.WithCode(filter)
                .InGroup(filter)
                .ToList();

        }

    }

问题

1. 我能否实现自己的Queryable.Where重载？如果可以，是否可行？
2. 如果不可行，则有没有一种方法可以动态构造谓词p => codes.Contains(p.Code)而不使用两个参数？
3. 有更简单的方法吗？我感觉我漏掉了什么。

- Garrett Bates

Answer 1

1. You can create your own extension method, name it Where, accept an IQueryable<T>, return an IQueryable<T>, and otherwise make it emulate the form of LINQ methods. It wouldn't be a LINQ method, but it would look like one. I would discourage you from writing such a method simply because it would likely confuse others; even if you want to make a new extension method, use a name not used in LINQ to avoid confusion. In short, do what you're doing now, create new extensions without actually naming them Where. If you really wanted to name one Where though nothing's stopping you.

2. Sure, just use a lambda:

   public static Expression<Func<T, bool>> FilterByCode<T>(List<string> codes)
       where T : ICoded //some interface with a `Code` field
   {
       return p => codes.Contains(p.Code);
   }
   

   If you really cannot have your entities implement an interface (hint: you almost certainly can), then the code would look identical to the code that you have, but using the list that you pass in as a constant rather than a new parameter:

   public static Expression<Func<T, bool>> FilterByCode<T>(List<string> codes)
   {
       var methodInfo = typeof(List<string>).GetMethod("Contains", 
           new Type[] { typeof(string) });
   
       var list = Expression.Constant(codes);
   
       var param = Expression.Parameter(typeof(T), "j");
       var value = Expression.Property(param, "Code");
       var body = Expression.Call(list, methodInfo, value);
   
       // j => codes.Contains(j.Code)
       return Expression.Lambda<Func<T, bool>>(body, param);
   }
   

   I would strongly encourage use of the former method; this method loses static type safety, and is more complex and as such harder to maintain.

   Another note, the comment you have in your code: // j => codes.Contains(j.Code) isn't accurate. What that lambda actually looks like is: (j, codes) => codes.Contains(j.Code); which is actually noticeably different.

3. See the first half of #2.

- Servy

---

太好了！这非常有帮助。我为“QueryView”实体创建了一个接口，并将其用作我的扩展方法的类型约束，一切都正常工作。感谢您的帮助。 - Garrett Bates