Как происходит замыкание в коде?

Механизм замыкания в C# для Unity

В контексте разработки на C# для Unity, замыкание — это мощный механизм языка, который позволяет функции (или анонимному методу) "запоминать" и продолжать иметь доступ к переменным из своей внешней (охватывающей) области видимости, даже после того, как эта внешняя область завершила свое выполнение. Это фундаментально для реализации колбэков, отложенных действий и работы с корутинами (Coroutines).

Как это работает технически?

Компилятор C# при обнаружении замыкания создает скрытый класс-замыкание, который инкапсулирует захваченные переменные и тело анонимного метода. Этот класс генерируется автоматически.

Рассмотрим практический пример из Unity:

using UnityEngine;
using System;

public class ClosureExample : MonoBehaviour
{
    void Start()
    {
        int counter = 0; // Эта локальная переменная будет захвачена

        // Создание замыкания: делегат Action "запоминает" переменную counter
        Action incrementAndLog = () =>
        {
            counter++;
            Debug.Log($"Счетчик: {counter}");
        };

        // Вызовем делегат несколько раз. Он ВСЕГДА работает с той же переменной counter,
        // хотя по логике область видимости метода Start() уже завершилась.
        incrementAndLog(); // Вывод: Счетчик:158
        incrementAndLog(); // Вывод: Счетчик: 2
        incrementAndLog(); // Вывод: Счетчик: 3
    }
}

Ключевые моменты в работе замыканий:

• Захват по ссылке, а не по значению: Замыкание захватывает ссылку на переменную, а не её текущее значение на момент создания. Это критически важно для понимания.
• Продление времени жизни: Локальная переменная counter в примере выше перестает быть просто локальной переменной в стеке. Благодаря захвату в замыкание, ее время жизни продлевается до тех пор, пока существует делегат incrementAndLog.
• Сгенерированный класс: Компилятор преобразует код выше примерно в следующее (упрощенно):

private sealed class DisplayClass
{
    public int counter; // Захваченная переменная становится полем класса
    public void IncrementAndLog() // Тело лямбда–выражения становится методом
    {
        counter++;
        Debug.Log($"Счетчик: {counter}");
    }
}

void Start()
{
    DisplayClass locals = new DisplayClass();
    locals.counter = 0;
    Action incrementAndLog = new Action(locals.IncrementAndLog);
    incrementAndLog();
}

Типичные сценарии использования в Unity:

1. Обработчики событий UI (UGUI): Самый частый случай.

   for (int i = 0; i < 5; i++)
   {
       button[i].onClick.AddListener(() => Debug.Log($"Нажата кнопка {i}"));
   }
   

    **Внимание! Опасность!** Здесь захватывается переменная цикла `i` по ссылке. К моменту нажатия кнопки цикл уже завершился и `i` равно 5. Все 5 кнопок выведут "Нажата кнопка 5". **Решение:** создать локальную копию внутри области видимости итерации:

```csharp
for (int i = 0; i < 5; i++)
{
    int index = i; // Новая переменная для каждой итерации
    button[i].onClick.AddListener(() => Debug.Log($"Нажата кнопка {index}"));
}
```

2. Корутины с параметрами: Чтобы передать параметр в корутину при запуске. ```csharp IEnumerator DelayedSpawn(GameObject prefab, Vector3 position, float delay) { yield return new WaitForSeconds(delay); Instantiate(prefab, position, Quaternion.identity); }

void Start()
{
    float specificDelay = 2.5f;
    // Замыкание захватывает specificDelay, prefab и position
    StartCoroutine(DelayedSpawn(enemyPrefab, spawnPoint.position, specificDelay));
}
```

3. Колбэки в асинхронных операциях (например, при работе с Addressables или UnityWebRequest).

Важные предостережения для Unity-разработчика:

• Утечки памяти: Замыкание держит ссылки на все захваченные объекты (включая MonoBehaviour), предотвращая их сборку мусора. Если делегат живуч (например, статическое событие), это может привести к утечке памяти. Всегда отписывайтесь от событий (RemoveListener, -=).
• Производительность: Создание класса-замыкания — это аллокация в управляемой куче. В высокопроизводительных циклах (например, Update() с сотнями вызовов) это может создать нагрузку на GC (Garbage Collector). В таких случаях стоит рассмотреть альтернативы.

Таким образом, замыкание в C# — это не "магия", а элегантная синтаксическая абстракция, которую компилятор преобразует в явный класс, хранящий состояние. Понимание этого механизма позволяет избежать тонких багов и эффективно использовать его для создания гибкого и чистого кода в Unity.