Исполняемые доки C#: Цикл foreach

Q: Как перебрать Dictionary через foreach в C#?

Каждый элемент это KeyValuePair : foreach (var pair in prices) Console.WriteLine($"{pair.Key}: {pair.Value}");. В .NET Core 2.0 и новее пару можно деконструировать: foreach (var (name, price) in prices). Чтобы перебрать только ключи или значения, используйте prices.Keys или prices.Values.

Q: Как получить индекс в цикле foreach в C#?

Встроенного индекса у foreach нет. Заведите счётчик (int i = 0; перед циклом, i++ в конце тела) или спроецируйте каждый элемент вместе с индексом через LINQ: foreach (var item in names.Select((name, index) => new { name, index })). Если индекс нужен, чтобы записывать обратно или сравнивать соседей, лучше подходит цикл for.

Q: Что означает «Collection was modified; enumeration operation may not execute»?

Вы добавили или удалили элементы в List, Dictionary или другой коллекции, пока foreach её перебирал. Перечислитель обнаруживает изменение и на следующем шаге выбрасывает InvalidOperationException. Перебирайте копию (foreach (var x in list.ToList())), собирайте изменения и применяйте их после цикла, используйте list.RemoveAll(...) или обратный цикл for.

Q: Почему нельзя присвоить значение переменной foreach в C#?

Переменная итерации доступна только для чтения: name = name.Trim(); внутри foreach (string name in names) это ошибка CS1656. Присваивание всё равно не изменило бы коллекцию. Чтобы заменить элементы, используйте цикл for с индексом или соберите новую коллекцию через Select. Изменять свойство объекта класса (order.Status = ...) можно.

Q: Можно ли выйти из цикла foreach в C#?

Да. break сразу завершает цикл, а continue переходит к следующему элементу, точно так же как в for и while. return выходит из всего метода. Метод List .ForEach устроен иначе: его тело это лямбда, поэтому break и continue там недоступны.

foreach выполняет своё тело по одному разу для каждого элемента коллекции, по порядку, без индекса, которым нужно управлять:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        string[] players = { "Ava", "Noah", "Mia" };
        foreach (string player in players)
        {
            Console.WriteLine($"Welcome, {player}");
        }

        var scores = new List<int> { 72, 88, 95 };
        int total = 0;
        foreach (int score in scores)
        {
            total += score;
        }
        Console.WriteLine($"Total: {total}");

        foreach (char c in "C#7")
        {
            Console.Write($"[{c}]");
        }
        Console.WriteLine();
    }
}

Вывод:

Welcome, Ava
Welcome, Noah
Welcome, Mia
Total: 255
[C][#][7]

Цикл одинаково работает с массивом, List<T>, строкой (тип элемента char), HashSet<T>, запросом LINQ и любой другой последовательностью. В качестве объявленного типа можно указать var, что распространено, когда тип элемента длинный: foreach (var order in pendingOrders).

Что foreach делает за кулисами

foreach запрашивает у коллекции перечислитель и проходит по нему. Для List<int> компилятор превращает цикл примерно в следующее:

List<int>.Enumerator e = scores.GetEnumerator();
try
{
    while (e.MoveNext())
    {
        int score = e.Current;
        // loop body
    }
}
finally
{
    e.Dispose();
}

Отсюда три следствия. Подходит любой тип с открытым методом GetEnumerator(), который обычно появляется благодаря реализации IEnumerable<T>. Перечислитель освобождается, даже когда тело выбрасывает исключение или выполняет break. А переменная элемента на каждом проходе это новая копия e.Current, поэтому присваивание ей не может изменить коллекцию.

Тип без GetEnumerator использовать нельзя:

error CS1579: foreach statement cannot operate on variables of type 'Order' because 'Order' does not contain a public instance or extension definition for 'GetEnumerator'

Реализуйте для типа IEnumerable<T> или перебирайте коллекцию, которую он содержит (order.Lines вместо order). Собственные последовательности можно писать через yield return, это описано на странице об IEnumerable и yield.

Перебор словаря

Элементы словаря это значения KeyValuePair<TKey, TValue> со свойствами Key и Value:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var stock = new Dictionary<string, int>
        {
            ["apples"] = 12,
            ["pears"] = 0,
            ["kiwis"] = 30,
        };

        foreach (KeyValuePair<string, int> item in stock)
        {
            Console.WriteLine($"{item.Key}: {item.Value}");
        }

        foreach (string fruit in stock.Keys)
        {
            Console.Write($"<{fruit}>");
        }
        Console.WriteLine();

        Console.WriteLine($"Units in stock: {stock.Values.Sum()}");

        foreach (var item in stock.OrderByDescending(p => p.Value))
        {
            Console.WriteLine($"{item.Value,3} {item.Key}");
        }
    }
}

Вывод:

apples: 12
pears: 0
kiwis: 30
<apples><pears><kiwis>
Units in stock: 42
 30 kiwis
 12 apples
  0 pears

Dictionary не обещает никакого порядка перебора. На практике он следует порядку вставки, пока вы не удалите элементы, но код, который зависит от порядка, должен сортировать явно, как это делает последний цикл с OrderByDescending, или использовать SortedDictionary.

В .NET Core 2.0 и новее (и в любом современном .NET) у KeyValuePair есть метод Deconstruct, поэтому пару можно разделить на две переменные прямо в заголовке цикла:

// modern .NET: KeyValuePair deconstruction
foreach (var (fruit, count) in stock)
{
    Console.WriteLine($"{fruit}: {count}");
}

Это самая короткая форма, и именно её вы увидите в современном коде. Она не компилируется в .NET Framework, где у KeyValuePair нет Deconstruct; там используйте item.Key и item.Value.

Получение индекса

Собственного индекса у foreach нет. Два обычных способа получить его: счётчик, который вы ведёте сами, или перегрузка Select из LINQ, которая передаёт индекс вместе с каждым элементом:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string[] podium = { "Kenji", "Sofia", "Omar" };

        int place = 1;
        foreach (string name in podium)
        {
            Console.WriteLine($"{place}. {name}");
            place++;
        }

        foreach (var entry in podium.Select((name, index) => new { name, index }))
        {
            Console.WriteLine($"index {entry.index}: {entry.name}");
        }
    }
}

Вывод:

1. Kenji
2. Sofia
3. Omar
index 0: Kenji
index 1: Sofia
index 2: Omar

Счётчик самый дешёвый и понятный. Если вы используете индекс, чтобы читать podium[i - 1] или записывать podium[i] = ..., переходите на цикл for, который создан именно для этого.

Переменная цикла доступна только для чтения

Присваивать значение переменной итерации нельзя:

foreach (string name in names)
{
    name = name.Trim();
    // error CS1656: Cannot assign to 'name' because it is a 'foreach iteration variable'
}

Даже если бы это было разрешено, изменилась бы только локальная копия. Чтобы преобразовать каждый элемент, соберите новую последовательность (names.Select(n => n.Trim()).ToArray()) или используйте цикл for, который записывает names[i] = names[i].Trim().

Что можно сделать, зависит от того, является ли элемент классом или структурой. Для класса переменная хранит ссылку, поэтому изменение свойства меняет объект в коллекции:

using System;
using System.Collections.Generic;

class Order
{
    public int Id;
    public string Status;
}

class Program
{
    static void Main()
    {
        var orders = new List<Order>
        {
            new Order { Id = 1, Status = "paid" },
            new Order { Id = 2, Status = "paid" },
        };

        foreach (Order order in orders)
        {
            order.Status = "shipped";
        }

        foreach (Order order in orders)
        {
            Console.WriteLine($"Order {order.Id}: {order.Status}");
        }
    }
}

Вывод:

Order 1: shipped
Order 2: shipped

Если бы Order был struct, то же присваивание завершилось бы ошибкой CS1654 (Cannot modify members of 'order' because it is a 'foreach iteration variable'), потому что переменная это копия значения, а не ссылка на него.

Изменение коллекции: InvalidOperationException

Добавление или удаление элементов List или Dictionary, пока foreach их перебирает, ломает перечислитель. Следующий MoveNext выбрасывает InvalidOperationException с сообщением «Collection was modified; enumeration operation may not execute.»:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var cart = new List<string> { "milk", "expired yogurt", "bread", "expired ham" };

        try
        {
            foreach (string item in cart)
            {
                if (item.StartsWith("expired"))
                    cart.Remove(item);
            }
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine($"{e.GetType().Name}: collection was modified");
        }

        cart = new List<string> { "milk", "expired yogurt", "bread", "expired ham" };

        // Fix 1: loop over a copy
        foreach (string item in cart.ToList())
        {
            if (item.StartsWith("expired"))
                cart.Remove(item);
        }
        Console.WriteLine(string.Join(", ", cart));

        // Fix 2: let the collection do it
        var cart2 = new List<string> { "milk", "expired yogurt", "bread" };
        cart2.RemoveAll(item => item.StartsWith("expired"));
        Console.WriteLine(string.Join(", ", cart2));
    }
}

Вывод:

InvalidOperationException: collection was modified
milk, bread
milk, bread

Способы исправления, от самого простого к самому гибкому:

RemoveAll(predicate) у List<T> удаляет все совпадения за один проход.
Перебор копии через ToList() или ToArray(), после чего оригинал можно свободно менять.
Сначала собрать, потом применить: во время цикла складывайте ключи для удаления в отдельный список, а удаляйте их после. Это обычный приём для Dictionary.
Обратный цикл for с RemoveAt(i).

У Dictionary есть одно исключение, которое стоит знать. Начиная с .NET Core 3.0 перезапись значения существующего ключа (stock[key] = 0) или удаление элементов во время foreach по словарю больше не выбрасывает исключение, а добавление нового ключа по-прежнему выбрасывает. В .NET Framework все три действия выбрасывают исключение, поэтому вариант со сбором ключей работает везде.

break, continue и коллекции null

break и continue ведут себя так же, как в любом другом цикле:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] readings = { 21, -1, 23, 999, 22 };

        foreach (int r in readings)
        {
            if (r < 0) continue;          // skip sensor errors
            if (r == 999) break;          // end-of-data marker
            Console.WriteLine($"reading {r}");
        }

        List<string> tags = null;
        foreach (string tag in tags ?? Enumerable.Empty<string>())
        {
            Console.WriteLine(tag);
        }
        Console.WriteLine("no tags, no crash");
    }
}

Вывод:

reading 21
reading 23
no tags, no crash

Перебор коллекции null выбрасывает NullReferenceException при вызове GetEnumerator. ?? Enumerable.Empty<T>() превращает последовательность, которая может быть null, в пустую; а ещё лучше возвращать из собственных методов пустые коллекции вместо null.

foreach и List.ForEach

У List<T> есть метод ForEach(Action<T>): names.ForEach(n => Console.WriteLine(n));. Это не то же самое, что цикл. Его тело это лямбда, поэтому break, continue и yield недоступны, а return лишь завершает вызов для текущего элемента. Он есть только у List<T>, но не у массивов или других последовательностей. Предпочитайте оператор foreach; используйте ForEach только для однострочного действия, которое у вас уже есть в виде метода.

Часто задаваемые вопросы

Как перебрать Dictionary через foreach в C#?

Каждый элемент это KeyValuePair<TKey, TValue>: foreach (var pair in prices) Console.WriteLine($"{pair.Key}: {pair.Value}");. В .NET Core 2.0 и новее пару можно деконструировать: foreach (var (name, price) in prices). Чтобы перебрать только ключи или значения, используйте prices.Keys или prices.Values.

Как получить индекс в цикле foreach в C#?

Встроенного индекса у foreach нет. Заведите счётчик (int i = 0; перед циклом, i++ в конце тела) или спроецируйте каждый элемент вместе с индексом через LINQ: foreach (var item in names.Select((name, index) => new { name, index })). Если индекс нужен, чтобы записывать обратно или сравнивать соседей, лучше подходит цикл for.

Что означает «Collection was modified; enumeration operation may not execute»?

Вы добавили или удалили элементы в List, Dictionary или другой коллекции, пока foreach её перебирал. Перечислитель обнаруживает изменение и на следующем шаге выбрасывает InvalidOperationException. Перебирайте копию (foreach (var x in list.ToList())), собирайте изменения и применяйте их после цикла, используйте list.RemoveAll(...) или обратный цикл for.

Почему нельзя присвоить значение переменной foreach в C#?

Переменная итерации доступна только для чтения: name = name.Trim(); внутри foreach (string name in names) это ошибка CS1656. Присваивание всё равно не изменило бы коллекцию. Чтобы заменить элементы, используйте цикл for с индексом или соберите новую коллекцию через Select. Изменять свойство объекта класса (order.Status = ...) можно.

Можно ли выйти из цикла foreach в C#?

Да. break сразу завершает цикл, а continue переходит к следующему элементу, точно так же как в for и while. return выходит из всего метода. Метод List<T>.ForEach устроен иначе: его тело это лямбда, поэтому break и continue там недоступны.

Связанные концепции