C#：重载具有不同类型参数的 LINQ 泛型方法

Question

我正在编写一组 LINQ 2 SQL 扩展方法。现在，我有一堆重复的方法，一个在 IEnumerable 集合上工作，另一个在 IQueryable 集合上工作。例如

public static IQueryable<X> LimitVisible(this IQueryable<X> items) {
    return items.Where(x => !x.Hidden && !x.Parent.Hidden);
}

public static IEnumerable<X> LimitVisible(this IEnumerable<X> items) {
    return items.Where(x => !x.Hidden && !x.Parent.Hidden);
}

我认为我需要这种重复，因为我希望能够在某些情况下保留 IQueryable 行为，以便将执行推迟到数据库。 这是一个正确的假设，还是单个 IEnumerable 方法（加上将输出转换为 IQueryable）有效？如果我确实需要两者，我不喜欢重复，所以我想将两者结合使用泛型方法

public static T LimitVisible<T>(this T items) where T : IEnumerable<X> {
    return (T)items.Where(x => !x.Hidden && !x.Parent.Hidden);
}

除了我还想为其编写 LimitVisible 函数的 X 以外的其他类型（比如 Y 和 Z）之外，这是可行的。但我不会写

public static T LimitVisible<T>(this T items) where T : IEnumerable<Y> {
    return (T)items.Where(y => !y.Hidden && !y.Parent.Hidden);
}

因为你可以基于泛型重载。我可以将这些方法放在不同的类中，但这似乎不是正确的解决方案。

有什么建议吗？也许我做出了不正确的假设，并且首先不需要 IQueryable 特定版本。

编辑：另一个选项

这是我过去用来避免重复的另一种模式

private static readonly Expression<Func<X, bool>> F = x => !x.Hidden && !x.Parent.Hidden;

public static IEnumerable<X> LimitVisible(this IEnumerable<X> e) {
    return e.Select(W.Compile());
}

public static IQueryable<X> LimitVisible(this IQueryable<X> q) {
    return q.Select(W);
}

这样做有什么危险吗？

Answer 1

真的没有什么好办法解决两种方法。 IQueryable Where 将Expression<Func<T,bool>> 作为参数，而IEnumerable 将Func<T,bool> 作为参数。由于 lambdas 的魔力，调用者的代码看起来相同，但编译器实际上对这两个不同的代码位做了截然不同的事情。

Answer 2

答案取决于您的使用情况：如果您不介意将数据集放入内存以执行查询，那么只保留 IEnumerable<T> 覆盖即可。

但是，此决定的必然结果是，在您使用 LimitVisible<T> 的那一刻，您的查询将被强制存入内存。这可能是也可能不是您想要的，并且可能会迫使您进入您宁愿避免的编码模式。例如，

var firstHundred = ctx
    .SalesOrders
    .LimitVisible()                     // Happens in memory
    .Where(ord => ord.UserId == myUser) // Also happens in memory
    .Take(100);

使用单个 IEnumerable<T> 会比使用 IQueryable<T> 覆盖可用性差很多，因为在确定其可见性之前，所有销售订单将被一一检索到内存中，而不是而不是检查服务器端的条件。如果按用户 ID 过滤可以消除服务器端的大部分销售订单，那么这个等效查询的性能差异可能会好几个数量级：

var firstHundred = ctx
    .SalesOrders
    .Where(ord => ord.UserId == myUser) // Happens in RDBMS
    .LimitVisible()                     // Happens in memory
    .Take(100);

如果您打算只自己使用代码，并且不介意在没有明显原因的情况下出现性能不佳的情况，您可以保留一个过载。如果您打算让其他人使用您的库，我强烈建议保留这两个覆盖。

编辑：为了加快您的替代实现，预编译您的表达式，如下所示：

private static readonly Expression<Func<X, bool>> F = x => !x.Hidden && !x.Parent.Hidden;
private static readonly Predicate<X> CompiledF = (Predicate<X>)F.Compile();

public static IEnumerable<X> LimitVisible(this IEnumerable<X> e) {
    return e.Select(CompiledF);
}

public static IQueryable<X> LimitVisible(this IQueryable<X> q) {
    return q.Select(F);
}