Как вызывается деструктор?

Общий механизм вызова деструктора в Unity и C#

В контексте разработки на Unity с использованием C#, понятие деструктора имеет несколько аспектов, так как Unity сочетает управляемый код C# и неуправляемые ресурсы движка. Давайте разберем, как и когда вызываются деструкторы.

Деструкторы в чистом C#

В языке C# деструктор — это специальный метод класса, предназначенный для выполнения финальной очистки управляемых ресуров перед тем, как объект будет собран сборщиком мусора (Garbage Collector, GC).

• Синтаксис и имя: Деструктор объявляется с именем, совпадающим с именем класса, и prefixed символом тильды (~). У него нет модификаторов доступа, параметров и возвращаемого типа.
• Механизм вызова: Деструктор не вызывается явно программистом. Он автоматически вызывается сборщиком мщора (GC) в неопределенный момент времени после того, как объект становится недостижимым. Это означает, что вы не можете точно знать, когда именно это произойдет.

public class GameCharacter
{
    private string name;

    public GameCharacter(string characterName)
    {
        name = characterName;
        Debug.Log($"Персонаж {name} создан.");
    }

    // Деструктор
    ~GameCharacter()
    {
        // Выполнится когда-то в будущем, когда GC соберет этот объект.
        Debug.Log($"Персонаж {name} уничтожен сборщиком мусора.");
    }
}

Критически важные ограничения деструкторов в Unity

1. Непредсказуемость времени вызова: Это главный недостаток. Деструктор может быть вызван через несколько кадров, секунд или даже минут после того, как объект перестал использоваться. В игровом цикле с требованием к производительности это неприемлемо для очистки критичных ресурсов.
2. Отсутствие контроля: Вы не можете заставить GC запуститься в нужный вам момент (хотя можно инициировать сборку с помощью GC.Collect(), но это очень дорогая операция и считается плохой практикой).
3. Не подходит для освобождения неуправляемых ресурсов Unity: Большинство игровых объектов (GameObject), компонентов, текстур, мешей — это неуправляемые ресурсы, которыми управляет движок Unity. Деструктор C# не имеет прямого доступа к их своевременному освобождению.

Правильные альтернативы деструктору в Unity

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

1. Интерфейс IDisposable и паттерн Dispose

Для детерминированной очистки управляемых ресуров, которые сами используют неуправляемые ресурсы (например, файловые потоки, сетевые подключения).

public class ManagedResourceHandler : MonoBehaviour, System.IDisposable
{
    private System.IO.FileStream fileStream;

    public void OpenFile(string path)
    {
        fileStream = new System.IO.FileStream(path, System.IO.FileMode.Open);
    }

    // Метод для явной очистки
    public void Dispose()
    {
        if (fileStream != null)
        {
            fileStream.Close();
            fileStream = null;
            Debug.Log("Файловый поток явно закрыт.");
        }
        // Подавляем вызов финализатора, так как очистка уже выполнена.
        GC.SuppressFinalize(this);
    }

    // Деструктор (финализатор) - страховка на случай, если Dispose не был вызван.
    ~ManagedResourceHandler()
    {
        Dispose();
    }

    private void OnDestroy()
    {
        // В Unity хорошей практикой является вызов Dispose() в OnDestroy.
        Dispose();
    }
}

// Использование
void ProcessData()
{
    using (var handler = new ManagedResourceHandler())
    {
        handler.OpenFile("data.txt");
        // ... работа с данными
    } // При выходе из блока using автоматически вызовется handler.Dispose()
}

2. Методы жизненного цикла MonoBehaviour

Это основной и предпочтительный способ управления временем жизни игровых объектов и компонентов в Unity.

• OnDestroy(): Главный аналог деструктора в Unity. Вызывается движком детерминированно в четко определенный момент:

    *   При уничтожении объекта через `Destroy(gameObject)` или `Destroy(component)`.
    *   При завершении работы сцены, содержащей объект.
    *   При остановке игры в редакторе (в режиме Play).
    *   **Здесь нужно освобождать ссылки на другие Unity-объекты, отписываться от событий (`event`), останавливать созданные корутины.**

public class EnemyController : MonoBehaviour
{
    private ParticleSystem deathEffect;
    private GameManager manager;

    void Start()
    {
        manager = GameObject.FindObjectOfType<GameManager>();
        if (manager != null)
        {
            manager.OnGameOver += HandleGameOver; // Подписка на событие
        }
    }

    // Правильный способ "деструкции" в Unity
    private void OnDestroy()
    {
        // 1. Критично: Отписаться от событий!
        if (manager != null)
        {
            manager.OnGameOver -= HandleGameOver;
        }

        // 2. Явно остановить все запущенные корутины этого MonoBehaviour.
        StopAllCoroutines();

        // 3. Дополнительная логика очистки.
        Debug.Log($"{gameObject.name} уничтожен. Ресурсы освобождены.");
    }

    private void HandleGameOver()
    {
        // ...
    }
}

• OnDisable(): Вызывается при отключении компонента или объекта (SetActive(false)). Часто используется вместе с OnEnable() для управления подписками на события, которые должны быть активны только при включенном объекте.

3. Уничтожение GameObject и компонентов

Явный и моментальный вызов "деструктора" для Unity-объекта:

// Уничтожает игровой объект в конце текущего кадра.
Destroy(myGameObject);

// Уничтожает только конкретный компонент.
Destroy(myGameObject.GetComponent<EnemyController>());

// Уничтожает объект с задержкой в 5 секунд.
Destroy(myGameObject, 5f);

Итоговые рекомендации

• Всегда используйте OnDestroy() вместо деструктора C# для очистки, связанной с Unity.
• Для управления подписками на события (event) предпочтительнее использовать пару OnEnable()/OnDisable().
• Деструктор C# (~ClassName()) практически никогда не нужен в скриптах Unity. Его использование оправдано только в очень специфичных случаях низкоуровневых управляемых классов, не связанных напрямую с жизненным циклом GameObject.
• Для освобождения неуправляемых .NET-ресуров (FileStream, Socket) реализуйте интерфейс IDisposable и вызывайте Dispose() в OnDestroy().

Таким образом, в Unity "деструктор" вызывается явно и предсказуемо через вызов Destroy() или автоматически движком при переключении сцен, что приводит к выполнению метода OnDestroy() у соответствующих компонентов. Классические деструкторы C# в этом контексте считаются устаревшим и ненадежным инструментом.