如何使用 LINQ 避免嵌套循环？

Question

我一直在阅读有关 LINQ to Objects 的内容，现在我的同事希望我将其介绍给他们。

现在，我对运算符和语法选择有了很好的了解，但我听说您可以通过使用 LINQ避免繁重的嵌套循环。不过，我很难想出一组好的“之前和之后”代码清单来证明这一点。

我在 Magennis 的书中找到了一个使用和不使用 LINQ 进行排序和分组的好例子，他也有一个编写 xml 的例子。但是那些嵌套循环呢？考虑到我们通常需要一个或两个 foreach 循环来遍历查询的结果，这甚至是一个现实的说法吗？

如果有人能向我解释这个想法（最好有具体的例子），我将不胜感激。

Answer 1

假设您有很多产品，例如：

var products = new List<Product>
    {
        new Product { Id = 1, Category = "Electronics", Value = 15.0 },
        // etc.
    };

如果您想查找价值 > 100.0 美元的所有产品，按类别分组，您可以使用foreach：

var results = new Dictionary<string, List<Product>>();

foreach (var p in products)
{
    if (p.value > 100.0)
    {
        List<Product> productsByGroup;

        if (!results.TryGetValue(p.Category, out productsByGroup))
        {
            productsByGroup = new List<Product>();
            results.Add(p.Category, productsByGroup);
        }
        productsByGroup.Add(p);
    }
}

或者，您可以简单地使用 LINQ 方法：

var results = products.Where(prod => prod.Value > 100.0)
                  .GroupBy(prod => prod.Category);

或者使用 LINQ 表达式语法：

var results = from p in products 
                  where p.Value > 100.0
                  group p by p.Category;

更简洁，更不容易出错。

Answer 2

这是一种可以使用 Linq 删除的嵌套循环。

foreach(SomeClass item in Items)
{
    foreach(SomeOtherClass subItem in item.SubItems)
    {
        // ...
    }
}

可以变成：

foreach(SomeOtherClass subItem in Items.SelectMany(i => i.SubItems))
{
}

使用the SelectMany extension method on IEnumerable。

一个非常有用的地方是nested loop double-break scenarios。

Answer 3

var results = new List<Object>();
foreach(var i in list)
{
    if (i.property == value)
    {
         foreach(var j in list.SubList)
         {
              if (j.other == something)
              {
                  results.push(j);
              }
         }
    }
}

可能是：

var results = list.Where(i => i == value)
                  .SelectMany(i => i.SubList)
                  .Where(j => j.other == something)
                  .ToList();

Answer 4

这是一个有些人为的例子。

假设给你一个字符串列表，你的任务是在 HashSet<> 中查找并返回在这些字符串中找到的所有控制字符。

var listOStrings = new List<string> { ... };
var result = new HashSet<char>();

你可以这样做：

foreach (var str in listOStrings)
{
    foreach (var c in str)
    {
        if (Char.IsControl(c))
        {
            result.Add(c);
        }
    }
}

或者使用 LINQ：

result = new HashSet<char>(
    listOStrings
        .SelectMany(str => str.Where(Char.IsControl)));

Answer 5

最有用的示例是您可以使用 LINQ 中的内置方法，例如 All 和 Any。像这样：

bool hasCats = listOfAnimals.Any(animal => animal.Type == "Cat");

用带有 if 和 break 的 for 循环和一个 bool 检查变量来编写它，我想这至少需要五行代码来做同样的事情。嗯，让我们看看：

bool hasCats = false;
foreach(Animal animal in listOfAnimals)
{
    if (animal.Type == "Cat")
    {
        hasCats = true;
        break;
    }
}

糟糕，9 行。而且你需要至少仔细阅读其中的三个才能知道代码的作用。

嗯，差不多。假设哺乳动物有一个真实的类型层次结构。

IEnumerable<Cat> allCats = listOfAnimals.OfType<Cat>();

这会返回所有可以被铸造成Cat 的动物并返回它们，铸造并准备好使用。用循环写：

List<Cat> allCats = new List<Cat>();
foreach(var animal in listOfAnimals)
{
    var cat = animal as Cat;
    if (cat != null)
    {
        allCats.Add(cat);
    }
}

说实话，您应该将其分解为一个单独的方法并使用 yield return cat; 来获得与 LINQ 版本相同的惰性行为。

但我更喜欢查询语法。阅读起来很流畅，而且噪音很小。

var cats = 
    from cat in listOfCats
    where cat.Age > 5
    where cat.Color == "White"
    select cat;

用普通循环编写

List<Cat> cats = new List<Cat>();
foreach(Cat cat in listOfCats)
{
    if (cat.Age > 5)
    {
        if (cat.Color == "White")
        {
            cats.Add(cat);
        }
    }
}

同样需要使用 yield return 的单独方法来获得相同的惰性求值行为。