3

我正在编写一组 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);
}

这有什么危险吗？

4

2 回答 2

2

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

于 2012-10-29T16:38:22.360 回答
1

答案取决于您的使用情况：如果您不介意将数据集放入内存以执行查询，那么只保留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>availalbe 执行得更差，因为所有销售订单将在确定它们的可见性之前一个接一个地检索到内存中，而不是检查服务器端的条件。如果按用户 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);
}
于 2012-10-29T16:39:40.633 回答