6

如果我试图在IEnumerable<T>对象图的多个级别过滤结果，是否有链接扩展方法的首选方法来执行此操作？

我对任何扩展方法和 lambda 用法持开放态度，但我不希望使用 LINQ 语法来与代码库的其余部分保持一致。

将过滤推送到方法selector中SelectMany()还是仅仅链接另一个Where()方法更好？还是有更好的解决方案？

我将如何确定最佳选择？在这个测试用例中，一切都直接在内存中可用。显然，下面的两个样本目前都产生了相同的正确结果；我只是在寻找一个或另一个（或另一种选择）更受欢迎的原因。

public class Test
{
    // I want the first chapter of a book that's exactly 42 pages, written by
    // an author whose name is Adams, from a library in London.
    public Chapter TestingIEnumerableTExtensionMethods()
    {
        List<Library> libraries = GetLibraries();

        Chapter chapter = libraries
            .Where(lib => lib.City == "London")
            .SelectMany(lib => lib.Books)
            .Where(b => b.Author == "Adams")
            .SelectMany(b => b.Chapters)
            .First(c => c.NumberOfPages == 42);

        Chapter chapter2 = libraries
            .Where(lib => lib.City == "London")
            .SelectMany(lib => lib.Books.Where(b => b.Author == "Adams"))
            .SelectMany(b => b.Chapters.Where(c => c.NumberOfPages == 42))
            .First();
    }

这是示例对象图：

public class Library
{
    public string Name { get; set; }
    public string City { get; set; }
    public List<Book> Books { get; set; }
}

public class Book
{
    public string Name { get; set; }
    public string Author { get; set; }
    public List<Chapter> Chapters { get; set; }
}

public class Chapter
{
    public string Name { get; set; }
    public int NumberOfPages { get; set; }
}
4

4 回答 4

3

哪个最有可能根据您使用的 LINQ 实现而有所不同。LinqToSql 的行为与内存过滤不同。子句的顺序应该会影响性能，具体取决于使用的数据，因为幼稚的实现会在序列的前面过滤更多的记录，这意味着后面的方法的工作量会减少。

对于您的两个示例，我猜想性能差异可以忽略不计，并且会支持第一个示例，因为它允许更轻松地修改每个子句，而独立于其他子句。

至于确定最佳选择，它与其他任何事情一样：衡量。

于 2012-04-09T20:07:50.877 回答
2

我猜你的第一个表达方式会稍微快一点，但速度并不明显。要真正确定其中一个是否更快，您需要使用分析器或秒表对它们进行计时。

无论哪种方式，可读性似乎都没有受到强烈影响。我更喜欢第一种方法，因为它的嵌套级别更少。这完全取决于您的个人喜好。

于 2012-04-09T20:06:39.970 回答
1

这取决于底层 LINQ 提供程序的工作方式。对于 LINQ to Objects，在这种情况下，两者都需要大约相同数量的工作，或多或少。但这是最直接（最简单）的例子，除此之外很难说。

于 2012-04-09T20:06:23.357 回答
0

这可能会给你一个不同的角度，虽然这更多的是风格问题......
我有时会发现自己在做这样的事情...... 

return libraries.Filter(
        l => l.City == "",
        l => l.Books,
        b => b.Author == "Adams",
        b => b.Chapters,
        c => c.NumberOfPages == 42
        );

...在那里您可以猜到扩展名是什么，例如...

public static IEnumerable<TC> Filter<TL, TB, TC>(this IEnumerable<TL> list,
    Func<TL, bool> whereLs,
    Func<TL, IEnumerable<TB>> selectBs,
    Func<TB, bool> whereBs,
    Func<TB, IEnumerable<TC>> selectCs,
    Func<TC, bool> whereCs
    )
{
    return list
        .Where(whereLs)
        .SelectMany(selectBs)
        .Where(whereBs)
        .SelectMany(selectCs)
        .Where(whereCs);
}

...或者....

...    
{
    return list
        .Where(whereLs)
        .SelectMany(l => selectBs(l).Where(whereBs))
        .SelectMany(b => selectCs(b).Where(whereCs));
}

组合/选项很多，具体取决于您拥有什么，您“喜欢如何拥有您的代码”（更多抽象或“捕获”、“参数化”PerCityAuthorPages(_city, _author, _numPages);等）

...基本上，我不喜欢拥有所有的'Where'，'Select'-s等，对我来说不是那么可读（或者）。虽然使用“短形式”，但很清楚哪个是哪个，在哪里，选择等，而且它非常“速记”，而且字符少得多。

此外，您可以推迟关于 Where/Select 组合的决定以供以后使用（根据需要，提供者做一个或另一个）

@Telastyn 是非常正确的，LINQ 提供程序，例如，如果您查看一些实现代码，
所有表达式都减少等。
它们是非常不确定的（即从提供程序到提供程序），
尽管它们最终可能会映射到例如 SQL这在我认为的大多数情况下应该是相同的。

于 2012-04-09T23:23:28.293 回答