Захват переменных в циклах и замыканиях C#

Обновлено: 31.10.2026 · 2 мин чтения

Что такое захваченная переменная?

Захваченная переменная - это термин, который описывает переменную, использованную в анонимной функции, такой как лямбда-выражение или делегат, который ссылается на переменную, определенную во внешней области видимости. Когда анонимная функция захватывает переменную из внешней области, она сохраняет свою связь с этой переменной даже после выхода из области, в которой эта переменная была определена.

int number = 10;
Func<int> getNumber = () => number;
number = 20;
Console.WriteLine(getNumber()); // Выведет 20, так как 'number' была захвачена лямбда-выражением

Как работает захват переменных в циклах?

В контексте циклов, особенно важно понимать захват переменных, так как он может привести к неожиданным результатам. Рассмотрим классический пример с циклом for:

List<Func<int>> actions = new List<Func<int>>();
for (int i = 0; i < 3; i++)
{
    actions.Add(() => i);
}

foreach (var action in actions)
{
    Console.WriteLine(action()); // Выведет '3' три раза, а не 0, 1, 2
}

В этом примере переменная i захвачена лямбда-выражением и сохраняет ссылку на одно и то же место в памяти для всех трех лямбда-выражений. Когда i изменяется в цикле, все лямбда-выражения “видят” последнее значение i, которое равно 3 после завершения цикла.

Избегаем ошибок с захваченными переменными

Для того чтобы избежать ошибок, связанных с захваченными переменными, можно использовать разные подходы. Один из способов - это создать локальную переменную внутри цикла:

List<Func<int>> actions = new List<Func<int>>();
for (int i = 0; i < 3; i++)
{
    int localI = i;
    actions.Add(() => localI);
}

foreach (var action in actions)
{
    Console.WriteLine(action()); // Теперь будет выводиться 0, 1, 2
}

Создание локальной переменной localI внутри блока цикла гарантирует, что каждое лямбда-выражение захватывает свою собственную переменную, что приводит к ожидаемому результату.

Применение захваченных переменных в асинхронном программировании

Захваченные переменные могут играть ключевую роль в асинхронном программировании, где они используются для сохранения состояния между асинхронными операциями. В асинхронных методах важно понимать, как переменные захватываются и как они будут использоваться при возврате управления после ожидания асинхронной операции:

async Task<int> AccessCapturedVariableAsync()
{
    int result = 0;
    await Task.Run(() =>
    {
        result = 42;
    });
    return result; // Захваченное значение 'result' будет равно 42 после выполнения Task.Run
}

Влияние захваченных переменных на производительность

Захват переменных может влиять на производительность приложения, так как каждое захваченное значение требует дополнительной памяти для хранения контекста. В случае большого количества захваченных переменных или большой активности с захватом и освобождением памяти это может привести к увеличению нагрузки на сборщик мусора.

Лучшие практики работы с захваченными переменными

Чтобы оптимально использовать захваченные переменные, следует применять следующие лучшие практики:
- Избегайте ненужного захвата переменных, особенно в циклах.
- Используйте локальные переменные внутри циклов для точного контроля захвата.
- Помните, что захват переменных может повлиять на производительность и управление памятью.
- Проверяйте области видимости переменных при использовании анонимных функций и лямбд.

Заключение

Понимание захваченных переменных в C# и их поведения в циклах является важной частью разработки надежного и предсказуемого кода. Изучение и применение лучших практик работы с захваченными переменными помогает избегать ошибок и улучшает качество программного продукта. Помните о потенциальных подводных камнях и стремитесь писать код, который будет легко читаться и поддерживаться другими разработчиками.