Как использовать LINQ для исключения вложенных циклов?

Ответ 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;

Гораздо более кратким и менее подверженным ошибкам.

Ответ 2

Здесь тип вложенного цикла, который вы можете удалить с помощью Linq.

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

Его можно преобразовать в:

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

Используя метод расширения SelectMany на IEnumerable.

Одно место, где это весьма полезно, - это сценарии двойного разрыва вложенных циклов.

Ответ 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();

Ответ 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)));

Ответ 5

Наиболее полезные примеры: когда вы можете использовать встроенные методы в LINQ, например All и Any. Вот так:

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

Запишите это с циклом for с переменными if и break и bool check, я думаю, что это будет по крайней мере пять строк кода, чтобы сделать то же самое. Хмм, давайте посмотрим:

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

ooops, 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, чтобы получить такое же ленивое поведение оценки.